diff --git a/.eslintrc.js b/.eslintrc.js
index 9a4dbec72..1fe96c594 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -30,12 +30,13 @@ module.exports = {
     globals: {
         Clipboard: true,
         clippy: true,
-        CodeMirror: true,
+        codeMirror: true,
         console: true,
         cssEditorUtils: true,
         editorConsole: true,
         featureDetector: true,
         mceAnalytics: true,
+        mceEvents: true,
         mceUtils: true,
         Prism: true,
         require: true
diff --git a/css/editable-js.css b/css/editable-js.css
index 1f05235d9..2eaffc6d1 100644
--- a/css/editable-js.css
+++ b/css/editable-js.css
@@ -3,6 +3,10 @@
     font-size: 14px;
 }
 
+.js .editor {
+    min-height: 280px;
+}
+
 .editor {
     position: relative;
     margin-bottom: 1em;
diff --git a/index.js b/index.js
index fc8178416..c18d2d864 100644
--- a/index.js
+++ b/index.js
@@ -8,6 +8,7 @@ const uglify = require('uglify-es');
 
 const config = {
     baseDir: './docs/',
+    codeMirrorModes: 'js/libs/mode',
     destCssDir: './docs/css/',
     destJsDir: './docs/js/',
     examplesDir: './docs/pages/',
@@ -49,16 +50,21 @@ function buildBundles(bundles) {
         let currentFilename = currentBundle.destFileName;
 
         if (currentBundle.javascript) {
+            let outputFileName = config.destJsDir + currentFilename + '.js';
+
             // ensure the target dir exists
             ensureDir(config.destJsDir);
 
+            if (bundle === 'codeMirror') {
+                // use a different output directory
+                outputFileName =
+                    config.destJsDir + 'libs/' + currentFilename + '.js';
+            }
+
             // concatenate, uglify, and write the result to file
             concat(currentBundle.javascript).then(function(result) {
                 let uglified = uglify.minify(result);
-                fse.outputFileSync(
-                    config.destJsDir + currentFilename + '.js',
-                    uglified.code
-                );
+                fse.outputFileSync(outputFileName, uglified.code);
             });
         }
 
@@ -160,7 +166,19 @@ function copyDirectory(sourceDir, destDir) {
 
         // copy all examples to target directory
         for (let file in files) {
-            fse.copySync(files[file], destDir + files[file]);
+            let currentFile = files[file];
+
+            // if it is the javascript mode file
+            if (currentFile.includes('javascript.js')) {
+                // we need to read the contents in
+                let fileContents = fse.readFileSync(currentFile, 'utf-8');
+                // minify the contents
+                let uglified = uglify.minify(fileContents);
+                // then only write the result out
+                fse.outputFileSync(destDir + files[file], uglified.code);
+            } else {
+                fse.copySync(files[file], destDir + files[file]);
+            }
         }
     });
 }
@@ -236,6 +254,8 @@ function init() {
             // copy assets in `/media`
             copyDirectory(config.mediaRoot, config.baseDir);
 
+            copyDirectory(config.codeMirrorModes, config.baseDir);
+
             // builds the CSS and JS bundles
             buildBundles(site.bundles);
             // generates the pages
diff --git a/js/editable-css.js b/js/editable-css.js
index 191e3641c..4a5168cb2 100644
--- a/js/editable-css.js
+++ b/js/editable-css.js
@@ -100,6 +100,9 @@
 
         clippy.addClippy();
 
+        // register events handlers
+        mceEvents.register();
+
         handleResetEvents();
     }
 
diff --git a/js/editable-js.js b/js/editable-js.js
index 8161a09a0..d510614e0 100644
--- a/js/editable-js.js
+++ b/js/editable-js.js
@@ -1,13 +1,13 @@
 (function() {
     'use strict';
 
-    var editorContainer = document.getElementById('editor');
+    var exampleFeature = document.getElementById('static-js').dataset[
+        'feature'
+    ];
     var execute = document.getElementById('execute');
     var liveContainer = '';
     var reset = document.getElementById('reset');
-    var codeMirror = undefined;
     var staticContainer;
-    var codeBlock;
 
     /**
      * Reads the textContent from the interactiveCodeBlock, sends the
@@ -23,21 +23,10 @@
         staticContainer = document.getElementById('static');
         staticContainer.classList.add('hidden');
 
-        codeBlock = staticContainer.querySelector('#static-js');
-
         liveContainer = document.getElementById('live');
         liveContainer.classList.remove('hidden');
 
-        // eslint-disable-next-line new-cap
-        codeMirror = CodeMirror(editorContainer, {
-            autofocus: true,
-            inputStyle: 'contenteditable',
-            lineNumbers: true,
-            mode: 'javascript',
-            undoDepth: 50,
-            tabindex: 0,
-            value: codeBlock.textContent
-        });
+        mceEvents.register();
     }
 
     /**
@@ -62,25 +51,22 @@
         });
     }
 
-    execute.addEventListener('click', function() {
-        editorConsole.clearOutput();
-        applyCode();
-    });
+    /* only execute JS in supported browsers. As `document.all`
+    is a non standard object available only in IE10 and older,
+    this will stop JS from executing in those versions. */
+    if (!document.all && featureDetector.isDefined(exampleFeature)) {
+        document.documentElement.classList.add('js');
 
-    reset.addEventListener('click', function() {
-        window.location.reload();
-    });
+        initInteractiveEditor();
 
-    window.addEventListener('load', function() {
-        var exampleFeature = document.getElementById('static-js').dataset[
-            'feature'
-        ];
+        execute.addEventListener('click', function() {
+            editorConsole.clearOutput();
+            applyCode();
+            mceAnalytics.trackRunClicks();
+        });
 
-        /* only execute JS in supported browsers. As `document.all`
-        is a non standard object available only in IE10 and older,
-        this will stop JS from executing in those versions. */
-        if (!document.all && featureDetector.isDefined(exampleFeature)) {
-            initInteractiveEditor();
-        }
-    });
+        reset.addEventListener('click', function() {
+            window.location.reload();
+        });
+    }
 })();
diff --git a/js/editor-libs/codemirrorLoader.js b/js/editor-libs/codemirrorLoader.js
new file mode 100644
index 000000000..73a3dc3bf
--- /dev/null
+++ b/js/editor-libs/codemirrorLoader.js
@@ -0,0 +1,16 @@
+require(['libs/codemirror'], function(CodeMirror) {
+    var codeBlock = document.getElementById('static-js');
+    var editorContainer = document.getElementById('editor');
+    // eslint-disable-next-line new-cap
+    var codeMirror = CodeMirror(editorContainer, {
+        autofocus: true,
+        inputStyle: 'contenteditable',
+        lineNumbers: true,
+        mode: 'javascript',
+        undoDepth: 10,
+        tabindex: 0,
+        value: codeBlock.textContent
+    });
+
+    window.codeMirror = codeMirror;
+});
diff --git a/js/editor-libs/console.js b/js/editor-libs/console.js
index fdde83b4e..12b911661 100644
--- a/js/editor-libs/console.js
+++ b/js/editor-libs/console.js
@@ -28,7 +28,7 @@
     function formatArray(input) {
         var output = '';
         for (var i = 0, l = input.length; i < l; i++) {
-            if (typeof(input[i]) === "string") {
+            if (typeof input[i] === 'string') {
                 output += '"' + input[i] + '"';
             } else if (Array.isArray(input[i])) {
                 output += '[';
@@ -38,7 +38,7 @@
                 output += input[i];
             }
 
-            if (i < (input.length - 1)) {
+            if (i < input.length - 1) {
                 output += ', ';
             }
         }
@@ -54,16 +54,16 @@
      * @param {any} input - The output to log.
      * @returns Formatted output as a string.
      */
-     function formatOutput(input) {
-         if (typeof(input) === "string") {
-             return '"' + input + '"';
-         } else if (Array.isArray(input)) {
-             // check the contents of the array
-             return '[' + formatArray(input) + ']';
-         } else {
-             return input;
-         }
-     }
+    function formatOutput(input) {
+        if (typeof input === 'string') {
+            return '"' + input + '"';
+        } else if (Array.isArray(input)) {
+            // check the contents of the array
+            return '[' + formatArray(input) + ']';
+        } else {
+            return input;
+        }
+    }
 
     /**
      * Writes the provided content to the editor’s output area
diff --git a/js/editor-libs/events.js b/js/editor-libs/events.js
index 8ca8d23b3..70ad609b0 100644
--- a/js/editor-libs/events.js
+++ b/js/editor-libs/events.js
@@ -2,7 +2,6 @@
     'use strict';
 
     var exampleChoiceList = document.getElementById('example-choice-list');
-    var liveEditorContainer = document.getElementById('live');
     var liveEditor = document.getElementById('editor');
 
     /**
@@ -57,101 +56,118 @@
         };
     }
 
-    // only bind events if the `exampleChoiceList` container exist
-    if (exampleChoiceList) {
-        sendPerformanceMetric('css');
+    var Events = {
+        attachCSSEditorEventListeners: function() {
+            exampleChoiceList.addEventListener('cut', copyTextOnly);
+            exampleChoiceList.addEventListener('copy', copyTextOnly);
+            exampleChoiceList.addEventListener('paste', handlePasteEvents);
 
-        exampleChoiceList.addEventListener('cut', copyTextOnly);
-        exampleChoiceList.addEventListener('copy', copyTextOnly);
-        exampleChoiceList.addEventListener('paste', handlePasteEvents);
-
-        exampleChoiceList.addEventListener('keydown', function() {
-            if (!localStorage.getItem('firstCSSEditRecorded')) {
-                mceAnalytics.trackFirstEdit('css');
-            }
-        });
+            exampleChoiceList.addEventListener('keydown', function() {
+                if (!localStorage.getItem('firstCSSEditRecorded')) {
+                    mceAnalytics.trackFirstEdit('css');
+                }
+            });
+
+            exampleChoiceList.addEventListener('keyup', function(event) {
+                var exampleChoiceParent =
+                    event.target.parentElement.parentElement;
+                cssEditorUtils.applyCode(
+                    exampleChoiceParent.textContent,
+                    exampleChoiceParent
+                );
+            });
+
+            exampleChoiceList.addEventListener('click', function(event) {
+                var target = event.target;
+
+                // if the original target is not an `example-choice` element
+                if (!target.classList.contains('example-choice')) {
+                    // find this element's `example-choice` parent
+                    target = mceUtils.findParentChoiceElem(target);
+                }
 
-        exampleChoiceList.addEventListener('keyup', function(event) {
-            var exampleChoiceParent = event.target.parentElement.parentElement;
-            cssEditorUtils.applyCode(
-                exampleChoiceParent.textContent,
-                exampleChoiceParent
+                // and pass it on the `onChoose`
+                cssEditorUtils.onChoose(target);
+            });
+        },
+        attachJSEditorEventListeners: function() {
+            liveEditor.addEventListener('keyup', function() {
+                if (!localStorage.getItem('firstJSEditRecorded')) {
+                    mceAnalytics.trackFirstEdit('js');
+                }
+            });
+        },
+        attachJSErrorListener: function() {
+            /**
+             * Catches JavaScript errors from the editor that bubble up to the
+             * window and passes them on to GA
+             */
+            window.onerror = function(msg, url, lineNo, columnNo, error) {
+                var errorDetails = [
+                    'URL: ' + url,
+                    'Line: ' + lineNo,
+                    'Column: ' + columnNo,
+                    'Error object: ' + JSON.stringify(error)
+                ].join(' - ');
+
+                mceAnalytics.trackEvent({
+                    category: 'Interactive Example - JavaScript Errors',
+                    action: errorDetails,
+                    label: msg
+                });
+            };
+        },
+        attachPostMessageListener: function() {
+            // listens for post message from Kuma
+            window.addEventListener(
+                'message',
+                function(event) {
+                    var isExpectedOrigin =
+                        event.origin === 'https://developer.mozilla.org';
+
+                    /* there may be other post messages so, ensure that the origin is as
+                    expected and, that `event.data` contains an `smallViewport` property */
+                    if (
+                        isExpectedOrigin &&
+                        typeof event.data.smallViewport !== undefined
+                    ) {
+                        var editorWrapper = document.querySelector(
+                            '.editor-wrapper'
+                        );
+
+                        if (event.data.smallViewport) {
+                            editorWrapper.classList.add(
+                                'small-desktop-and-below'
+                            );
+                        } else {
+                            editorWrapper.classList.remove(
+                                'small-desktop-and-below'
+                            );
+                        }
+                    }
+                },
+                false
             );
-        });
-
-        exampleChoiceList.addEventListener('click', function(event) {
-            var target = event.target;
-
-            // if the original target is not an `example-choice` element
-            if (!target.classList.contains('example-choice')) {
-                // find this element's `example-choice` parent
-                target = mceUtils.findParentChoiceElem(target);
-            }
-
-            // and pass it on the `onChoose`
-            cssEditorUtils.onChoose(target);
-        });
-    }
-
-    if (liveEditor) {
-        sendPerformanceMetric('js');
-
-        liveEditorContainer.addEventListener('click', function(event) {
-            switch (event.target.id) {
-            case 'execute':
-                mceAnalytics.trackRunClicks();
-                break;
-            }
-        });
-
-        liveEditor.addEventListener('keyup', function() {
-            if (!localStorage.getItem('firstJSEditRecorded')) {
-                mceAnalytics.trackFirstEdit('js');
+        },
+        /**
+         * Called by the main JS file after all other initialization
+         * has been completed.
+         */
+        register: function() {
+            this.attachPostMessageListener();
+            this.attachJSErrorListener();
+
+            // only bind events if the `exampleChoiceList` container exist
+            if (exampleChoiceList) {
+                sendPerformanceMetric('css');
+                this.attachCSSEditorEventListeners();
             }
-        });
-    }
 
-    // listens for post message from Kuma
-    window.addEventListener(
-        'message',
-        function(event) {
-            var isExpectedOrigin =
-                event.origin === 'https://developer.mozilla.org';
-
-            /* there may be other post messages so, ensure that the origin is the
-            expected and, that `event.data` contains an `smallViewport` property */
-            if (
-                isExpectedOrigin &&
-                typeof event.data.smallViewport !== undefined
-            ) {
-                var editorWrapper = document.querySelector('.editor-wrapper');
-
-                if (event.data.smallViewport) {
-                    editorWrapper.classList.add('small-desktop-and-below');
-                } else {
-                    editorWrapper.classList.remove('small-desktop-and-below');
-                }
+            if (liveEditor) {
+                sendPerformanceMetric('js');
             }
-        },
-        false
-    );
-
-    /**
-     * Catches JavaScript errors from the editor that bubble up to the
-     * window and passes them on to GA
-     */
-    window.onerror = function(msg, url, lineNo, columnNo, error) {
-        var errorDetails = [
-            'URL: ' + url,
-            'Line: ' + lineNo,
-            'Column: ' + columnNo,
-            'Error object: ' + JSON.stringify(error)
-        ].join(' - ');
-
-        mceAnalytics.trackEvent({
-            category: 'Interactive Example - JavaScript Errors',
-            action: errorDetails,
-            label: msg
-        });
+        }
     };
+
+    window.mceEvents = Events;
 })();
diff --git a/js/libs/javascript.js b/js/libs/mode/javascript/javascript.js
similarity index 100%
rename from js/libs/javascript.js
rename to js/libs/mode/javascript/javascript.js
diff --git a/js/require.js b/js/require.js
new file mode 100644
index 000000000..051e284b0
--- /dev/null
+++ b/js/require.js
@@ -0,0 +1,2145 @@
+/** vim: et:ts=4:sw=4:sts=4
+ * @license RequireJS 2.3.5 Copyright jQuery Foundation and other contributors.
+ * Released under MIT license, https://github.com/requirejs/requirejs/blob/master/LICENSE
+ */
+//Not using strict: uneven strict support in browsers, #392, and causes
+//problems with requirejs.exec()/transpiler plugins that may not be strict.
+/*jslint regexp: true, nomen: true, sloppy: true */
+/*global window, navigator, document, importScripts, setTimeout, opera */
+
+var requirejs, require, define;
+(function (global, setTimeout) {
+    var req, s, head, baseElement, dataMain, src,
+        interactiveScript, currentlyAddingScript, mainScript, subPath,
+        version = '2.3.5',
+        commentRegExp = /\/\*[\s\S]*?\*\/|([^:"'=]|^)\/\/.*$/mg,
+        cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,
+        jsSuffixRegExp = /\.js$/,
+        currDirRegExp = /^\.\//,
+        op = Object.prototype,
+        ostring = op.toString,
+        hasOwn = op.hasOwnProperty,
+        isBrowser = !!(typeof window !== 'undefined' && typeof navigator !== 'undefined' && window.document),
+        isWebWorker = !isBrowser && typeof importScripts !== 'undefined',
+        //PS3 indicates loaded and complete, but need to wait for complete
+        //specifically. Sequence is 'loading', 'loaded', execution,
+        // then 'complete'. The UA check is unfortunate, but not sure how
+        //to feature test w/o causing perf issues.
+        readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ?
+                      /^complete$/ : /^(complete|loaded)$/,
+        defContextName = '_',
+        //Oh the tragedy, detecting opera. See the usage of isOpera for reason.
+        isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]',
+        contexts = {},
+        cfg = {},
+        globalDefQueue = [],
+        useInteractive = false;
+
+    //Could match something like ')//comment', do not lose the prefix to comment.
+    function commentReplace(match, singlePrefix) {
+        return singlePrefix || '';
+    }
+
+    function isFunction(it) {
+        return ostring.call(it) === '[object Function]';
+    }
+
+    function isArray(it) {
+        return ostring.call(it) === '[object Array]';
+    }
+
+    /**
+     * Helper function for iterating over an array. If the func returns
+     * a true value, it will break out of the loop.
+     */
+    function each(ary, func) {
+        if (ary) {
+            var i;
+            for (i = 0; i < ary.length; i += 1) {
+                if (ary[i] && func(ary[i], i, ary)) {
+                    break;
+                }
+            }
+        }
+    }
+
+    /**
+     * Helper function for iterating over an array backwards. If the func
+     * returns a true value, it will break out of the loop.
+     */
+    function eachReverse(ary, func) {
+        if (ary) {
+            var i;
+            for (i = ary.length - 1; i > -1; i -= 1) {
+                if (ary[i] && func(ary[i], i, ary)) {
+                    break;
+                }
+            }
+        }
+    }
+
+    function hasProp(obj, prop) {
+        return hasOwn.call(obj, prop);
+    }
+
+    function getOwn(obj, prop) {
+        return hasProp(obj, prop) && obj[prop];
+    }
+
+    /**
+     * Cycles over properties in an object and calls a function for each
+     * property value. If the function returns a truthy value, then the
+     * iteration is stopped.
+     */
+    function eachProp(obj, func) {
+        var prop;
+        for (prop in obj) {
+            if (hasProp(obj, prop)) {
+                if (func(obj[prop], prop)) {
+                    break;
+                }
+            }
+        }
+    }
+
+    /**
+     * Simple function to mix in properties from source into target,
+     * but only if target does not already have a property of the same name.
+     */
+    function mixin(target, source, force, deepStringMixin) {
+        if (source) {
+            eachProp(source, function (value, prop) {
+                if (force || !hasProp(target, prop)) {
+                    if (deepStringMixin && typeof value === 'object' && value &&
+                        !isArray(value) && !isFunction(value) &&
+                        !(value instanceof RegExp)) {
+
+                        if (!target[prop]) {
+                            target[prop] = {};
+                        }
+                        mixin(target[prop], value, force, deepStringMixin);
+                    } else {
+                        target[prop] = value;
+                    }
+                }
+            });
+        }
+        return target;
+    }
+
+    //Similar to Function.prototype.bind, but the 'this' object is specified
+    //first, since it is easier to read/figure out what 'this' will be.
+    function bind(obj, fn) {
+        return function () {
+            return fn.apply(obj, arguments);
+        };
+    }
+
+    function scripts() {
+        return document.getElementsByTagName('script');
+    }
+
+    function defaultOnError(err) {
+        throw err;
+    }
+
+    //Allow getting a global that is expressed in
+    //dot notation, like 'a.b.c'.
+    function getGlobal(value) {
+        if (!value) {
+            return value;
+        }
+        var g = global;
+        each(value.split('.'), function (part) {
+            g = g[part];
+        });
+        return g;
+    }
+
+    /**
+     * Constructs an error with a pointer to an URL with more information.
+     * @param {String} id the error ID that maps to an ID on a web page.
+     * @param {String} message human readable error.
+     * @param {Error} [err] the original error, if there is one.
+     *
+     * @returns {Error}
+     */
+    function makeError(id, msg, err, requireModules) {
+        var e = new Error(msg + '\nhttp://requirejs.org/docs/errors.html#' + id);
+        e.requireType = id;
+        e.requireModules = requireModules;
+        if (err) {
+            e.originalError = err;
+        }
+        return e;
+    }
+
+    if (typeof define !== 'undefined') {
+        //If a define is already in play via another AMD loader,
+        //do not overwrite.
+        return;
+    }
+
+    if (typeof requirejs !== 'undefined') {
+        if (isFunction(requirejs)) {
+            //Do not overwrite an existing requirejs instance.
+            return;
+        }
+        cfg = requirejs;
+        requirejs = undefined;
+    }
+
+    //Allow for a require config object
+    if (typeof require !== 'undefined' && !isFunction(require)) {
+        //assume it is a config object.
+        cfg = require;
+        require = undefined;
+    }
+
+    function newContext(contextName) {
+        var inCheckLoaded, Module, context, handlers,
+            checkLoadedTimeoutId,
+            config = {
+                //Defaults. Do not set a default for map
+                //config to speed up normalize(), which
+                //will run faster if there is no default.
+                waitSeconds: 7,
+                baseUrl: './',
+                paths: {},
+                bundles: {},
+                pkgs: {},
+                shim: {},
+                config: {}
+            },
+            registry = {},
+            //registry of just enabled modules, to speed
+            //cycle breaking code when lots of modules
+            //are registered, but not activated.
+            enabledRegistry = {},
+            undefEvents = {},
+            defQueue = [],
+            defined = {},
+            urlFetched = {},
+            bundlesMap = {},
+            requireCounter = 1,
+            unnormalizedCounter = 1;
+
+        /**
+         * Trims the . and .. from an array of path segments.
+         * It will keep a leading path segment if a .. will become
+         * the first path segment, to help with module name lookups,
+         * which act like paths, but can be remapped. But the end result,
+         * all paths that use this function should look normalized.
+         * NOTE: this method MODIFIES the input array.
+         * @param {Array} ary the array of path segments.
+         */
+        function trimDots(ary) {
+            var i, part;
+            for (i = 0; i < ary.length; i++) {
+                part = ary[i];
+                if (part === '.') {
+                    ary.splice(i, 1);
+                    i -= 1;
+                } else if (part === '..') {
+                    // If at the start, or previous value is still ..,
+                    // keep them so that when converted to a path it may
+                    // still work when converted to a path, even though
+                    // as an ID it is less than ideal. In larger point
+                    // releases, may be better to just kick out an error.
+                    if (i === 0 || (i === 1 && ary[2] === '..') || ary[i - 1] === '..') {
+                        continue;
+                    } else if (i > 0) {
+                        ary.splice(i - 1, 2);
+                        i -= 2;
+                    }
+                }
+            }
+        }
+
+        /**
+         * Given a relative module name, like ./something, normalize it to
+         * a real name that can be mapped to a path.
+         * @param {String} name the relative name
+         * @param {String} baseName a real name that the name arg is relative
+         * to.
+         * @param {Boolean} applyMap apply the map config to the value. Should
+         * only be done if this normalization is for a dependency ID.
+         * @returns {String} normalized name
+         */
+        function normalize(name, baseName, applyMap) {
+            var pkgMain, mapValue, nameParts, i, j, nameSegment, lastIndex,
+                foundMap, foundI, foundStarMap, starI, normalizedBaseParts,
+                baseParts = (baseName && baseName.split('/')),
+                map = config.map,
+                starMap = map && map['*'];
+
+            //Adjust any relative paths.
+            if (name) {
+                name = name.split('/');
+                lastIndex = name.length - 1;
+
+                // If wanting node ID compatibility, strip .js from end
+                // of IDs. Have to do this here, and not in nameToUrl
+                // because node allows either .js or non .js to map
+                // to same file.
+                if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
+                    name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
+                }
+
+                // Starts with a '.' so need the baseName
+                if (name[0].charAt(0) === '.' && baseParts) {
+                    //Convert baseName to array, and lop off the last part,
+                    //so that . matches that 'directory' and not name of the baseName's
+                    //module. For instance, baseName of 'one/two/three', maps to
+                    //'one/two/three.js', but we want the directory, 'one/two' for
+                    //this normalization.
+                    normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
+                    name = normalizedBaseParts.concat(name);
+                }
+
+                trimDots(name);
+                name = name.join('/');
+            }
+
+            //Apply map config if available.
+            if (applyMap && map && (baseParts || starMap)) {
+                nameParts = name.split('/');
+
+                outerLoop: for (i = nameParts.length; i > 0; i -= 1) {
+                    nameSegment = nameParts.slice(0, i).join('/');
+
+                    if (baseParts) {
+                        //Find the longest baseName segment match in the config.
+                        //So, do joins on the biggest to smallest lengths of baseParts.
+                        for (j = baseParts.length; j > 0; j -= 1) {
+                            mapValue = getOwn(map, baseParts.slice(0, j).join('/'));
+
+                            //baseName segment has config, find if it has one for
+                            //this name.
+                            if (mapValue) {
+                                mapValue = getOwn(mapValue, nameSegment);
+                                if (mapValue) {
+                                    //Match, update name to the new value.
+                                    foundMap = mapValue;
+                                    foundI = i;
+                                    break outerLoop;
+                                }
+                            }
+                        }
+                    }
+
+                    //Check for a star map match, but just hold on to it,
+                    //if there is a shorter segment match later in a matching
+                    //config, then favor over this star map.
+                    if (!foundStarMap && starMap && getOwn(starMap, nameSegment)) {
+                        foundStarMap = getOwn(starMap, nameSegment);
+                        starI = i;
+                    }
+                }
+
+                if (!foundMap && foundStarMap) {
+                    foundMap = foundStarMap;
+                    foundI = starI;
+                }
+
+                if (foundMap) {
+                    nameParts.splice(0, foundI, foundMap);
+                    name = nameParts.join('/');
+                }
+            }
+
+            // If the name points to a package's name, use
+            // the package main instead.
+            pkgMain = getOwn(config.pkgs, name);
+
+            return pkgMain ? pkgMain : name;
+        }
+
+        function removeScript(name) {
+            if (isBrowser) {
+                each(scripts(), function (scriptNode) {
+                    if (scriptNode.getAttribute('data-requiremodule') === name &&
+                            scriptNode.getAttribute('data-requirecontext') === context.contextName) {
+                        scriptNode.parentNode.removeChild(scriptNode);
+                        return true;
+                    }
+                });
+            }
+        }
+
+        function hasPathFallback(id) {
+            var pathConfig = getOwn(config.paths, id);
+            if (pathConfig && isArray(pathConfig) && pathConfig.length > 1) {
+                //Pop off the first array value, since it failed, and
+                //retry
+                pathConfig.shift();
+                context.require.undef(id);
+
+                //Custom require that does not do map translation, since
+                //ID is "absolute", already mapped/resolved.
+                context.makeRequire(null, {
+                    skipMap: true
+                })([id]);
+
+                return true;
+            }
+        }
+
+        //Turns a plugin!resource to [plugin, resource]
+        //with the plugin being undefined if the name
+        //did not have a plugin prefix.
+        function splitPrefix(name) {
+            var prefix,
+                index = name ? name.indexOf('!') : -1;
+            if (index > -1) {
+                prefix = name.substring(0, index);
+                name = name.substring(index + 1, name.length);
+            }
+            return [prefix, name];
+        }
+
+        /**
+         * Creates a module mapping that includes plugin prefix, module
+         * name, and path. If parentModuleMap is provided it will
+         * also normalize the name via require.normalize()
+         *
+         * @param {String} name the module name
+         * @param {String} [parentModuleMap] parent module map
+         * for the module name, used to resolve relative names.
+         * @param {Boolean} isNormalized: is the ID already normalized.
+         * This is true if this call is done for a define() module ID.
+         * @param {Boolean} applyMap: apply the map config to the ID.
+         * Should only be true if this map is for a dependency.
+         *
+         * @returns {Object}
+         */
+        function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {
+            var url, pluginModule, suffix, nameParts,
+                prefix = null,
+                parentName = parentModuleMap ? parentModuleMap.name : null,
+                originalName = name,
+                isDefine = true,
+                normalizedName = '';
+
+            //If no name, then it means it is a require call, generate an
+            //internal name.
+            if (!name) {
+                isDefine = false;
+                name = '_@r' + (requireCounter += 1);
+            }
+
+            nameParts = splitPrefix(name);
+            prefix = nameParts[0];
+            name = nameParts[1];
+
+            if (prefix) {
+                prefix = normalize(prefix, parentName, applyMap);
+                pluginModule = getOwn(defined, prefix);
+            }
+
+            //Account for relative paths if there is a base name.
+            if (name) {
+                if (prefix) {
+                    if (isNormalized) {
+                        normalizedName = name;
+                    } else if (pluginModule && pluginModule.normalize) {
+                        //Plugin is loaded, use its normalize method.
+                        normalizedName = pluginModule.normalize(name, function (name) {
+                            return normalize(name, parentName, applyMap);
+                        });
+                    } else {
+                        // If nested plugin references, then do not try to
+                        // normalize, as it will not normalize correctly. This
+                        // places a restriction on resourceIds, and the longer
+                        // term solution is not to normalize until plugins are
+                        // loaded and all normalizations to allow for async
+                        // loading of a loader plugin. But for now, fixes the
+                        // common uses. Details in #1131
+                        normalizedName = name.indexOf('!') === -1 ?
+                                         normalize(name, parentName, applyMap) :
+                                         name;
+                    }
+                } else {
+                    //A regular module.
+                    normalizedName = normalize(name, parentName, applyMap);
+
+                    //Normalized name may be a plugin ID due to map config
+                    //application in normalize. The map config values must
+                    //already be normalized, so do not need to redo that part.
+                    nameParts = splitPrefix(normalizedName);
+                    prefix = nameParts[0];
+                    normalizedName = nameParts[1];
+                    isNormalized = true;
+
+                    url = context.nameToUrl(normalizedName);
+                }
+            }
+
+            //If the id is a plugin id that cannot be determined if it needs
+            //normalization, stamp it with a unique ID so two matching relative
+            //ids that may conflict can be separate.
+            suffix = prefix && !pluginModule && !isNormalized ?
+                     '_unnormalized' + (unnormalizedCounter += 1) :
+                     '';
+
+            return {
+                prefix: prefix,
+                name: normalizedName,
+                parentMap: parentModuleMap,
+                unnormalized: !!suffix,
+                url: url,
+                originalName: originalName,
+                isDefine: isDefine,
+                id: (prefix ?
+                        prefix + '!' + normalizedName :
+                        normalizedName) + suffix
+            };
+        }
+
+        function getModule(depMap) {
+            var id = depMap.id,
+                mod = getOwn(registry, id);
+
+            if (!mod) {
+                mod = registry[id] = new context.Module(depMap);
+            }
+
+            return mod;
+        }
+
+        function on(depMap, name, fn) {
+            var id = depMap.id,
+                mod = getOwn(registry, id);
+
+            if (hasProp(defined, id) &&
+                    (!mod || mod.defineEmitComplete)) {
+                if (name === 'defined') {
+                    fn(defined[id]);
+                }
+            } else {
+                mod = getModule(depMap);
+                if (mod.error && name === 'error') {
+                    fn(mod.error);
+                } else {
+                    mod.on(name, fn);
+                }
+            }
+        }
+
+        function onError(err, errback) {
+            var ids = err.requireModules,
+                notified = false;
+
+            if (errback) {
+                errback(err);
+            } else {
+                each(ids, function (id) {
+                    var mod = getOwn(registry, id);
+                    if (mod) {
+                        //Set error on module, so it skips timeout checks.
+                        mod.error = err;
+                        if (mod.events.error) {
+                            notified = true;
+                            mod.emit('error', err);
+                        }
+                    }
+                });
+
+                if (!notified) {
+                    req.onError(err);
+                }
+            }
+        }
+
+        /**
+         * Internal method to transfer globalQueue items to this context's
+         * defQueue.
+         */
+        function takeGlobalQueue() {
+            //Push all the globalDefQueue items into the context's defQueue
+            if (globalDefQueue.length) {
+                each(globalDefQueue, function(queueItem) {
+                    var id = queueItem[0];
+                    if (typeof id === 'string') {
+                        context.defQueueMap[id] = true;
+                    }
+                    defQueue.push(queueItem);
+                });
+                globalDefQueue = [];
+            }
+        }
+
+        handlers = {
+            'require': function (mod) {
+                if (mod.require) {
+                    return mod.require;
+                } else {
+                    return (mod.require = context.makeRequire(mod.map));
+                }
+            },
+            'exports': function (mod) {
+                mod.usingExports = true;
+                if (mod.map.isDefine) {
+                    if (mod.exports) {
+                        return (defined[mod.map.id] = mod.exports);
+                    } else {
+                        return (mod.exports = defined[mod.map.id] = {});
+                    }
+                }
+            },
+            'module': function (mod) {
+                if (mod.module) {
+                    return mod.module;
+                } else {
+                    return (mod.module = {
+                        id: mod.map.id,
+                        uri: mod.map.url,
+                        config: function () {
+                            return getOwn(config.config, mod.map.id) || {};
+                        },
+                        exports: mod.exports || (mod.exports = {})
+                    });
+                }
+            }
+        };
+
+        function cleanRegistry(id) {
+            //Clean up machinery used for waiting modules.
+            delete registry[id];
+            delete enabledRegistry[id];
+        }
+
+        function breakCycle(mod, traced, processed) {
+            var id = mod.map.id;
+
+            if (mod.error) {
+                mod.emit('error', mod.error);
+            } else {
+                traced[id] = true;
+                each(mod.depMaps, function (depMap, i) {
+                    var depId = depMap.id,
+                        dep = getOwn(registry, depId);
+
+                    //Only force things that have not completed
+                    //being defined, so still in the registry,
+                    //and only if it has not been matched up
+                    //in the module already.
+                    if (dep && !mod.depMatched[i] && !processed[depId]) {
+                        if (getOwn(traced, depId)) {
+                            mod.defineDep(i, defined[depId]);
+                            mod.check(); //pass false?
+                        } else {
+                            breakCycle(dep, traced, processed);
+                        }
+                    }
+                });
+                processed[id] = true;
+            }
+        }
+
+        function checkLoaded() {
+            var err, usingPathFallback,
+                waitInterval = config.waitSeconds * 1000,
+                //It is possible to disable the wait interval by using waitSeconds of 0.
+                expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
+                noLoads = [],
+                reqCalls = [],
+                stillLoading = false,
+                needCycleCheck = true;
+
+            //Do not bother if this call was a result of a cycle break.
+            if (inCheckLoaded) {
+                return;
+            }
+
+            inCheckLoaded = true;
+
+            //Figure out the state of all the modules.
+            eachProp(enabledRegistry, function (mod) {
+                var map = mod.map,
+                    modId = map.id;
+
+                //Skip things that are not enabled or in error state.
+                if (!mod.enabled) {
+                    return;
+                }
+
+                if (!map.isDefine) {
+                    reqCalls.push(mod);
+                }
+
+                if (!mod.error) {
+                    //If the module should be executed, and it has not
+                    //been inited and time is up, remember it.
+                    if (!mod.inited && expired) {
+                        if (hasPathFallback(modId)) {
+                            usingPathFallback = true;
+                            stillLoading = true;
+                        } else {
+                            noLoads.push(modId);
+                            removeScript(modId);
+                        }
+                    } else if (!mod.inited && mod.fetched && map.isDefine) {
+                        stillLoading = true;
+                        if (!map.prefix) {
+                            //No reason to keep looking for unfinished
+                            //loading. If the only stillLoading is a
+                            //plugin resource though, keep going,
+                            //because it may be that a plugin resource
+                            //is waiting on a non-plugin cycle.
+                            return (needCycleCheck = false);
+                        }
+                    }
+                }
+            });
+
+            if (expired && noLoads.length) {
+                //If wait time expired, throw error of unloaded modules.
+                err = makeError('timeout', 'Load timeout for modules: ' + noLoads, null, noLoads);
+                err.contextName = context.contextName;
+                return onError(err);
+            }
+
+            //Not expired, check for a cycle.
+            if (needCycleCheck) {
+                each(reqCalls, function (mod) {
+                    breakCycle(mod, {}, {});
+                });
+            }
+
+            //If still waiting on loads, and the waiting load is something
+            //other than a plugin resource, or there are still outstanding
+            //scripts, then just try back later.
+            if ((!expired || usingPathFallback) && stillLoading) {
+                //Something is still waiting to load. Wait for it, but only
+                //if a timeout is not already in effect.
+                if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {
+                    checkLoadedTimeoutId = setTimeout(function () {
+                        checkLoadedTimeoutId = 0;
+                        checkLoaded();
+                    }, 50);
+                }
+            }
+
+            inCheckLoaded = false;
+        }
+
+        Module = function (map) {
+            this.events = getOwn(undefEvents, map.id) || {};
+            this.map = map;
+            this.shim = getOwn(config.shim, map.id);
+            this.depExports = [];
+            this.depMaps = [];
+            this.depMatched = [];
+            this.pluginMaps = {};
+            this.depCount = 0;
+
+            /* this.exports this.factory
+               this.depMaps = [],
+               this.enabled, this.fetched
+            */
+        };
+
+        Module.prototype = {
+            init: function (depMaps, factory, errback, options) {
+                options = options || {};
+
+                //Do not do more inits if already done. Can happen if there
+                //are multiple define calls for the same module. That is not
+                //a normal, common case, but it is also not unexpected.
+                if (this.inited) {
+                    return;
+                }
+
+                this.factory = factory;
+
+                if (errback) {
+                    //Register for errors on this module.
+                    this.on('error', errback);
+                } else if (this.events.error) {
+                    //If no errback already, but there are error listeners
+                    //on this module, set up an errback to pass to the deps.
+                    errback = bind(this, function (err) {
+                        this.emit('error', err);
+                    });
+                }
+
+                //Do a copy of the dependency array, so that
+                //source inputs are not modified. For example
+                //"shim" deps are passed in here directly, and
+                //doing a direct modification of the depMaps array
+                //would affect that config.
+                this.depMaps = depMaps && depMaps.slice(0);
+
+                this.errback = errback;
+
+                //Indicate this module has be initialized
+                this.inited = true;
+
+                this.ignore = options.ignore;
+
+                //Could have option to init this module in enabled mode,
+                //or could have been previously marked as enabled. However,
+                //the dependencies are not known until init is called. So
+                //if enabled previously, now trigger dependencies as enabled.
+                if (options.enabled || this.enabled) {
+                    //Enable this module and dependencies.
+                    //Will call this.check()
+                    this.enable();
+                } else {
+                    this.check();
+                }
+            },
+
+            defineDep: function (i, depExports) {
+                //Because of cycles, defined callback for a given
+                //export can be called more than once.
+                if (!this.depMatched[i]) {
+                    this.depMatched[i] = true;
+                    this.depCount -= 1;
+                    this.depExports[i] = depExports;
+                }
+            },
+
+            fetch: function () {
+                if (this.fetched) {
+                    return;
+                }
+                this.fetched = true;
+
+                context.startTime = (new Date()).getTime();
+
+                var map = this.map;
+
+                //If the manager is for a plugin managed resource,
+                //ask the plugin to load it now.
+                if (this.shim) {
+                    context.makeRequire(this.map, {
+                        enableBuildCallback: true
+                    })(this.shim.deps || [], bind(this, function () {
+                        return map.prefix ? this.callPlugin() : this.load();
+                    }));
+                } else {
+                    //Regular dependency.
+                    return map.prefix ? this.callPlugin() : this.load();
+                }
+            },
+
+            load: function () {
+                var url = this.map.url;
+
+                //Regular dependency.
+                if (!urlFetched[url]) {
+                    urlFetched[url] = true;
+                    context.load(this.map.id, url);
+                }
+            },
+
+            /**
+             * Checks if the module is ready to define itself, and if so,
+             * define it.
+             */
+            check: function () {
+                if (!this.enabled || this.enabling) {
+                    return;
+                }
+
+                var err, cjsModule,
+                    id = this.map.id,
+                    depExports = this.depExports,
+                    exports = this.exports,
+                    factory = this.factory;
+
+                if (!this.inited) {
+                    // Only fetch if not already in the defQueue.
+                    if (!hasProp(context.defQueueMap, id)) {
+                        this.fetch();
+                    }
+                } else if (this.error) {
+                    this.emit('error', this.error);
+                } else if (!this.defining) {
+                    //The factory could trigger another require call
+                    //that would result in checking this module to
+                    //define itself again. If already in the process
+                    //of doing that, skip this work.
+                    this.defining = true;
+
+                    if (this.depCount < 1 && !this.defined) {
+                        if (isFunction(factory)) {
+                            //If there is an error listener, favor passing
+                            //to that instead of throwing an error. However,
+                            //only do it for define()'d  modules. require
+                            //errbacks should not be called for failures in
+                            //their callbacks (#699). However if a global
+                            //onError is set, use that.
+                            if ((this.events.error && this.map.isDefine) ||
+                                req.onError !== defaultOnError) {
+                                try {
+                                    exports = context.execCb(id, factory, depExports, exports);
+                                } catch (e) {
+                                    err = e;
+                                }
+                            } else {
+                                exports = context.execCb(id, factory, depExports, exports);
+                            }
+
+                            // Favor return value over exports. If node/cjs in play,
+                            // then will not have a return value anyway. Favor
+                            // module.exports assignment over exports object.
+                            if (this.map.isDefine && exports === undefined) {
+                                cjsModule = this.module;
+                                if (cjsModule) {
+                                    exports = cjsModule.exports;
+                                } else if (this.usingExports) {
+                                    //exports already set the defined value.
+                                    exports = this.exports;
+                                }
+                            }
+
+                            if (err) {
+                                err.requireMap = this.map;
+                                err.requireModules = this.map.isDefine ? [this.map.id] : null;
+                                err.requireType = this.map.isDefine ? 'define' : 'require';
+                                return onError((this.error = err));
+                            }
+
+                        } else {
+                            //Just a literal value
+                            exports = factory;
+                        }
+
+                        this.exports = exports;
+
+                        if (this.map.isDefine && !this.ignore) {
+                            defined[id] = exports;
+
+                            if (req.onResourceLoad) {
+                                var resLoadMaps = [];
+                                each(this.depMaps, function (depMap) {
+                                    resLoadMaps.push(depMap.normalizedMap || depMap);
+                                });
+                                req.onResourceLoad(context, this.map, resLoadMaps);
+                            }
+                        }
+
+                        //Clean up
+                        cleanRegistry(id);
+
+                        this.defined = true;
+                    }
+
+                    //Finished the define stage. Allow calling check again
+                    //to allow define notifications below in the case of a
+                    //cycle.
+                    this.defining = false;
+
+                    if (this.defined && !this.defineEmitted) {
+                        this.defineEmitted = true;
+                        this.emit('defined', this.exports);
+                        this.defineEmitComplete = true;
+                    }
+
+                }
+            },
+
+            callPlugin: function () {
+                var map = this.map,
+                    id = map.id,
+                    //Map already normalized the prefix.
+                    pluginMap = makeModuleMap(map.prefix);
+
+                //Mark this as a dependency for this plugin, so it
+                //can be traced for cycles.
+                this.depMaps.push(pluginMap);
+
+                on(pluginMap, 'defined', bind(this, function (plugin) {
+                    var load, normalizedMap, normalizedMod,
+                        bundleId = getOwn(bundlesMap, this.map.id),
+                        name = this.map.name,
+                        parentName = this.map.parentMap ? this.map.parentMap.name : null,
+                        localRequire = context.makeRequire(map.parentMap, {
+                            enableBuildCallback: true
+                        });
+
+                    //If current map is not normalized, wait for that
+                    //normalized name to load instead of continuing.
+                    if (this.map.unnormalized) {
+                        //Normalize the ID if the plugin allows it.
+                        if (plugin.normalize) {
+                            name = plugin.normalize(name, function (name) {
+                                return normalize(name, parentName, true);
+                            }) || '';
+                        }
+
+                        //prefix and name should already be normalized, no need
+                        //for applying map config again either.
+                        normalizedMap = makeModuleMap(map.prefix + '!' + name,
+                                                      this.map.parentMap,
+                                                      true);
+                        on(normalizedMap,
+                            'defined', bind(this, function (value) {
+                                this.map.normalizedMap = normalizedMap;
+                                this.init([], function () { return value; }, null, {
+                                    enabled: true,
+                                    ignore: true
+                                });
+                            }));
+
+                        normalizedMod = getOwn(registry, normalizedMap.id);
+                        if (normalizedMod) {
+                            //Mark this as a dependency for this plugin, so it
+                            //can be traced for cycles.
+                            this.depMaps.push(normalizedMap);
+
+                            if (this.events.error) {
+                                normalizedMod.on('error', bind(this, function (err) {
+                                    this.emit('error', err);
+                                }));
+                            }
+                            normalizedMod.enable();
+                        }
+
+                        return;
+                    }
+
+                    //If a paths config, then just load that file instead to
+                    //resolve the plugin, as it is built into that paths layer.
+                    if (bundleId) {
+                        this.map.url = context.nameToUrl(bundleId);
+                        this.load();
+                        return;
+                    }
+
+                    load = bind(this, function (value) {
+                        this.init([], function () { return value; }, null, {
+                            enabled: true
+                        });
+                    });
+
+                    load.error = bind(this, function (err) {
+                        this.inited = true;
+                        this.error = err;
+                        err.requireModules = [id];
+
+                        //Remove temp unnormalized modules for this module,
+                        //since they will never be resolved otherwise now.
+                        eachProp(registry, function (mod) {
+                            if (mod.map.id.indexOf(id + '_unnormalized') === 0) {
+                                cleanRegistry(mod.map.id);
+                            }
+                        });
+
+                        onError(err);
+                    });
+
+                    //Allow plugins to load other code without having to know the
+                    //context or how to 'complete' the load.
+                    load.fromText = bind(this, function (text, textAlt) {
+                        /*jslint evil: true */
+                        var moduleName = map.name,
+                            moduleMap = makeModuleMap(moduleName),
+                            hasInteractive = useInteractive;
+
+                        //As of 2.1.0, support just passing the text, to reinforce
+                        //fromText only being called once per resource. Still
+                        //support old style of passing moduleName but discard
+                        //that moduleName in favor of the internal ref.
+                        if (textAlt) {
+                            text = textAlt;
+                        }
+
+                        //Turn off interactive script matching for IE for any define
+                        //calls in the text, then turn it back on at the end.
+                        if (hasInteractive) {
+                            useInteractive = false;
+                        }
+
+                        //Prime the system by creating a module instance for
+                        //it.
+                        getModule(moduleMap);
+
+                        //Transfer any config to this other module.
+                        if (hasProp(config.config, id)) {
+                            config.config[moduleName] = config.config[id];
+                        }
+
+                        try {
+                            req.exec(text);
+                        } catch (e) {
+                            return onError(makeError('fromtexteval',
+                                             'fromText eval for ' + id +
+                                            ' failed: ' + e,
+                                             e,
+                                             [id]));
+                        }
+
+                        if (hasInteractive) {
+                            useInteractive = true;
+                        }
+
+                        //Mark this as a dependency for the plugin
+                        //resource
+                        this.depMaps.push(moduleMap);
+
+                        //Support anonymous modules.
+                        context.completeLoad(moduleName);
+
+                        //Bind the value of that module to the value for this
+                        //resource ID.
+                        localRequire([moduleName], load);
+                    });
+
+                    //Use parentName here since the plugin's name is not reliable,
+                    //could be some weird string with no path that actually wants to
+                    //reference the parentName's path.
+                    plugin.load(map.name, localRequire, load, config);
+                }));
+
+                context.enable(pluginMap, this);
+                this.pluginMaps[pluginMap.id] = pluginMap;
+            },
+
+            enable: function () {
+                enabledRegistry[this.map.id] = this;
+                this.enabled = true;
+
+                //Set flag mentioning that the module is enabling,
+                //so that immediate calls to the defined callbacks
+                //for dependencies do not trigger inadvertent load
+                //with the depCount still being zero.
+                this.enabling = true;
+
+                //Enable each dependency
+                each(this.depMaps, bind(this, function (depMap, i) {
+                    var id, mod, handler;
+
+                    if (typeof depMap === 'string') {
+                        //Dependency needs to be converted to a depMap
+                        //and wired up to this module.
+                        depMap = makeModuleMap(depMap,
+                                               (this.map.isDefine ? this.map : this.map.parentMap),
+                                               false,
+                                               !this.skipMap);
+                        this.depMaps[i] = depMap;
+
+                        handler = getOwn(handlers, depMap.id);
+
+                        if (handler) {
+                            this.depExports[i] = handler(this);
+                            return;
+                        }
+
+                        this.depCount += 1;
+
+                        on(depMap, 'defined', bind(this, function (depExports) {
+                            if (this.undefed) {
+                                return;
+                            }
+                            this.defineDep(i, depExports);
+                            this.check();
+                        }));
+
+                        if (this.errback) {
+                            on(depMap, 'error', bind(this, this.errback));
+                        } else if (this.events.error) {
+                            // No direct errback on this module, but something
+                            // else is listening for errors, so be sure to
+                            // propagate the error correctly.
+                            on(depMap, 'error', bind(this, function(err) {
+                                this.emit('error', err);
+                            }));
+                        }
+                    }
+
+                    id = depMap.id;
+                    mod = registry[id];
+
+                    //Skip special modules like 'require', 'exports', 'module'
+                    //Also, don't call enable if it is already enabled,
+                    //important in circular dependency cases.
+                    if (!hasProp(handlers, id) && mod && !mod.enabled) {
+                        context.enable(depMap, this);
+                    }
+                }));
+
+                //Enable each plugin that is used in
+                //a dependency
+                eachProp(this.pluginMaps, bind(this, function (pluginMap) {
+                    var mod = getOwn(registry, pluginMap.id);
+                    if (mod && !mod.enabled) {
+                        context.enable(pluginMap, this);
+                    }
+                }));
+
+                this.enabling = false;
+
+                this.check();
+            },
+
+            on: function (name, cb) {
+                var cbs = this.events[name];
+                if (!cbs) {
+                    cbs = this.events[name] = [];
+                }
+                cbs.push(cb);
+            },
+
+            emit: function (name, evt) {
+                each(this.events[name], function (cb) {
+                    cb(evt);
+                });
+                if (name === 'error') {
+                    //Now that the error handler was triggered, remove
+                    //the listeners, since this broken Module instance
+                    //can stay around for a while in the registry.
+                    delete this.events[name];
+                }
+            }
+        };
+
+        function callGetModule(args) {
+            //Skip modules already defined.
+            if (!hasProp(defined, args[0])) {
+                getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2]);
+            }
+        }
+
+        function removeListener(node, func, name, ieName) {
+            //Favor detachEvent because of IE9
+            //issue, see attachEvent/addEventListener comment elsewhere
+            //in this file.
+            if (node.detachEvent && !isOpera) {
+                //Probably IE. If not it will throw an error, which will be
+                //useful to know.
+                if (ieName) {
+                    node.detachEvent(ieName, func);
+                }
+            } else {
+                node.removeEventListener(name, func, false);
+            }
+        }
+
+        /**
+         * Given an event from a script node, get the requirejs info from it,
+         * and then removes the event listeners on the node.
+         * @param {Event} evt
+         * @returns {Object}
+         */
+        function getScriptData(evt) {
+            //Using currentTarget instead of target for Firefox 2.0's sake. Not
+            //all old browsers will be supported, but this one was easy enough
+            //to support and still makes sense.
+            var node = evt.currentTarget || evt.srcElement;
+
+            //Remove the listeners once here.
+            removeListener(node, context.onScriptLoad, 'load', 'onreadystatechange');
+            removeListener(node, context.onScriptError, 'error');
+
+            return {
+                node: node,
+                id: node && node.getAttribute('data-requiremodule')
+            };
+        }
+
+        function intakeDefines() {
+            var args;
+
+            //Any defined modules in the global queue, intake them now.
+            takeGlobalQueue();
+
+            //Make sure any remaining defQueue items get properly processed.
+            while (defQueue.length) {
+                args = defQueue.shift();
+                if (args[0] === null) {
+                    return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' +
+                        args[args.length - 1]));
+                } else {
+                    //args are id, deps, factory. Should be normalized by the
+                    //define() function.
+                    callGetModule(args);
+                }
+            }
+            context.defQueueMap = {};
+        }
+
+        context = {
+            config: config,
+            contextName: contextName,
+            registry: registry,
+            defined: defined,
+            urlFetched: urlFetched,
+            defQueue: defQueue,
+            defQueueMap: {},
+            Module: Module,
+            makeModuleMap: makeModuleMap,
+            nextTick: req.nextTick,
+            onError: onError,
+
+            /**
+             * Set a configuration for the context.
+             * @param {Object} cfg config object to integrate.
+             */
+            configure: function (cfg) {
+                //Make sure the baseUrl ends in a slash.
+                if (cfg.baseUrl) {
+                    if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {
+                        cfg.baseUrl += '/';
+                    }
+                }
+
+                // Convert old style urlArgs string to a function.
+                if (typeof cfg.urlArgs === 'string') {
+                    var urlArgs = cfg.urlArgs;
+                    cfg.urlArgs = function(id, url) {
+                        return (url.indexOf('?') === -1 ? '?' : '&') + urlArgs;
+                    };
+                }
+
+                //Save off the paths since they require special processing,
+                //they are additive.
+                var shim = config.shim,
+                    objs = {
+                        paths: true,
+                        bundles: true,
+                        config: true,
+                        map: true
+                    };
+
+                eachProp(cfg, function (value, prop) {
+                    if (objs[prop]) {
+                        if (!config[prop]) {
+                            config[prop] = {};
+                        }
+                        mixin(config[prop], value, true, true);
+                    } else {
+                        config[prop] = value;
+                    }
+                });
+
+                //Reverse map the bundles
+                if (cfg.bundles) {
+                    eachProp(cfg.bundles, function (value, prop) {
+                        each(value, function (v) {
+                            if (v !== prop) {
+                                bundlesMap[v] = prop;
+                            }
+                        });
+                    });
+                }
+
+                //Merge shim
+                if (cfg.shim) {
+                    eachProp(cfg.shim, function (value, id) {
+                        //Normalize the structure
+                        if (isArray(value)) {
+                            value = {
+                                deps: value
+                            };
+                        }
+                        if ((value.exports || value.init) && !value.exportsFn) {
+                            value.exportsFn = context.makeShimExports(value);
+                        }
+                        shim[id] = value;
+                    });
+                    config.shim = shim;
+                }
+
+                //Adjust packages if necessary.
+                if (cfg.packages) {
+                    each(cfg.packages, function (pkgObj) {
+                        var location, name;
+
+                        pkgObj = typeof pkgObj === 'string' ? {name: pkgObj} : pkgObj;
+
+                        name = pkgObj.name;
+                        location = pkgObj.location;
+                        if (location) {
+                            config.paths[name] = pkgObj.location;
+                        }
+
+                        //Save pointer to main module ID for pkg name.
+                        //Remove leading dot in main, so main paths are normalized,
+                        //and remove any trailing .js, since different package
+                        //envs have different conventions: some use a module name,
+                        //some use a file name.
+                        config.pkgs[name] = pkgObj.name + '/' + (pkgObj.main || 'main')
+                                     .replace(currDirRegExp, '')
+                                     .replace(jsSuffixRegExp, '');
+                    });
+                }
+
+                //If there are any "waiting to execute" modules in the registry,
+                //update the maps for them, since their info, like URLs to load,
+                //may have changed.
+                eachProp(registry, function (mod, id) {
+                    //If module already has init called, since it is too
+                    //late to modify them, and ignore unnormalized ones
+                    //since they are transient.
+                    if (!mod.inited && !mod.map.unnormalized) {
+                        mod.map = makeModuleMap(id, null, true);
+                    }
+                });
+
+                //If a deps array or a config callback is specified, then call
+                //require with those args. This is useful when require is defined as a
+                //config object before require.js is loaded.
+                if (cfg.deps || cfg.callback) {
+                    context.require(cfg.deps || [], cfg.callback);
+                }
+            },
+
+            makeShimExports: function (value) {
+                function fn() {
+                    var ret;
+                    if (value.init) {
+                        ret = value.init.apply(global, arguments);
+                    }
+                    return ret || (value.exports && getGlobal(value.exports));
+                }
+                return fn;
+            },
+
+            makeRequire: function (relMap, options) {
+                options = options || {};
+
+                function localRequire(deps, callback, errback) {
+                    var id, map, requireMod;
+
+                    if (options.enableBuildCallback && callback && isFunction(callback)) {
+                        callback.__requireJsBuild = true;
+                    }
+
+                    if (typeof deps === 'string') {
+                        if (isFunction(callback)) {
+                            //Invalid call
+                            return onError(makeError('requireargs', 'Invalid require call'), errback);
+                        }
+
+                        //If require|exports|module are requested, get the
+                        //value for them from the special handlers. Caveat:
+                        //this only works while module is being defined.
+                        if (relMap && hasProp(handlers, deps)) {
+                            return handlers[deps](registry[relMap.id]);
+                        }
+
+                        //Synchronous access to one module. If require.get is
+                        //available (as in the Node adapter), prefer that.
+                        if (req.get) {
+                            return req.get(context, deps, relMap, localRequire);
+                        }
+
+                        //Normalize module name, if it contains . or ..
+                        map = makeModuleMap(deps, relMap, false, true);
+                        id = map.id;
+
+                        if (!hasProp(defined, id)) {
+                            return onError(makeError('notloaded', 'Module name "' +
+                                        id +
+                                        '" has not been loaded yet for context: ' +
+                                        contextName +
+                                        (relMap ? '' : '. Use require([])')));
+                        }
+                        return defined[id];
+                    }
+
+                    //Grab defines waiting in the global queue.
+                    intakeDefines();
+
+                    //Mark all the dependencies as needing to be loaded.
+                    context.nextTick(function () {
+                        //Some defines could have been added since the
+                        //require call, collect them.
+                        intakeDefines();
+
+                        requireMod = getModule(makeModuleMap(null, relMap));
+
+                        //Store if map config should be applied to this require
+                        //call for dependencies.
+                        requireMod.skipMap = options.skipMap;
+
+                        requireMod.init(deps, callback, errback, {
+                            enabled: true
+                        });
+
+                        checkLoaded();
+                    });
+
+                    return localRequire;
+                }
+
+                mixin(localRequire, {
+                    isBrowser: isBrowser,
+
+                    /**
+                     * Converts a module name + .extension into an URL path.
+                     * *Requires* the use of a module name. It does not support using
+                     * plain URLs like nameToUrl.
+                     */
+                    toUrl: function (moduleNamePlusExt) {
+                        var ext,
+                            index = moduleNamePlusExt.lastIndexOf('.'),
+                            segment = moduleNamePlusExt.split('/')[0],
+                            isRelative = segment === '.' || segment === '..';
+
+                        //Have a file extension alias, and it is not the
+                        //dots from a relative path.
+                        if (index !== -1 && (!isRelative || index > 1)) {
+                            ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
+                            moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
+                        }
+
+                        return context.nameToUrl(normalize(moduleNamePlusExt,
+                                                relMap && relMap.id, true), ext,  true);
+                    },
+
+                    defined: function (id) {
+                        return hasProp(defined, makeModuleMap(id, relMap, false, true).id);
+                    },
+
+                    specified: function (id) {
+                        id = makeModuleMap(id, relMap, false, true).id;
+                        return hasProp(defined, id) || hasProp(registry, id);
+                    }
+                });
+
+                //Only allow undef on top level require calls
+                if (!relMap) {
+                    localRequire.undef = function (id) {
+                        //Bind any waiting define() calls to this context,
+                        //fix for #408
+                        takeGlobalQueue();
+
+                        var map = makeModuleMap(id, relMap, true),
+                            mod = getOwn(registry, id);
+
+                        mod.undefed = true;
+                        removeScript(id);
+
+                        delete defined[id];
+                        delete urlFetched[map.url];
+                        delete undefEvents[id];
+
+                        //Clean queued defines too. Go backwards
+                        //in array so that the splices do not
+                        //mess up the iteration.
+                        eachReverse(defQueue, function(args, i) {
+                            if (args[0] === id) {
+                                defQueue.splice(i, 1);
+                            }
+                        });
+                        delete context.defQueueMap[id];
+
+                        if (mod) {
+                            //Hold on to listeners in case the
+                            //module will be attempted to be reloaded
+                            //using a different config.
+                            if (mod.events.defined) {
+                                undefEvents[id] = mod.events;
+                            }
+
+                            cleanRegistry(id);
+                        }
+                    };
+                }
+
+                return localRequire;
+            },
+
+            /**
+             * Called to enable a module if it is still in the registry
+             * awaiting enablement. A second arg, parent, the parent module,
+             * is passed in for context, when this method is overridden by
+             * the optimizer. Not shown here to keep code compact.
+             */
+            enable: function (depMap) {
+                var mod = getOwn(registry, depMap.id);
+                if (mod) {
+                    getModule(depMap).enable();
+                }
+            },
+
+            /**
+             * Internal method used by environment adapters to complete a load event.
+             * A load event could be a script load or just a load pass from a synchronous
+             * load call.
+             * @param {String} moduleName the name of the module to potentially complete.
+             */
+            completeLoad: function (moduleName) {
+                var found, args, mod,
+                    shim = getOwn(config.shim, moduleName) || {},
+                    shExports = shim.exports;
+
+                takeGlobalQueue();
+
+                while (defQueue.length) {
+                    args = defQueue.shift();
+                    if (args[0] === null) {
+                        args[0] = moduleName;
+                        //If already found an anonymous module and bound it
+                        //to this name, then this is some other anon module
+                        //waiting for its completeLoad to fire.
+                        if (found) {
+                            break;
+                        }
+                        found = true;
+                    } else if (args[0] === moduleName) {
+                        //Found matching define call for this script!
+                        found = true;
+                    }
+
+                    callGetModule(args);
+                }
+                context.defQueueMap = {};
+
+                //Do this after the cycle of callGetModule in case the result
+                //of those calls/init calls changes the registry.
+                mod = getOwn(registry, moduleName);
+
+                if (!found && !hasProp(defined, moduleName) && mod && !mod.inited) {
+                    if (config.enforceDefine && (!shExports || !getGlobal(shExports))) {
+                        if (hasPathFallback(moduleName)) {
+                            return;
+                        } else {
+                            return onError(makeError('nodefine',
+                                             'No define call for ' + moduleName,
+                                             null,
+                                             [moduleName]));
+                        }
+                    } else {
+                        //A script that does not call define(), so just simulate
+                        //the call for it.
+                        callGetModule([moduleName, (shim.deps || []), shim.exportsFn]);
+                    }
+                }
+
+                checkLoaded();
+            },
+
+            /**
+             * Converts a module name to a file path. Supports cases where
+             * moduleName may actually be just an URL.
+             * Note that it **does not** call normalize on the moduleName,
+             * it is assumed to have already been normalized. This is an
+             * internal API, not a public one. Use toUrl for the public API.
+             */
+            nameToUrl: function (moduleName, ext, skipExt) {
+                var paths, syms, i, parentModule, url,
+                    parentPath, bundleId,
+                    pkgMain = getOwn(config.pkgs, moduleName);
+
+                if (pkgMain) {
+                    moduleName = pkgMain;
+                }
+
+                bundleId = getOwn(bundlesMap, moduleName);
+
+                if (bundleId) {
+                    return context.nameToUrl(bundleId, ext, skipExt);
+                }
+
+                //If a colon is in the URL, it indicates a protocol is used and it is just
+                //an URL to a file, or if it starts with a slash, contains a query arg (i.e. ?)
+                //or ends with .js, then assume the user meant to use an url and not a module id.
+                //The slash is important for protocol-less URLs as well as full paths.
+                if (req.jsExtRegExp.test(moduleName)) {
+                    //Just a plain path, not module name lookup, so just return it.
+                    //Add extension if it is included. This is a bit wonky, only non-.js things pass
+                    //an extension, this method probably needs to be reworked.
+                    url = moduleName + (ext || '');
+                } else {
+                    //A module that needs to be converted to a path.
+                    paths = config.paths;
+
+                    syms = moduleName.split('/');
+                    //For each module name segment, see if there is a path
+                    //registered for it. Start with most specific name
+                    //and work up from it.
+                    for (i = syms.length; i > 0; i -= 1) {
+                        parentModule = syms.slice(0, i).join('/');
+
+                        parentPath = getOwn(paths, parentModule);
+                        if (parentPath) {
+                            //If an array, it means there are a few choices,
+                            //Choose the one that is desired
+                            if (isArray(parentPath)) {
+                                parentPath = parentPath[0];
+                            }
+                            syms.splice(0, i, parentPath);
+                            break;
+                        }
+                    }
+
+                    //Join the path parts together, then figure out if baseUrl is needed.
+                    url = syms.join('/');
+                    url += (ext || (/^data\:|^blob\:|\?/.test(url) || skipExt ? '' : '.js'));
+                    url = (url.charAt(0) === '/' || url.match(/^[\w\+\.\-]+:/) ? '' : config.baseUrl) + url;
+                }
+
+                return config.urlArgs && !/^blob\:/.test(url) ?
+                       url + config.urlArgs(moduleName, url) : url;
+            },
+
+            //Delegates to req.load. Broken out as a separate function to
+            //allow overriding in the optimizer.
+            load: function (id, url) {
+                req.load(context, id, url);
+            },
+
+            /**
+             * Executes a module callback function. Broken out as a separate function
+             * solely to allow the build system to sequence the files in the built
+             * layer in the right sequence.
+             *
+             * @private
+             */
+            execCb: function (name, callback, args, exports) {
+                return callback.apply(exports, args);
+            },
+
+            /**
+             * callback for script loads, used to check status of loading.
+             *
+             * @param {Event} evt the event from the browser for the script
+             * that was loaded.
+             */
+            onScriptLoad: function (evt) {
+                //Using currentTarget instead of target for Firefox 2.0's sake. Not
+                //all old browsers will be supported, but this one was easy enough
+                //to support and still makes sense.
+                if (evt.type === 'load' ||
+                        (readyRegExp.test((evt.currentTarget || evt.srcElement).readyState))) {
+                    //Reset interactive script so a script node is not held onto for
+                    //to long.
+                    interactiveScript = null;
+
+                    //Pull out the name of the module and the context.
+                    var data = getScriptData(evt);
+                    context.completeLoad(data.id);
+                }
+            },
+
+            /**
+             * Callback for script errors.
+             */
+            onScriptError: function (evt) {
+                var data = getScriptData(evt);
+                if (!hasPathFallback(data.id)) {
+                    var parents = [];
+                    eachProp(registry, function(value, key) {
+                        if (key.indexOf('_@r') !== 0) {
+                            each(value.depMaps, function(depMap) {
+                                if (depMap.id === data.id) {
+                                    parents.push(key);
+                                    return true;
+                                }
+                            });
+                        }
+                    });
+                    return onError(makeError('scripterror', 'Script error for "' + data.id +
+                                             (parents.length ?
+                                             '", needed by: ' + parents.join(', ') :
+                                             '"'), evt, [data.id]));
+                }
+            }
+        };
+
+        context.require = context.makeRequire();
+        return context;
+    }
+
+    /**
+     * Main entry point.
+     *
+     * If the only argument to require is a string, then the module that
+     * is represented by that string is fetched for the appropriate context.
+     *
+     * If the first argument is an array, then it will be treated as an array
+     * of dependency string names to fetch. An optional function callback can
+     * be specified to execute when all of those dependencies are available.
+     *
+     * Make a local req variable to help Caja compliance (it assumes things
+     * on a require that are not standardized), and to give a short
+     * name for minification/local scope use.
+     */
+    req = requirejs = function (deps, callback, errback, optional) {
+
+        //Find the right context, use default
+        var context, config,
+            contextName = defContextName;
+
+        // Determine if have config object in the call.
+        if (!isArray(deps) && typeof deps !== 'string') {
+            // deps is a config object
+            config = deps;
+            if (isArray(callback)) {
+                // Adjust args if there are dependencies
+                deps = callback;
+                callback = errback;
+                errback = optional;
+            } else {
+                deps = [];
+            }
+        }
+
+        if (config && config.context) {
+            contextName = config.context;
+        }
+
+        context = getOwn(contexts, contextName);
+        if (!context) {
+            context = contexts[contextName] = req.s.newContext(contextName);
+        }
+
+        if (config) {
+            context.configure(config);
+        }
+
+        return context.require(deps, callback, errback);
+    };
+
+    /**
+     * Support require.config() to make it easier to cooperate with other
+     * AMD loaders on globally agreed names.
+     */
+    req.config = function (config) {
+        return req(config);
+    };
+
+    /**
+     * Execute something after the current tick
+     * of the event loop. Override for other envs
+     * that have a better solution than setTimeout.
+     * @param  {Function} fn function to execute later.
+     */
+    req.nextTick = typeof setTimeout !== 'undefined' ? function (fn) {
+        setTimeout(fn, 4);
+    } : function (fn) { fn(); };
+
+    /**
+     * Export require as a global, but only if it does not already exist.
+     */
+    if (!require) {
+        require = req;
+    }
+
+    req.version = version;
+
+    //Used to filter out dependencies that are already paths.
+    req.jsExtRegExp = /^\/|:|\?|\.js$/;
+    req.isBrowser = isBrowser;
+    s = req.s = {
+        contexts: contexts,
+        newContext: newContext
+    };
+
+    //Create default context.
+    req({});
+
+    //Exports some context-sensitive methods on global require.
+    each([
+        'toUrl',
+        'undef',
+        'defined',
+        'specified'
+    ], function (prop) {
+        //Reference from contexts instead of early binding to default context,
+        //so that during builds, the latest instance of the default context
+        //with its config gets used.
+        req[prop] = function () {
+            var ctx = contexts[defContextName];
+            return ctx.require[prop].apply(ctx, arguments);
+        };
+    });
+
+    if (isBrowser) {
+        head = s.head = document.getElementsByTagName('head')[0];
+        //If BASE tag is in play, using appendChild is a problem for IE6.
+        //When that browser dies, this can be removed. Details in this jQuery bug:
+        //http://dev.jquery.com/ticket/2709
+        baseElement = document.getElementsByTagName('base')[0];
+        if (baseElement) {
+            head = s.head = baseElement.parentNode;
+        }
+    }
+
+    /**
+     * Any errors that require explicitly generates will be passed to this
+     * function. Intercept/override it if you want custom error handling.
+     * @param {Error} err the error object.
+     */
+    req.onError = defaultOnError;
+
+    /**
+     * Creates the node for the load command. Only used in browser envs.
+     */
+    req.createNode = function (config, moduleName, url) {
+        var node = config.xhtml ?
+                document.createElementNS('http://www.w3.org/1999/xhtml', 'html:script') :
+                document.createElement('script');
+        node.type = config.scriptType || 'text/javascript';
+        node.charset = 'utf-8';
+        node.async = true;
+        return node;
+    };
+
+    /**
+     * Does the request to load a module for the browser case.
+     * Make this a separate function to allow other environments
+     * to override it.
+     *
+     * @param {Object} context the require context to find state.
+     * @param {String} moduleName the name of the module.
+     * @param {Object} url the URL to the module.
+     */
+    req.load = function (context, moduleName, url) {
+        var config = (context && context.config) || {},
+            node;
+        if (isBrowser) {
+            //In the browser so use a script tag
+            node = req.createNode(config, moduleName, url);
+
+            node.setAttribute('data-requirecontext', context.contextName);
+            node.setAttribute('data-requiremodule', moduleName);
+
+            //Set up load listener. Test attachEvent first because IE9 has
+            //a subtle issue in its addEventListener and script onload firings
+            //that do not match the behavior of all other browsers with
+            //addEventListener support, which fire the onload event for a
+            //script right after the script execution. See:
+            //https://connect.microsoft.com/IE/feedback/details/648057/script-onload-event-is-not-fired-immediately-after-script-execution
+            //UNFORTUNATELY Opera implements attachEvent but does not follow the script
+            //script execution mode.
+            if (node.attachEvent &&
+                    //Check if node.attachEvent is artificially added by custom script or
+                    //natively supported by browser
+                    //read https://github.com/requirejs/requirejs/issues/187
+                    //if we can NOT find [native code] then it must NOT natively supported.
+                    //in IE8, node.attachEvent does not have toString()
+                    //Note the test for "[native code" with no closing brace, see:
+                    //https://github.com/requirejs/requirejs/issues/273
+                    !(node.attachEvent.toString && node.attachEvent.toString().indexOf('[native code') < 0) &&
+                    !isOpera) {
+                //Probably IE. IE (at least 6-8) do not fire
+                //script onload right after executing the script, so
+                //we cannot tie the anonymous define call to a name.
+                //However, IE reports the script as being in 'interactive'
+                //readyState at the time of the define call.
+                useInteractive = true;
+
+                node.attachEvent('onreadystatechange', context.onScriptLoad);
+                //It would be great to add an error handler here to catch
+                //404s in IE9+. However, onreadystatechange will fire before
+                //the error handler, so that does not help. If addEventListener
+                //is used, then IE will fire error before load, but we cannot
+                //use that pathway given the connect.microsoft.com issue
+                //mentioned above about not doing the 'script execute,
+                //then fire the script load event listener before execute
+                //next script' that other browsers do.
+                //Best hope: IE10 fixes the issues,
+                //and then destroys all installs of IE 6-9.
+                //node.attachEvent('onerror', context.onScriptError);
+            } else {
+                node.addEventListener('load', context.onScriptLoad, false);
+                node.addEventListener('error', context.onScriptError, false);
+            }
+            node.src = url;
+
+            //Calling onNodeCreated after all properties on the node have been
+            //set, but before it is placed in the DOM.
+            if (config.onNodeCreated) {
+                config.onNodeCreated(node, config, moduleName, url);
+            }
+
+            //For some cache cases in IE 6-8, the script executes before the end
+            //of the appendChild execution, so to tie an anonymous define
+            //call to the module name (which is stored on the node), hold on
+            //to a reference to this node, but clear after the DOM insertion.
+            currentlyAddingScript = node;
+            if (baseElement) {
+                head.insertBefore(node, baseElement);
+            } else {
+                head.appendChild(node);
+            }
+            currentlyAddingScript = null;
+
+            return node;
+        } else if (isWebWorker) {
+            try {
+                //In a web worker, use importScripts. This is not a very
+                //efficient use of importScripts, importScripts will block until
+                //its script is downloaded and evaluated. However, if web workers
+                //are in play, the expectation is that a build has been done so
+                //that only one script needs to be loaded anyway. This may need
+                //to be reevaluated if other use cases become common.
+
+                // Post a task to the event loop to work around a bug in WebKit
+                // where the worker gets garbage-collected after calling
+                // importScripts(): https://webkit.org/b/153317
+                setTimeout(function() {}, 0);
+                importScripts(url);
+
+                //Account for anonymous modules
+                context.completeLoad(moduleName);
+            } catch (e) {
+                context.onError(makeError('importscripts',
+                                'importScripts failed for ' +
+                                    moduleName + ' at ' + url,
+                                e,
+                                [moduleName]));
+            }
+        }
+    };
+
+    function getInteractiveScript() {
+        if (interactiveScript && interactiveScript.readyState === 'interactive') {
+            return interactiveScript;
+        }
+
+        eachReverse(scripts(), function (script) {
+            if (script.readyState === 'interactive') {
+                return (interactiveScript = script);
+            }
+        });
+        return interactiveScript;
+    }
+
+    //Look for a data-main script attribute, which could also adjust the baseUrl.
+    if (isBrowser && !cfg.skipDataMain) {
+        //Figure out baseUrl. Get it from the script tag with require.js in it.
+        eachReverse(scripts(), function (script) {
+            //Set the 'head' where we can append children by
+            //using the script's parent.
+            if (!head) {
+                head = script.parentNode;
+            }
+
+            //Look for a data-main attribute to set main script for the page
+            //to load. If it is there, the path to data main becomes the
+            //baseUrl, if it is not already set.
+            dataMain = script.getAttribute('data-main');
+            if (dataMain) {
+                //Preserve dataMain in case it is a path (i.e. contains '?')
+                mainScript = dataMain;
+
+                //Set final baseUrl if there is not already an explicit one,
+                //but only do so if the data-main value is not a loader plugin
+                //module ID.
+                if (!cfg.baseUrl && mainScript.indexOf('!') === -1) {
+                    //Pull off the directory of data-main for use as the
+                    //baseUrl.
+                    src = mainScript.split('/');
+                    mainScript = src.pop();
+                    subPath = src.length ? src.join('/')  + '/' : './';
+
+                    cfg.baseUrl = subPath;
+                }
+
+                //Strip off any trailing .js since mainScript is now
+                //like a module name.
+                mainScript = mainScript.replace(jsSuffixRegExp, '');
+
+                //If mainScript is still a path, fall back to dataMain
+                if (req.jsExtRegExp.test(mainScript)) {
+                    mainScript = dataMain;
+                }
+
+                //Put the data-main script in the files to load.
+                cfg.deps = cfg.deps ? cfg.deps.concat(mainScript) : [mainScript];
+
+                return true;
+            }
+        });
+    }
+
+    /**
+     * The function that handles definitions of modules. Differs from
+     * require() in that a string for the module should be the first argument,
+     * and the function to execute after dependencies are loaded should
+     * return a value to define the module corresponding to the first argument's
+     * name.
+     */
+    define = function (name, deps, callback) {
+        var node, context;
+
+        //Allow for anonymous modules
+        if (typeof name !== 'string') {
+            //Adjust args appropriately
+            callback = deps;
+            deps = name;
+            name = null;
+        }
+
+        //This module may not have dependencies
+        if (!isArray(deps)) {
+            callback = deps;
+            deps = null;
+        }
+
+        //If no name, and callback is a function, then figure out if it a
+        //CommonJS thing with dependencies.
+        if (!deps && isFunction(callback)) {
+            deps = [];
+            //Remove comments from the callback string,
+            //look for require calls, and pull them into the dependencies,
+            //but only if there are function args.
+            if (callback.length) {
+                callback
+                    .toString()
+                    .replace(commentRegExp, commentReplace)
+                    .replace(cjsRequireRegExp, function (match, dep) {
+                        deps.push(dep);
+                    });
+
+                //May be a CommonJS thing even without require calls, but still
+                //could use exports, and module. Avoid doing exports and module
+                //work though if it just needs require.
+                //REQUIRES the function to expect the CommonJS variables in the
+                //order listed below.
+                deps = (callback.length === 1 ? ['require'] : ['require', 'exports', 'module']).concat(deps);
+            }
+        }
+
+        //If in IE 6-8 and hit an anonymous define() call, do the interactive
+        //work.
+        if (useInteractive) {
+            node = currentlyAddingScript || getInteractiveScript();
+            if (node) {
+                if (!name) {
+                    name = node.getAttribute('data-requiremodule');
+                }
+                context = contexts[node.getAttribute('data-requirecontext')];
+            }
+        }
+
+        //Always save off evaluating the def call until the script onload handler.
+        //This allows multiple modules to be in a file without prematurely
+        //tracing dependencies, and allows for anonymous module support,
+        //where the module name is not known until the script onload event
+        //occurs. If no context, use the global queue, and get it processed
+        //in the onscript load callback.
+        if (context) {
+            context.defQueue.push([name, deps, callback]);
+            context.defQueueMap[name] = true;
+        } else {
+            globalDefQueue.push([name, deps, callback]);
+        }
+    };
+
+    define.amd = {
+        jQuery: true
+    };
+
+    /**
+     * Executes the text. Normally just uses eval, but can be modified
+     * to use a better, environment-specific call. Only used for transpiling
+     * loader plugins, not for plain JS modules.
+     * @param {String} text the text to execute/evaluate.
+     */
+    req.exec = function (text) {
+        /*jslint evil: true */
+        return eval(text);
+    };
+
+    //Set up with config info.
+    req(cfg);
+}(this, (typeof setTimeout === 'undefined' ? undefined : setTimeout)));
diff --git a/site.json b/site.json
index 31185bd22..1e25fb09a 100644
--- a/site.json
+++ b/site.json
@@ -1,10 +1,21 @@
 {
     "bundles": {
         "codeMirror": {
-            "javascript": ["js/libs/codemirror.js", "js/libs/javascript.js"],
-            "css": ["css/libs/codemirror.css", "css/editor-libs/codemirror-override.css"],
+            "javascript": ["js/libs/codemirror.js"],
+            "css": [
+                "css/libs/codemirror.css",
+                "css/editor-libs/codemirror-override.css"
+            ],
             "destFileName": "codemirror"
         },
+        "require": {
+            "javascript": ["js/require.js"],
+            "destFileName": "require"
+        },
+        "codemirrorLoader": {
+            "javascript": ["js/editor-libs/codemirrorLoader.js"],
+            "destFileName": "codemirrorLoader"
+        },
         "cssExamplesBase": {
             "javascript": [
                 "js/editor-libs/mce-utils.js",
@@ -179,14 +190,16 @@
         },
         "arraybufferConstructor": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/arraybuffer-constructor.html",
+            "exampleCode":
+                "live-examples/js-examples/arraybuffer-constructor.html",
             "fileName": "arraybuffer-constructor.html",
             "title": "JavaScript Demo: ArrayBuffer Constructor",
             "type": "js"
         },
         "arraybufferByteLength": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/arraybuffer-bytelength.html",
+            "exampleCode":
+                "live-examples/js-examples/arraybuffer-bytelength.html",
             "fileName": "arraybuffer-bytelength.html",
             "title": "JavaScript Demo: ArrayBuffer.byteLength()",
             "type": "js"
@@ -221,7 +234,8 @@
         },
         "atomicsCompareExchange": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/atomics-compareexchange.html",
+            "exampleCode":
+                "live-examples/js-examples/atomics-compareexchange.html",
             "fileName": "atomics-compareexchange.html",
             "title": "JavaScript Demo: Atomics.compareExchange()",
             "type": "js"
@@ -389,7 +403,8 @@
         },
         "dataviewConstructor": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/dataview-constructor.html",
+            "exampleCode":
+                "live-examples/js-examples/dataview-constructor.html",
             "fileName": "dataview-constructor.html",
             "title": "JavaScript Demo: DataView Constructor",
             "type": "js"
@@ -543,7 +558,8 @@
         },
         "dateGetMilliseconds": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/date-getmilliseconds.html",
+            "exampleCode":
+                "live-examples/js-examples/date-getmilliseconds.html",
             "fileName": "date-getmilliseconds.html",
             "title": "JavaScript Demo: Date.getMilliseconds()",
             "type": "js"
@@ -578,7 +594,8 @@
         },
         "dateGetTimezoneOffset": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/date-gettimezoneoffset.html",
+            "exampleCode":
+                "live-examples/js-examples/date-gettimezoneoffset.html",
             "fileName": "date-gettimezoneoffset.html",
             "title": "JavaScript Demo: Date.getTimezoneOffset()",
             "type": "js"
@@ -655,7 +672,8 @@
         },
         "dateSetMilliseconds": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/date-setmilliseconds.html",
+            "exampleCode":
+                "live-examples/js-examples/date-setmilliseconds.html",
             "fileName": "date-setmilliseconds.html",
             "title": "JavaScript Demo: Date.setMilliseconds()",
             "type": "js"
@@ -739,7 +757,8 @@
         },
         "dateToLocaleDateString": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/date-tolocaledatestring.html",
+            "exampleCode":
+                "live-examples/js-examples/date-tolocaledatestring.html",
             "fileName": "date-tolocaledatestring.html",
             "title": "JavaScript Demo: Date.toLocaleDateString()",
             "type": "js"
@@ -753,7 +772,8 @@
         },
         "dateToLocaleTimeString": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/date-tolocaletimestring.html",
+            "exampleCode":
+                "live-examples/js-examples/date-tolocaletimestring.html",
             "fileName": "date-tolocaletimestring.html",
             "title": "JavaScript Demo: Date.toLocaleTimeString()",
             "type": "js"
@@ -795,147 +815,168 @@
         },
         "expressionsArithmetic": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/expressions-arithmetic.html",
+            "exampleCode":
+                "live-examples/js-examples/expressions-arithmetic.html",
             "fileName": "expressions-arithmetic.html",
             "title": "JavaScript Demo: Expressions - Arithmetic",
             "type": "js"
         },
         "expressionsAssignment": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/expressions-assignment.html",
+            "exampleCode":
+                "live-examples/js-examples/expressions-assignment.html",
             "fileName": "expressions-assignment.html",
             "title": "JavaScript Demo: Expressions - Assignment",
             "type": "js"
         },
         "expressionsBitwiseOperators": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/expressions-bitwiseoperators.html",
+            "exampleCode":
+                "live-examples/js-examples/expressions-bitwiseoperators.html",
             "fileName": "expressions-bitwiseoperators.html",
             "title": "JavaScript Demo: Expressions - Bitwise Operators",
             "type": "js"
         },
         "expressionsClassExpression": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/expressions-classexpression.html",
+            "exampleCode":
+                "live-examples/js-examples/expressions-classexpression.html",
             "fileName": "expressions-classexpression.html",
             "title": "JavaScript Demo: Expressions - Class Expression",
             "type": "js"
         },
         "expressionsCommaOperators": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/expressions-commaoperators.html",
+            "exampleCode":
+                "live-examples/js-examples/expressions-commaoperators.html",
             "fileName": "expressions-commaoperators.html",
             "title": "JavaScript Demo: Expressions - Comma Operators",
             "type": "js"
         },
         "expressionsComparisonOperators": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/expressions-comparisonoperators.html",
+            "exampleCode":
+                "live-examples/js-examples/expressions-comparisonoperators.html",
             "fileName": "expressions-comparisonoperators.html",
             "title": "JavaScript Demo: Expressions - Comparison Operators",
             "type": "js"
         },
         "expressionsConditionalOperators": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/expressions-conditionaloperators.html",
+            "exampleCode":
+                "live-examples/js-examples/expressions-conditionaloperators.html",
             "fileName": "expressions-conditionaloperators.html",
             "title": "JavaScript Demo: Expressions - Conditional Operators",
             "type": "js"
         },
         "expressionsDeleteOperator": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/expressions-deleteoperator.html",
+            "exampleCode":
+                "live-examples/js-examples/expressions-deleteoperator.html",
             "fileName": "expressions-deleteoperator.html",
             "title": "JavaScript Demo: Expressions - Delete Operator",
             "type": "js"
         },
         "expressionsDestructuringAssignment": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/expressions-destructuringassignment.html",
+            "exampleCode":
+                "live-examples/js-examples/expressions-destructuringassignment.html",
             "fileName": "expressions-destructuringassignment.html",
             "title": "JavaScript Demo: Expressions - Destructuring Assignment",
             "type": "js"
         },
         "expressionsFunctionAsteriskExpression": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/expressions-functionasteriskexpression.html",
+            "exampleCode":
+                "live-examples/js-examples/expressions-functionasteriskexpression.html",
             "fileName": "expressions-functionasteriskexpression.html",
             "title": "JavaScript Demo: Expressions - Function* Expression",
             "type": "js"
         },
         "expressionsFunctionExpression": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/expressions-functionexpression.html",
+            "exampleCode":
+                "live-examples/js-examples/expressions-functionexpression.html",
             "fileName": "expressions-functionexpression.html",
             "title": "JavaScript Demo: Expressions - Function Expression",
             "type": "js"
         },
         "expressionsGroupingOperator": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/expressions-groupingoperator.html",
+            "exampleCode":
+                "live-examples/js-examples/expressions-groupingoperator.html",
             "fileName": "expressions-groupingoperator.html",
             "title": "JavaScript Demo: Expressions - Grouping Operator",
             "type": "js"
         },
         "expressionsInOperator": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/expressions-inoperator.html",
+            "exampleCode":
+                "live-examples/js-examples/expressions-inoperator.html",
             "fileName": "expressions-inoperator.html",
             "title": "JavaScript Demo: Expressions - In Operator",
             "type": "js"
         },
         "expressionsInstanceof": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/expressions-instanceof.html",
+            "exampleCode":
+                "live-examples/js-examples/expressions-instanceof.html",
             "fileName": "expressions-instanceof.html",
             "title": "JavaScript Demo: Expressions - Instanceof",
             "type": "js"
         },
         "expressionsLogicalOperator": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/expressions-logicaloperator.html",
+            "exampleCode":
+                "live-examples/js-examples/expressions-logicaloperator.html",
             "fileName": "expressions-logicaloperator.html",
             "title": "JavaScript Demo: Expressions - Logical Operator",
             "type": "js"
         },
         "expressionsNewOperator": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/expressions-newoperator.html",
+            "exampleCode":
+                "live-examples/js-examples/expressions-newoperator.html",
             "fileName": "expressions-newoperator.html",
             "title": "JavaScript Demo: Expressions - New Operator",
             "type": "js"
         },
         "expressionsNewTarget": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/expressions-newtarget.html",
+            "exampleCode":
+                "live-examples/js-examples/expressions-newtarget.html",
             "fileName": "expressions-newtarget.html",
             "title": "JavaScript Demo: Expressions - New Target",
             "type": "js"
         },
         "expressionsObjectInitializer": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/expressions-objectinitializer.html",
+            "exampleCode":
+                "live-examples/js-examples/expressions-objectinitializer.html",
             "fileName": "expressions-objectinitializer.html",
             "title": "JavaScript Demo: Expressions - Object Initializer",
             "type": "js"
         },
         "expressionsOperatorPrecedence": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/expressions-operatorprecedence.html",
+            "exampleCode":
+                "live-examples/js-examples/expressions-operatorprecedence.html",
             "fileName": "expressions-operatorprecedence.html",
             "title": "JavaScript Demo: Expressions - Operator Precedence",
             "type": "js"
         },
         "expressionsPropertyAccessors": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/expressions-propertyaccessors.html",
+            "exampleCode":
+                "live-examples/js-examples/expressions-propertyaccessors.html",
             "fileName": "expressions-propertyaccessors.html",
             "title": "JavaScript Demo: Expressions - Property Accessors",
             "type": "js"
         },
         "expressionsSpreadSyntax": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/expressions-spreadsyntax.html",
+            "exampleCode":
+                "live-examples/js-examples/expressions-spreadsyntax.html",
             "fileName": "expressions-spreadsyntax.html",
             "title": "JavaScript Demo: Expressions - Spread Syntax",
             "type": "js"
@@ -956,7 +997,8 @@
         },
         "expressionsVoidOperator": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/expressions-voidoperator.html",
+            "exampleCode":
+                "live-examples/js-examples/expressions-voidoperator.html",
             "fileName": "expressions-voidoperator.html",
             "title": "JavaScript Demo: Expressions - Void Operator",
             "type": "js"
@@ -970,7 +1012,8 @@
         },
         "expressionsYieldAsterisk": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/expressions-yieldasterisk.html",
+            "exampleCode":
+                "live-examples/js-examples/expressions-yieldasterisk.html",
             "fileName": "expressions-yieldasterisk.html",
             "title": "JavaScript Demo: Expressions - Yield*",
             "type": "js"
@@ -998,7 +1041,8 @@
         },
         "functionConstructor": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/function-constructor.html",
+            "exampleCode":
+                "live-examples/js-examples/function-constructor.html",
             "fileName": "function-constructor.html",
             "title": "JavaScript Demo: Function - Constructor",
             "type": "js"
@@ -1047,7 +1091,8 @@
         },
         "functionsDefinitions": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/functions-definitions.html",
+            "exampleCode":
+                "live-examples/js-examples/functions-definitions.html",
             "fileName": "functions-definitions.html",
             "title": "JavaScript Demo: Functions Definitions",
             "type": "js"
@@ -1061,7 +1106,8 @@
         },
         "functionsRestParameters": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/functions-restparameters.html",
+            "exampleCode":
+                "live-examples/js-examples/functions-restparameters.html",
             "fileName": "functions-restparameters.html",
             "title": "JavaScript Demo: Functions Rest Parameters",
             "type": "js"
@@ -1075,30 +1121,36 @@
         },
         "globalpropsDecodeURI": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/globalprops-decodeuri.html",
+            "exampleCode":
+                "live-examples/js-examples/globalprops-decodeuri.html",
             "fileName": "globalprops-decodeuri.html",
             "title": "JavaScript Demo: Standard built-in objects - decodeURI()",
             "type": "js"
         },
         "globalpropsDecodeURIComponent": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/globalprops-decodeuricomponent.html",
+            "exampleCode":
+                "live-examples/js-examples/globalprops-decodeuricomponent.html",
             "fileName": "globalprops-decodeuricomponent.html",
-            "title": "JavaScript Demo: Standard built-in objects - decodeURIComponent()",
+            "title":
+                "JavaScript Demo: Standard built-in objects - decodeURIComponent()",
             "type": "js"
         },
         "globalpropsEncodeURI": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/globalprops-encodeuri.html",
+            "exampleCode":
+                "live-examples/js-examples/globalprops-encodeuri.html",
             "fileName": "globalprops-encodeuri.html",
             "title": "JavaScript Demo: Standard built-in objects - encodeURI()",
             "type": "js"
         },
         "globalpropsEncodeURIComponent": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/globalprops-encodeuricomponent.html",
+            "exampleCode":
+                "live-examples/js-examples/globalprops-encodeuricomponent.html",
             "fileName": "globalprops-encodeuricomponent.html",
-            "title": "JavaScript Demo: Standard built-in objects - encodeURIComponent()",
+            "title":
+                "JavaScript Demo: Standard built-in objects - encodeURIComponent()",
             "type": "js"
         },
         "globalpropsEval": {
@@ -1110,14 +1162,16 @@
         },
         "globalpropsInfinity": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/globalprops-infinity.html",
+            "exampleCode":
+                "live-examples/js-examples/globalprops-infinity.html",
             "fileName": "globalprops-infinity.html",
             "title": "JavaScript Demo: Standard built-in objects - infinity",
             "type": "js"
         },
         "globalpropsIsFinite": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/globalprops-isfinite.html",
+            "exampleCode":
+                "live-examples/js-examples/globalprops-isfinite.html",
             "fileName": "globalprops-isfinite.html",
             "title": "JavaScript Demo: Standard built-in objects - isFinite()",
             "type": "js"
@@ -1145,21 +1199,25 @@
         },
         "globalpropsParseFloat": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/globalprops-parsefloat.html",
+            "exampleCode":
+                "live-examples/js-examples/globalprops-parsefloat.html",
             "fileName": "globalprops-parsefloat.html",
-            "title": "JavaScript Demo: Standard built-in objects - parseFloat()",
+            "title":
+                "JavaScript Demo: Standard built-in objects - parseFloat()",
             "type": "js"
         },
         "globalpropsParseInt": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/globalprops-parseint.html",
+            "exampleCode":
+                "live-examples/js-examples/globalprops-parseint.html",
             "fileName": "globalprops-parseint.html",
             "title": "JavaScript Demo: Standard built-in objects - parseInt()",
             "type": "js"
         },
         "globalpropsUndefined": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/globalprops-undefined.html",
+            "exampleCode":
+                "live-examples/js-examples/globalprops-undefined.html",
             "fileName": "globalprops-undefined.html",
             "title": "JavaScript Demo: Standard built-in objects - undefined",
             "type": "js"
@@ -1208,14 +1266,16 @@
         },
         "numberIsSafeInteger": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/number-issafeinteger.html",
+            "exampleCode":
+                "live-examples/js-examples/number-issafeinteger.html",
             "fileName": "number-issafeinteger.html",
             "title": "JavaScript Demo: Number.isSafeInteger()",
             "type": "js"
         },
         "numberMaxSafeInteger": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/number-max-safe-integer.html",
+            "exampleCode":
+                "live-examples/js-examples/number-max-safe-integer.html",
             "fileName": "number-maxsafeinteger.html",
             "title": "JavaScript Demo: Number.MAX_SAFE_INTEGER",
             "type": "js"
@@ -1229,7 +1289,8 @@
         },
         "numberMinSafeInteger": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/number-min-safe-integer.html",
+            "exampleCode":
+                "live-examples/js-examples/number-min-safe-integer.html",
             "fileName": "number-min-safe-integer.html",
             "title": "JavaScript Demo: Number.MIN_SAFE_INTEGER",
             "type": "js"
@@ -1250,7 +1311,8 @@
         },
         "numberNegativeInfinity": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/number-negative-infinity.html",
+            "exampleCode":
+                "live-examples/js-examples/number-negative-infinity.html",
             "fileName": "number-negative-infinity.html",
             "title": "JavaScript Demo: Number.NEGATIVE_INFINITY",
             "type": "js"
@@ -1271,14 +1333,16 @@
         },
         "numberPositiveInfinity": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/number-positive-infinity.html",
+            "exampleCode":
+                "live-examples/js-examples/number-positive-infinity.html",
             "fileName": "number-positive-infinity.html",
             "title": "JavaScript Demo: Number.POSITIVE_INFINITY",
             "type": "js"
         },
         "numberToExponential": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/number-toexponential.html",
+            "exampleCode":
+                "live-examples/js-examples/number-toexponential.html",
             "fileName": "number-toexponential.html",
             "title": "JavaScript Demo: Number.toExponential()",
             "type": "js"
@@ -1292,7 +1356,8 @@
         },
         "numberToLocaleString": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/number-tolocalestring.html",
+            "exampleCode":
+                "live-examples/js-examples/number-tolocalestring.html",
             "fileName": "number-tolocalestring.html",
             "title": "JavaScript Demo: Number.toLocaleString()",
             "type": "js"
@@ -1334,14 +1399,16 @@
         },
         "objectDefineProperties": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/object-defineproperties.html",
+            "exampleCode":
+                "live-examples/js-examples/object-defineproperties.html",
             "fileName": "object-defineproperties.html",
             "title": "JavaScript Demo: Object.defineProperties()",
             "type": "js"
         },
         "objectDefineProperty": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/object-defineproperty.html",
+            "exampleCode":
+                "live-examples/js-examples/object-defineproperty.html",
             "fileName": "object-defineproperty.html",
             "title": "JavaScript Demo: Object.defineProperty()",
             "type": "js"
@@ -1362,35 +1429,40 @@
         },
         "objectGetOwnPropertyDescriptor": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/object-getownpropertydescriptor.html",
+            "exampleCode":
+                "live-examples/js-examples/object-getownpropertydescriptor.html",
             "fileName": "object-getownpropertydescriptor.html",
             "title": "JavaScript Demo: Object.getOwnPropertyDescriptor()",
             "type": "js"
         },
         "objectGetOwnPropertyDescriptors": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/object-getownpropertydescriptors.html",
+            "exampleCode":
+                "live-examples/js-examples/object-getownpropertydescriptors.html",
             "fileName": "object-getownpropertydescriptors.html",
             "title": "JavaScript Demo: Object.getOwnPropertyDescriptors()",
             "type": "js"
         },
         "objectGetOwnPropertyNames": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/object-getownpropertynames.html",
+            "exampleCode":
+                "live-examples/js-examples/object-getownpropertynames.html",
             "fileName": "object-getownpropertynames.html",
             "title": "JavaScript Demo: Object.getOwnPropertyNames()",
             "type": "js"
         },
         "objectGetOwnPropertySymbols": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/object-getownpropertysymbols.html",
+            "exampleCode":
+                "live-examples/js-examples/object-getownpropertysymbols.html",
             "fileName": "object-getownpropertysymbols.html",
             "title": "JavaScript Demo: Object.getOwnPropertySymbols()",
             "type": "js"
         },
         "objectGetProtoypeOf": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/object-getprototypeof.html",
+            "exampleCode":
+                "live-examples/js-examples/object-getprototypeof.html",
             "fileName": "object-getprototypeof.html",
             "title": "JavaScript Demo: Object.getPrototypeOf()",
             "type": "js"
@@ -1418,56 +1490,65 @@
         },
         "objectPreventExtensions": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/object-preventextensions.html",
+            "exampleCode":
+                "live-examples/js-examples/object-preventextensions.html",
             "fileName": "object-preventextensions.html",
             "title": "JavaScript Demo: Object.preventExtensions()",
             "type": "js"
         },
         "objectPrototypeHasOwnProperty": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/object-prototype-hasownproperty.html",
+            "exampleCode":
+                "live-examples/js-examples/object-prototype-hasownproperty.html",
             "fileName": "object-prototype-hasownproperty.html",
             "title": "JavaScript Demo: Object.prototype.hasOwnProperty()",
             "type": "js"
         },
         "objectIsPrototypePrototypeOf": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/object-prototype-isprototypeof.html",
+            "exampleCode":
+                "live-examples/js-examples/object-prototype-isprototypeof.html",
             "fileName": "object-prototype-isprototypeof.html",
             "title": "JavaScript Demo: Object.prototype.isPrototypeOf()",
             "type": "js"
         },
         "objectPrototypePropertyIsEnumerable": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/object-prototype-propertyisenumerable.html",
+            "exampleCode":
+                "live-examples/js-examples/object-prototype-propertyisenumerable.html",
             "fileName": "object-prototype-propertyisenumberable.html",
-            "title": "JavaScript Demo: Object.prototype.propertyIsEnumberable()",
+            "title":
+                "JavaScript Demo: Object.prototype.propertyIsEnumberable()",
             "type": "js"
         },
         "objectPrototypeSeal": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/object-prototype-seal.html",
+            "exampleCode":
+                "live-examples/js-examples/object-prototype-seal.html",
             "fileName": "object-prototype-seal.html",
             "title": "JavaScript Demo: Object.prototype.seal()",
             "type": "js"
         },
         "objectPrototypeToLocaleString": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/object-prototype-tolocalestring.html",
+            "exampleCode":
+                "live-examples/js-examples/object-prototype-tolocalestring.html",
             "fileName": "object-prototype-tolocalestring.html",
             "title": "JavaScript Demo: Object.prototype.tolocalestring()",
             "type": "js"
         },
         "objectPrototypeToString": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/object-prototype-tostring.html",
+            "exampleCode":
+                "live-examples/js-examples/object-prototype-tostring.html",
             "fileName": "object-prototype-tostring.html",
             "title": "JavaScript Demo: Object.prototype.tostring()",
             "type": "js"
         },
         "objectPrototypeValueOf": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/object-prototype-valueof.html",
+            "exampleCode":
+                "live-examples/js-examples/object-prototype-valueof.html",
             "fileName": "object-prototype-valueof.html",
             "title": "JavaScript Demo: Object.prototype.valueof()",
             "type": "js"
@@ -1530,21 +1611,24 @@
         },
         "sharedarraybufferByteLength": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/sharedarraybuffer-bytelength.html",
+            "exampleCode":
+                "live-examples/js-examples/sharedarraybuffer-bytelength.html",
             "fileName": "sharedarraybuffer-bytelength.html",
             "title": "JavaScript Demo: SharedArrayBuffer.byteLength",
             "type": "js"
         },
         "sharedarraybufferConstructor": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/sharedarraybuffer-constructor.html",
+            "exampleCode":
+                "live-examples/js-examples/sharedarraybuffer-constructor.html",
             "fileName": "sharedarraybuffer-constructor.html",
             "title": "JavaScript Demo: SharedArrayBuffer Constructor",
             "type": "js"
         },
         "sharedarraybufferSlice": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/sharedarraybuffer-slice.html",
+            "exampleCode":
+                "live-examples/js-examples/sharedarraybuffer-slice.html",
             "fileName": "sharedarraybuffer-slice.html",
             "title": "JavaScript Demo: SharedArrayBuffer.slice()",
             "type": "js"
@@ -1642,7 +1726,8 @@
         },
         "statementFunctionAsterisk": {
             "baseTmpl": "tmpl/live-js-tmpl.html",
-            "exampleCode": "live-examples/js-examples/statement-functionasterisk.html",
+            "exampleCode":
+                "live-examples/js-examples/statement-functionasterisk.html",
             "fileName": "statement-functionasterisk.html",
             "title": "JavaScript Demo: Statement - Function*",
             "type": "js"
@@ -1711,218 +1796,225 @@
             "type": "js"
         },
         "typedarrayBuffer": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-buffer.html",
-          "fileName": "typedarray-buffer.html",
-          "title": "JavaScript Demo: TypedArray.buffer",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode": "live-examples/js-examples/typedarray-buffer.html",
+            "fileName": "typedarray-buffer.html",
+            "title": "JavaScript Demo: TypedArray.buffer",
+            "type": "js"
         },
         "typedarrayByteLength": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-bytelength.html",
-          "fileName": "typedarray-bytelength.html",
-          "title": "JavaScript Demo: TypedArray.byteLength",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode":
+                "live-examples/js-examples/typedarray-bytelength.html",
+            "fileName": "typedarray-bytelength.html",
+            "title": "JavaScript Demo: TypedArray.byteLength",
+            "type": "js"
         },
         "typedarrayBytesPerElement": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-bytes-per-element.html",
-          "fileName": "typedarray-bytes-per-element.html",
-          "title": "JavaScript Demo: TypedArray.BYTES_PER_ELEMENT",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode":
+                "live-examples/js-examples/typedarray-bytes-per-element.html",
+            "fileName": "typedarray-bytes-per-element.html",
+            "title": "JavaScript Demo: TypedArray.BYTES_PER_ELEMENT",
+            "type": "js"
         },
         "typedarrayConstructor": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-constructor.html",
-          "fileName": "typedarray-constructor.html",
-          "title": "JavaScript Demo: TypedArray Constructor",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode":
+                "live-examples/js-examples/typedarray-constructor.html",
+            "fileName": "typedarray-constructor.html",
+            "title": "JavaScript Demo: TypedArray Constructor",
+            "type": "js"
         },
         "typedarrayCopyWithin": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-copywithin.html",
-          "fileName": "typedarray-copywithin.html",
-          "title": "JavaScript Demo: TypedArray.copyWithin()",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode":
+                "live-examples/js-examples/typedarray-copywithin.html",
+            "fileName": "typedarray-copywithin.html",
+            "title": "JavaScript Demo: TypedArray.copyWithin()",
+            "type": "js"
         },
         "typedarrayEntries": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-entries.html",
-          "fileName": "typedarray-entries.html",
-          "title": "JavaScript Demo: TypedArray.entries()",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode": "live-examples/js-examples/typedarray-entries.html",
+            "fileName": "typedarray-entries.html",
+            "title": "JavaScript Demo: TypedArray.entries()",
+            "type": "js"
         },
         "typedarrayEvery": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-every.html",
-          "fileName": "typedarray-every.html",
-          "title": "JavaScript Demo: TypedArray.every()",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode": "live-examples/js-examples/typedarray-every.html",
+            "fileName": "typedarray-every.html",
+            "title": "JavaScript Demo: TypedArray.every()",
+            "type": "js"
         },
         "typedarrayFill": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-fill.html",
-          "fileName": "typedarray-fill.html",
-          "title": "JavaScript Demo: TypedArray.fill()",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode": "live-examples/js-examples/typedarray-fill.html",
+            "fileName": "typedarray-fill.html",
+            "title": "JavaScript Demo: TypedArray.fill()",
+            "type": "js"
         },
         "typedarrayFilter": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-filter.html",
-          "fileName": "typedarray-filter.html",
-          "title": "JavaScript Demo: TypedArray.filter()",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode": "live-examples/js-examples/typedarray-filter.html",
+            "fileName": "typedarray-filter.html",
+            "title": "JavaScript Demo: TypedArray.filter()",
+            "type": "js"
         },
         "typedarrayFind": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-find.html",
-          "fileName": "typedarray-find.html",
-          "title": "JavaScript Demo: TypedArray.find()",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode": "live-examples/js-examples/typedarray-find.html",
+            "fileName": "typedarray-find.html",
+            "title": "JavaScript Demo: TypedArray.find()",
+            "type": "js"
         },
         "typedarrayFindIndex": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-findindex.html",
-          "fileName": "typedarray-findindex.html",
-          "title": "JavaScript Demo: TypedArray.findIndex()",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode":
+                "live-examples/js-examples/typedarray-findindex.html",
+            "fileName": "typedarray-findindex.html",
+            "title": "JavaScript Demo: TypedArray.findIndex()",
+            "type": "js"
         },
         "typedarrayFrom": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-from.html",
-          "fileName": "typedarray-from.html",
-          "title": "JavaScript Demo: TypedArray.from()",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode": "live-examples/js-examples/typedarray-from.html",
+            "fileName": "typedarray-from.html",
+            "title": "JavaScript Demo: TypedArray.from()",
+            "type": "js"
         },
         "typedarrayIncludes": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-includes.html",
-          "fileName": "typedarray-includes.html",
-          "title": "JavaScript Demo: TypedArray.includes()",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode": "live-examples/js-examples/typedarray-includes.html",
+            "fileName": "typedarray-includes.html",
+            "title": "JavaScript Demo: TypedArray.includes()",
+            "type": "js"
         },
         "typedarrayIndexOf": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-indexof.html",
-          "fileName": "typedarray-indexof.html",
-          "title": "JavaScript Demo: TypedArray.indexOf()",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode": "live-examples/js-examples/typedarray-indexof.html",
+            "fileName": "typedarray-indexof.html",
+            "title": "JavaScript Demo: TypedArray.indexOf()",
+            "type": "js"
         },
         "typedarrayJoin": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-join.html",
-          "fileName": "typedarray-join.html",
-          "title": "JavaScript Demo: TypedArray.join()",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode": "live-examples/js-examples/typedarray-join.html",
+            "fileName": "typedarray-join.html",
+            "title": "JavaScript Demo: TypedArray.join()",
+            "type": "js"
         },
         "typedarrayKeys": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-keys.html",
-          "fileName": "typedarray-keys.html",
-          "title": "JavaScript Demo: TypedArray.keys()",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode": "live-examples/js-examples/typedarray-keys.html",
+            "fileName": "typedarray-keys.html",
+            "title": "JavaScript Demo: TypedArray.keys()",
+            "type": "js"
         },
         "typedarrayLastIndexOf": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-lastindexof.html",
-          "fileName": "typedarray-lastindexof.html",
-          "title": "JavaScript Demo: TypedArray.lastIndexOf()",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode":
+                "live-examples/js-examples/typedarray-lastindexof.html",
+            "fileName": "typedarray-lastindexof.html",
+            "title": "JavaScript Demo: TypedArray.lastIndexOf()",
+            "type": "js"
         },
         "typedarrayLength": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-length.html",
-          "fileName": "typedarray-length.html",
-          "title": "JavaScript Demo: TypedArray.length",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode": "live-examples/js-examples/typedarray-length.html",
+            "fileName": "typedarray-length.html",
+            "title": "JavaScript Demo: TypedArray.length",
+            "type": "js"
         },
         "typedarrayMap": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-map.html",
-          "fileName": "typedarray-map.html",
-          "title": "JavaScript Demo: TypedArray.map()",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode": "live-examples/js-examples/typedarray-map.html",
+            "fileName": "typedarray-map.html",
+            "title": "JavaScript Demo: TypedArray.map()",
+            "type": "js"
         },
         "typedarrayName": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-name.html",
-          "fileName": "typedarray-name.html",
-          "title": "JavaScript Demo: TypedArray.name",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode": "live-examples/js-examples/typedarray-name.html",
+            "fileName": "typedarray-name.html",
+            "title": "JavaScript Demo: TypedArray.name",
+            "type": "js"
         },
         "typedarrayOf": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-of.html",
-          "fileName": "typedarray-of.html",
-          "title": "JavaScript Demo: TypedArray.of()",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode": "live-examples/js-examples/typedarray-of.html",
+            "fileName": "typedarray-of.html",
+            "title": "JavaScript Demo: TypedArray.of()",
+            "type": "js"
         },
         "typedarrayReduce": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-reduce.html",
-          "fileName": "typedarray-reduce.html",
-          "title": "JavaScript Demo: TypedArray.reduce()",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode": "live-examples/js-examples/typedarray-reduce.html",
+            "fileName": "typedarray-reduce.html",
+            "title": "JavaScript Demo: TypedArray.reduce()",
+            "type": "js"
         },
         "typedarrayReverse": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-reverse.html",
-          "fileName": "typedarray-reverse.html",
-          "title": "JavaScript Demo: TypedArray.reverse()",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode": "live-examples/js-examples/typedarray-reverse.html",
+            "fileName": "typedarray-reverse.html",
+            "title": "JavaScript Demo: TypedArray.reverse()",
+            "type": "js"
         },
         "typedarraySet": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-set.html",
-          "fileName": "typedarray-set.html",
-          "title": "JavaScript Demo: TypedArray.set()",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode": "live-examples/js-examples/typedarray-set.html",
+            "fileName": "typedarray-set.html",
+            "title": "JavaScript Demo: TypedArray.set()",
+            "type": "js"
         },
         "typedarraySlice": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-slice.html",
-          "fileName": "typedarray-slice.html",
-          "title": "JavaScript Demo: TypedArray.slice()",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode": "live-examples/js-examples/typedarray-slice.html",
+            "fileName": "typedarray-slice.html",
+            "title": "JavaScript Demo: TypedArray.slice()",
+            "type": "js"
         },
         "typedarraySome": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-some.html",
-          "fileName": "typedarray-some.html",
-          "title": "JavaScript Demo: TypedArray.some()",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode": "live-examples/js-examples/typedarray-some.html",
+            "fileName": "typedarray-some.html",
+            "title": "JavaScript Demo: TypedArray.some()",
+            "type": "js"
         },
         "typedarraySort": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-sort.html",
-          "fileName": "typedarray-sort.html",
-          "title": "JavaScript Demo: TypedArray.sort()",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode": "live-examples/js-examples/typedarray-sort.html",
+            "fileName": "typedarray-sort.html",
+            "title": "JavaScript Demo: TypedArray.sort()",
+            "type": "js"
         },
         "typedarraySubarray": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-subarray.html",
-          "fileName": "typedarray-subarray.html",
-          "title": "JavaScript Demo: TypedArray.subarray()",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode": "live-examples/js-examples/typedarray-subarray.html",
+            "fileName": "typedarray-subarray.html",
+            "title": "JavaScript Demo: TypedArray.subarray()",
+            "type": "js"
         },
         "typedarrayToString": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-tostring.html",
-          "fileName": "typedarray-tostring.html",
-          "title": "JavaScript Demo: TypedArray.tostring()",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode": "live-examples/js-examples/typedarray-tostring.html",
+            "fileName": "typedarray-tostring.html",
+            "title": "JavaScript Demo: TypedArray.tostring()",
+            "type": "js"
         },
         "typedarrayValues": {
-          "baseTmpl": "tmpl/live-js-tmpl.html",
-          "exampleCode": "live-examples/js-examples/typedarray-values.html",
-          "fileName": "typedarray-values.html",
-          "title": "JavaScript Demo: TypedArray.values()",
-          "type": "js"
+            "baseTmpl": "tmpl/live-js-tmpl.html",
+            "exampleCode": "live-examples/js-examples/typedarray-values.html",
+            "fileName": "typedarray-values.html",
+            "title": "JavaScript Demo: TypedArray.values()",
+            "type": "js"
         },
         "animation": {
             "baseTmpl": "tmpl/live-css-tmpl.html",
-            "cssExampleSrc": "../../live-examples/css-examples/css/animation.css",
+            "cssExampleSrc":
+                "../../live-examples/css-examples/css/animation.css",
             "exampleCode": "live-examples/css-examples/animation.html",
             "fileName": "animation.html",
             "title": "CSS Demo: Animation",
@@ -1930,7 +2022,8 @@
         },
         "backgroundClip": {
             "baseTmpl": "tmpl/live-css-tmpl.html",
-            "cssExampleSrc": "../../live-examples/css-examples/css/background-clip.css",
+            "cssExampleSrc":
+                "../../live-examples/css-examples/css/background-clip.css",
             "exampleCode": "live-examples/css-examples/background-clip.html",
             "fileName": "background-clip.html",
             "title": "CSS Demo: Background Clip",
@@ -1938,7 +2031,8 @@
         },
         "backgroundColor": {
             "baseTmpl": "tmpl/live-css-tmpl.html",
-            "cssExampleSrc": "../../live-examples/css-examples/css/background-color.css",
+            "cssExampleSrc":
+                "../../live-examples/css-examples/css/background-color.css",
             "exampleCode": "live-examples/css-examples/background-color.html",
             "fileName": "background-color.html",
             "title": "CSS Demo: Background Color",
@@ -1946,7 +2040,8 @@
         },
         "backgroundImage": {
             "baseTmpl": "tmpl/live-css-tmpl.html",
-            "cssExampleSrc": "../../live-examples/css-examples/css/background-image.css",
+            "cssExampleSrc":
+                "../../live-examples/css-examples/css/background-image.css",
             "exampleCode": "live-examples/css-examples/background-image.html",
             "fileName": "background-image.html",
             "title": "CSS Demo: Background Image",
@@ -1954,15 +2049,18 @@
         },
         "backgroundPosition": {
             "baseTmpl": "tmpl/live-css-tmpl.html",
-            "cssExampleSrc": "../../live-examples/css-examples/css/background-position.css",
-            "exampleCode": "live-examples/css-examples/background-position.html",
+            "cssExampleSrc":
+                "../../live-examples/css-examples/css/background-position.css",
+            "exampleCode":
+                "live-examples/css-examples/background-position.html",
             "fileName": "background-position.html",
             "title": "CSS Demo: Background Position",
             "type": "css"
         },
         "backgroundRepeat": {
             "baseTmpl": "tmpl/live-css-tmpl.html",
-            "cssExampleSrc": "../../live-examples/css-examples/css/background-repeat.css",
+            "cssExampleSrc":
+                "../../live-examples/css-examples/css/background-repeat.css",
             "exampleCode": "live-examples/css-examples/background-repeat.html",
             "fileName": "background-repeat.html",
             "title": "CSS Demo: Background Repeat",
@@ -1970,7 +2068,8 @@
         },
         "backgroundSize": {
             "baseTmpl": "tmpl/live-css-tmpl.html",
-            "cssExampleSrc": "../../live-examples/css-examples/css/background-size.css",
+            "cssExampleSrc":
+                "../../live-examples/css-examples/css/background-size.css",
             "exampleCode": "live-examples/css-examples/background-size.html",
             "fileName": "background-size.html",
             "title": "CSS Demo: Background Size",
@@ -1978,7 +2077,8 @@
         },
         "borderImage": {
             "baseTmpl": "tmpl/live-css-tmpl.html",
-            "cssExampleSrc": "../../live-examples/css-examples/css/border-image.css",
+            "cssExampleSrc":
+                "../../live-examples/css-examples/css/border-image.css",
             "exampleCode": "live-examples/css-examples/border-image.html",
             "fileName": "border-image.html",
             "title": "CSS Demo: Background Image",
@@ -1986,7 +2086,8 @@
         },
         "borderStyle": {
             "baseTmpl": "tmpl/live-css-tmpl.html",
-            "cssExampleSrc": "../../live-examples/css-examples/css/border-style.css",
+            "cssExampleSrc":
+                "../../live-examples/css-examples/css/border-style.css",
             "exampleCode": "live-examples/css-examples/border-style.html",
             "fileName": "border-style.html",
             "title": "CSS Demo: Border Style",
@@ -1994,7 +2095,8 @@
         },
         "borderTopColor": {
             "baseTmpl": "tmpl/live-css-tmpl.html",
-            "cssExampleSrc": "../../live-examples/css-examples/css/border-top-color.css",
+            "cssExampleSrc":
+                "../../live-examples/css-examples/css/border-top-color.css",
             "exampleCode": "live-examples/css-examples/border-top-color.html",
             "fileName": "border-top-color.html",
             "title": "CSS Demo: Border Top Color",
@@ -2002,7 +2104,8 @@
         },
         "boxShadow": {
             "baseTmpl": "tmpl/live-css-tmpl.html",
-            "cssExampleSrc": "../../live-examples/css-examples/css/box-shadow.css",
+            "cssExampleSrc":
+                "../../live-examples/css-examples/css/box-shadow.css",
             "exampleCode": "live-examples/css-examples/box-shadow.html",
             "fileName": "box-shadow.html",
             "title": "CSS Demo: Box Shadow",
@@ -2033,7 +2136,8 @@
         },
         "fontStyle": {
             "baseTmpl": "tmpl/live-css-tmpl.html",
-            "cssExampleSrc": "../../live-examples/css-examples/css/fonts-base.css",
+            "cssExampleSrc":
+                "../../live-examples/css-examples/css/fonts-base.css",
             "exampleCode": "live-examples/css-examples/font-style.html",
             "fileName": "font-style.html",
             "title": "CSS Demo: Font Style",
@@ -2041,7 +2145,8 @@
         },
         "fontWeight": {
             "baseTmpl": "tmpl/live-css-tmpl.html",
-            "cssExampleSrc": "../../live-examples/css-examples/css/fonts-base.css",
+            "cssExampleSrc":
+                "../../live-examples/css-examples/css/fonts-base.css",
             "exampleCode": "live-examples/css-examples/font-weight.html",
             "fileName": "font-weight.html",
             "title": "CSS Demo: Font Weight",
@@ -2049,7 +2154,8 @@
         },
         "position": {
             "baseTmpl": "tmpl/live-css-tmpl.html",
-            "cssExampleSrc": "../../live-examples/css-examples/css/position.css",
+            "cssExampleSrc":
+                "../../live-examples/css-examples/css/position.css",
             "exampleCode": "live-examples/css-examples/position.html",
             "fileName": "position.html",
             "jsExampleSrc": "../../live-examples/css-examples/js/position.js",
@@ -2058,7 +2164,8 @@
         },
         "textAlign": {
             "baseTmpl": "tmpl/live-css-tmpl.html",
-            "cssExampleSrc": "../../live-examples/css-examples/css/fonts-base.css",
+            "cssExampleSrc":
+                "../../live-examples/css-examples/css/fonts-base.css",
             "exampleCode": "live-examples/css-examples/text-align.html",
             "fileName": "text-align.html",
             "title": "CSS Demo: Text Align",
diff --git a/tmpl/live-js-tmpl.html b/tmpl/live-js-tmpl.html
index 99a04e009..aa5b6c7dd 100644
--- a/tmpl/live-js-tmpl.html
+++ b/tmpl/live-js-tmpl.html
@@ -28,7 +28,7 @@
       </section>
 
     %example-js-src%
-    <script src="../../js/codemirror.js"></script>
+    <script data-main="../../js/codemirrorLoader" src="../../js/require.js"></script>
     <script src="../../js/editor-js.js"></script>
   </body>
 </html>