Add test data for spaceport benchmark.

chrome/test/data/third_party/spaceport/js/unrequire.js

+/** @preserve
+ * unrequire.js
+ *
+ * Copyright 2011 Sibblingz, Inc.
+ *
+ * Licensed under MIT
+ */
+
+// XXX Lines between comments with @{{{ and @}}} are removed when building
+
+//@{{{
+(function () {
+//@}}}
+
+    // MIT: http://trac.webkit.org/wiki/DetectingWebKit
+    var IS_WEBKIT = typeof navigator !== 'undefined' && navigator && / AppleWebKit\//.test(navigator.userAgent);
+
+    var HAS_SETTIMEOUT = typeof setTimeout === 'function';
+
+    //@{{{
+
+    // Logging support
+    var LOGGING = false;
+
+    // Show debug warnings
+    var WARNINGS = true;
+
+    // Aliases support
+    var ENABLE_ALIASES = true;
+
+    // Packages support
+    var ENABLE_PACKAGES = true;
+
+    // Web browser support
+    var ENABLE_BROWSER = true;
+
+    // Web browser should try to make synchronous requests
+    var BROWSER_SYNC = false;
+
+    // Node.JS support
+    var ENABLE_NODEJS = true;
+
+    // Spaceport support
+    var ENABLE_SPACEPORT = true;
+
+    // CommonJS compatibility
+    var COMMONJS_COMPAT = true;
+
+    // Check for circular dependencies
+    var CHECK_CYCLES = true;
+
+    //@}}}
+
+    // Utility functions {{{
+    var hasOwnProperty = ({ }).hasOwnProperty;
+    var toString = ({ }).toString;
+
+    // For minification
+    var dot = '.';
+    var dotdot = '..';
+
+    function hasOwn(obj, name) {
+        return obj && hasOwnProperty.call(obj, name);
+    }
+
+    function isArray(x) {
+        return toString.call(x) === '[object Array]';
+    }
+
+    function isPlainOldObject(x) {
+        return toString.call(x) === '[object Object]';
+    }
+
+    function map(array, fn, context) {
+        // TODO Fallback if Function.prototype.map is missing
+        return array.map(fn, context);
+    }
+
+    var forEach = map;
+
+    function extend(base, extension) {
+        var key;
+
+        for (key in extension) {
+            if (hasOwn(extension, key)) {
+                base[key] = extension[key];
+            }
+        }
+
+        return base;
+    }
+
+    function clone(object, extension) {
+        return extend(extend({ }, object), extension || { });
+    }
+    // Utility functions }}}
+
+    // Path functions {{{
+    function stringToPath(parts) {
+        parts = isArray(parts) ? parts : [ parts ];
+
+        var splitParts = [ ];
+        var i;
+
+        for (i = 0; i < parts.length; ++i) {
+            splitParts = splitParts.concat(parts[i].split(/\//g));
+        }
+
+        return splitParts;
+    }
+
+    function pathToString(path) {
+        var s = path
+            .join('/')
+            .replace(/\/+/g, '/');
+
+        if (path.length === 0 && path[0] === '') {
+            s = '/' + s;
+        }
+
+        return s;
+    }
+
+    function normalizePath(path) {
+        var newPath = [ ];
+        var i;
+
+        for (i = 0; i < path.length; ++i) {
+            if (!path[i]) {
+                // Root
+                newPath = [ '' ];
+            } else if (path[i] === dotdot) {
+                // Go back
+                if (!newPath.length) {
+                    newPath = [ dotdot ];
+                } else if (newPath.length === 1) {
+                    if (newPath[0] === dot || !newPath[0]) {
+                        newPath = [ dotdot ];
+                    } else {
+                        newPath.pop();
+                    }
+                } else {
+                    newPath.pop();
+                }
+            } else if (path[i] === dot) {
+                // Go here
+                if (!newPath.length) {
+                    newPath = [ dot ];
+                }
+            } else {
+                // Everything else
+                newPath.push(path[i]);
+            }
+        }
+
+        return newPath;
+    }
+
+    function resolveUrl(cwd, baseUrl, path) {
+        var cwdPath = normalizePath(stringToPath(cwd));
+        var basePath = normalizePath(stringToPath(baseUrl || dot));
+        var npath = normalizePath(stringToPath(path));
+
+        if (npath[0] === dotdot || npath[0] === dot) {
+            // Relative paths are based on cwd
+            return pathToString(normalizePath(cwdPath.concat(npath)));
+        } else if (npath[0] === '') {
+            // Absolute path stays absolute
+            return pathToString(npath);
+        } else {
+            // Implicit relative paths are based on baseUrl
+            return pathToString(basePath.concat(npath));
+        }
+    }
+
+    function resolveCwd(baseUrl, cwd) {
+        var basePath = normalizePath(stringToPath(baseUrl || dot));
+        var npath = normalizePath(stringToPath(cwd));
+
+        if (npath[0] === dotdot || npath[0] === dot) {
+            // Relative paths are absolute
+            return pathToString(npath);
+        } else if (npath[0] === '') {
+            // Absolute path stays absolute
+            return pathToString(npath);
+        } else {
+            // Implicit relative paths are based on baseUrl
+            return pathToString(basePath.concat(npath));
+        }
+    }
+
+    function dirname(url) {
+        var path = stringToPath(url);
+        path = path.slice(0, path.length - 1);
+        return pathToString(path);
+    }
+    // Path functions }}}
+
+    // Argument extraction functions {{{
+    function defArgs(name, config, deps, callback) {
+        if (typeof name !== 'string') {
+            // Name omitted
+            callback = deps;
+            deps = config;
+            config = name;
+            name = null;
+        }
+
+        if (!isPlainOldObject(config)) {
+            // Config omitted
+            callback = deps;
+            deps = config;
+            config = { };
+        }
+
+        if (!isArray(deps)) {
+            // Dependencies omitted
+            callback = deps;
+            deps = [ ];
+        }
+
+        return {
+            name: name,
+            config: config,
+            deps: deps,
+            callback: callback
+        };
+    }
+
+    function reqArgs(config, deps, callback) {
+        // TODO require(string)
+        if (typeof config === 'string') {
+            throw new Error('Not supported');
+        }
+
+        if (!isPlainOldObject(config)) {
+            // Config omitted
+            callback = deps;
+            deps = config;
+            config = { };
+        }
+
+        if (!isArray(deps)) {
+            // Dependencies omitted
+            callback = deps;
+            deps = [ ];
+        }
+
+        return {
+            config: config,
+            deps: deps,
+            callback: callback
+        };
+    }
+    // Argument extraction functions }}}
+
+    function getScriptName(moduleName, config) {
+        if (ENABLE_ALIASES) {
+            if (hasOwn(config._aliases, moduleName)) {
+                return config._aliases[moduleName];
+            }
+        }
+
+        var scriptName = resolveUrl(config.cwd, config.baseUrl, moduleName);
+        scriptName = scriptName + (/\.js$/i.test(scriptName) ? '' : '.js');
+        return scriptName;
+    }
+
+    function mergeConfigInto(base, augmentation) {
+        // The order of these checks are important, because changes cascade
+
+        if (hasOwn(augmentation, 'baseUrl')) {
+            base.baseUrl = resolveUrl(base.cwd, base.baseUrl, augmentation.baseUrl);
+        }
+
+        if (hasOwn(augmentation, 'cwd')) {
+            base.cwd = augmentation.cwd;
+            //base.cwd = resolveCwd(base.baseUrl, augmentation.cwd);
+        }
+
+        if (ENABLE_ALIASES) {
+            if (hasOwn(base, '_aliases')) {
+                base._aliases = clone(base._aliases);
+            } else {
+                base._aliases = { };
+            }
+
+            if (hasOwn(augmentation, '_aliases')) {
+                extend(base._aliases, augmentation._aliases);
+            }
+
+            if (hasOwn(augmentation, 'aliases')) {
+                var aliasName;
+                for (aliasName in augmentation.aliases) {
+                    if (!hasOwn(augmentation.aliases, aliasName)) {
+                        continue;
+                    }
+
+                    var aliasTarget = augmentation.aliases[aliasName];
+
+                    // Aliases are stored as their full script name
+                    base._aliases[aliasName] = getScriptName(aliasTarget, base);
+                }
+            }
+        }
+
+        if (ENABLE_PACKAGES) {
+            if (hasOwn(base, '_packageOwners')) {
+                base._packageOwners = clone(base._packageOwners);
+            } else {
+                base._packageOwners = { };
+            }
+
+            if (hasOwn(augmentation, '_packageOwners')) {
+                extend(base._packageOwners, augmentation._packageOwners);
+            }
+
+            if (hasOwn(augmentation, 'packages')) {
+                var packageName;
+                for (packageName in augmentation.packages) {
+                    if (!hasOwn(augmentation.packages, packageName)) {
+                        continue;
+                    }
+
+                    var packageOwner = getScriptName(packageName, base);
+                    forEach(augmentation.packages[packageName], function (moduleName) {
+                        base._packageOwners[getScriptName(moduleName, base)] = packageOwner;
+                    });
+                }
+            }
+        }
+    }
+
+    function mergeConfigs(first, second) {
+        var base = clone(first);
+        mergeConfigInto(base, second);
+        return base;
+    }
+
+    function findCycles(graph, vertices) {
+        var vertexIndices = { };
+        var vertexLowLinks = { };
+
+        var index = 0;
+        var stack = [ ];
+
+        var cycles = [ ];
+
+        function strongConnect(v) {
+            vertexIndices[v] = index;
+            vertexLowLinks[v] = index;
+            ++index;
+            stack.push(v);
+
+            if (hasOwn(graph, v)) {
+                graph[v].forEach(function (w) {
+                    if (!hasOwn(vertexIndices, w)) {
+                        strongConnect(w);
+                        vertexLowLinks[v] = Math.min(vertexLowLinks[v], vertexLowLinks[w]);
+                    } else if (stack.indexOf(w) >= 0) {
+                        vertexLowLinks[v] = Math.min(vertexLowLinks[v], vertexIndices[w]);
+                    }
+                });
+            }
+
+            if (vertexLowLinks[v] === vertexIndices[v]) {
+                var cycle = [ ];
+                var w;
+                do {
+                    w = stack.pop();
+                    cycle.push(w);
+                } while (w !== v);
+                cycles.push(cycle);
+            }
+        }
+
+        vertices.forEach(function (vertex) {
+            if (!hasOwn(vertexIndices, vertex)) {
+                strongConnect(vertex);
+            }
+        });
+
+        return cycles;
+    }
+
+    // dependencyGraph :: Map String [String]
+    var dependencyGraph = { };
+
+    // pulledScripts :: [String]
+    var pulledScripts = [ ];
+
+    function addDependency(from, to) {
+        if (hasOwn(dependencyGraph, from)) {
+            dependencyGraph[from].push(to);
+        } else {
+            dependencyGraph[from] = [ to ];
+        }
+    }
+
+    function checkCircularDependencies() {
+        var cycles = findCycles(dependencyGraph, pulledScripts);
+
+        cycles.forEach(function (cycle) {
+            if (cycle.length > 1) {
+                throw new Error('Circular dependency detected between scripts: ' + cycle.join(' '));
+            }
+        });
+    }
+
+    function getScriptsDependingUpon(scriptName) {
+        var scripts = [ ];
+
+        for (var curScript in dependencyGraph) {
+            if (hasOwn(dependencyGraph, curScript)) {
+                if (dependencyGraph[curScript].indexOf(scriptName) >= 0) {
+                    scripts.push(curScript);
+                }
+            }
+        }
+
+        return scripts;
+    }
+
+    // requestedScripts :: Map String Bool
+    var requestedScripts = { };
+
+    // requestingScriptCount :: Int
+    var requestingScriptCount = 0;
+
+    // We have two queues here.
+    //
+    // The script complete queue is built up while executing scripts.  A define
+    // call adds to this queue.  The queue is flushed when the script completes
+    // execution.  This allows us to determine which script was executed
+    // exactly for asynchronous loads.
+    //
+    // A load callback queue is built up after a define call knows its complete
+    // name configuration.  It is executed when that defined module is
+    // requested.  This allows for lazy loading of defiend modules, and also
+    // allows for asynchronous module definitions.  There is a mapping of
+    // script name to load callback queue, thus this queue is a hash and not an
+    // array.
+
+    // scriptCompleteQueue :: [Maybe Error -> Configuration -> IO ()]
+    var scriptCompleteQueue = [ ];
+
+    // loadCallbackQueues :: Map String [IO ()]
+    var loadCallbackQueues = { };
+
+    // The push-pull mechanism decouples requesters of a module from definers
+    // of a module.  When a module is defined, it is "pushed"; when a module is
+    // requested, it is "pulled".  If a pull is made on an already-pushed
+    // module name, the pull callback is executed immediately.  Else, the pull
+    // callback is executed immediately when the appropriate push is made.
+
+    // pushed :: Map String a
+    var pushed = { };
+
+    // pulling :: Map String [Maybe Error -> a -> IO ()]
+    var pulling = { };
+
+    function checkPullForLoadCallback(scriptName) {
+        if (hasOwn(pulling, scriptName) && hasOwn(loadCallbackQueues, scriptName)) {
+            var callbacks = loadCallbackQueues[scriptName];
+            delete loadCallbackQueues[scriptName];
+
+            forEach(callbacks, function (callback) {
+                callback();
+            });
+        }
+    }
+
+    function checkPullForPush(scriptName, value) {
+        if (hasOwn(pulling, scriptName) && hasOwn(pushed, scriptName)) {
+            var callbacks = pulling[scriptName];
+            delete pulling[scriptName];
+
+            forEach(callbacks, function (callback) {
+                callback(null, pushed[scriptName]);
+            });
+        }
+    }
+
+    function enqueueLoadCallback(scriptName, callback) {
+        if (hasOwn(loadCallbackQueues, scriptName)) {
+            loadCallbackQueues[scriptName].push(callback);
+        } else {
+            loadCallbackQueues[scriptName] = [ callback ];
+        }
+
+        checkPullForLoadCallback(scriptName);
+    }
+
+    function enqueueScriptCompleteCallback(callback) {
+        if (requestingScriptCount > 0) {
+            scriptCompleteQueue.push(callback);
+        } else {
+            callback(null, { });
+        }
+    }
+
+    function push(scriptName, value) {
+        if (hasOwn(pushed, scriptName)) {
+            throw new Error('Should not push value for ' + scriptName + ' again');
+        }
+
+        pushed[scriptName] = value;
+
+        checkPullForPush(scriptName);
+    }
+
+    function pull(scriptName, callback) {
+        if (CHECK_CYCLES) {
+            pulledScripts.push(scriptName);
+        }
+
+        if (hasOwn(pulling, scriptName)) {
+            pulling[scriptName].push(callback);
+        } else {
+            pulling[scriptName] = [ callback ];
+        }
+
+        checkPullForLoadCallback(scriptName);
+        checkPullForPush(scriptName);
+    }
+
+    function needsRequest(scriptName) {
+        return !hasOwn(requestedScripts, scriptName) && !hasOwn(pushed, scriptName) && !hasOwn(loadCallbackQueues, scriptName);
+    }
+
+    // Entry points {{{
+    function create(configuration) {
+        var context = extend({
+            'require': req,
+            'define': def,
+            'reconfigure': reconfigure,
+            'userCallback': defaultUserCallback
+        }, configuration);
+
+        var baseConfig = {
+            cwd: '.',
+            baseUrl: '.'
+        };
+
+        context.configuration = configuration;
+        req.config = config;
+        req.debug = debug;
+
+        return context;
+
+        function config(config) {
+            mergeConfigInto(baseConfig, config);
+        }
+
+        function defaultUserCallback(scriptName, data, moduleValues, moduleScripts, moduleNames, callback) {
+            if (LOGGING) {
+                console.log('Executing', scriptName);
+            }
+
+            var moduleValue;
+            if (typeof data === 'function') {
+                if (COMMONJS_COMPAT && data.length === 3 && moduleNames.length === 0) {
+                    moduleValues = [
+                        // require
+                        function () {
+                            throw new Error('Not supported');
+                        },
+
+                        // exports
+                        { },
+
+                        // module
+                        { } // TODO
+                    ];
+                }
+
+                moduleValue = data.apply(null, moduleValues);
+
+                if (COMMONJS_COMPAT && data.length === 3 && moduleNames.length === 0) {
+                    if (typeof moduleValue === 'undefined') {
+                        moduleValue = moduleValues[1]; // exports
+                    }
+                }
+            } else {
+                moduleValue = data;
+            }
+
+            callback(null, moduleValue);
+        }
+
+        function reconfigure(configuration) {
+            extend(context, configuration);
+        }
+
+        function getRequestScriptName(scriptName, config) {
+            if (ENABLE_PACKAGES) {
+                if (hasOwn(config._packageOwners, scriptName)) {
+                    return config._packageOwners[scriptName];
+                }
+            }
+
+            return scriptName;
+        }
+
+        function request(scriptName, config, callback) {
+            if (!needsRequest(scriptName)) {
+                throw new Error('Should not request ' + scriptName + ' again');
+            }
+
+            if (LOGGING) {
+                console.log('Requesting script ' + scriptName);
+            }
+
+            requestedScripts[scriptName] = true;
+            ++requestingScriptCount;
+
+            function done(err) {
+                --requestingScriptCount;
+
+                var scriptCompleteCallbacks = scriptCompleteQueue;
+                scriptCompleteQueue = [ ];
+
+                if (!err) {
+                    if (scriptCompleteCallbacks.length === 0) {
+                        console.warn('Possibly missing define for script ' + scriptName);
+                    }
+                }
+
+                callback(err, scriptCompleteCallbacks);
+            }
+
+            function tryAsync() {
+            }
+
+            // Try a sync load first
+            if (context.loadScriptSync) {
+                // We have this setTimeout logic to handle exceptions thrown by
+                // loadScriptSync.  We do not catch exceptions (so debugging is
+                // easier for users), or deal with the 'finally' mess, but
+                // still call done().
+                var timer;
+                if (HAS_SETTIMEOUT) {
+                    timer = setTimeout(function () {
+                        done(new Error('Script threw exception'));
+                    }, 0);
+                }
+
+                var success = context.loadScriptSync(scriptName, config);
+
+                if (HAS_SETTIMEOUT) {
+                    clearTimeout(timer);
+                }
+
+                if (success) {
+                    done(null);
+                    return;
+                }
+            }
+
+            if (context.loadScriptAsync) {
+                return context.loadScriptAsync(scriptName, done, config);
+            }
+
+            done(new Error('Failed to load script'));
+        }
+
+        function requestAndPullMany(scriptNames, config, callback) {
+            var loaded = [ ];
+            var values = [ ];
+            var i;
+            var called = false;
+
+            function checkValues() {
+                if (called) return;
+
+                var i;
+
+                for (i = 0; i < scriptNames.length; ++i) {
+                    if (!loaded[i]) return;
+                }
+
+                called = true;
+                callback(null, values, scriptNames);
+            }
+
+            forEach(scriptNames, function (scriptName, i) {
+                var requestScriptName = getRequestScriptName(scriptName, config);
+
+                if (needsRequest(requestScriptName)) {
+                    request(requestScriptName, config, function (err, callbacks) {
+                        var neoConfig = mergeConfigs(config, { });
+                        neoConfig.cwd = dirname(requestScriptName);
+                        neoConfig.scriptName = scriptName;
+
+                        forEach(callbacks, function (callback) {
+                            callback(err, neoConfig);
+                        });
+
+                        if (err) {
+                            var errorString = 'Failed to load ' + requestScriptName;
+
+                            var dependers = getScriptsDependingUpon(requestScriptName);
+                            if (dependers.length) {
+                                errorString += ' (depended upon by ' + dependers.join(', ') + ')';
+                            }
+
+                            console.error(errorString, err);
+                        }
+                    });
+                }
+
+                pull(scriptName, function (err, value) {
+                    if (err) throw err;
+
+                    loaded[i] = true;
+                    values[i] = value;
+                    checkValues();
+                });
+            });
+
+            // In case we have no scripts to load
+            checkValues();
+        }
+
+        function req() {
+            // TODO require(string)
+
+            var args = reqArgs.apply(null, arguments);
+            var config = args.config;
+            var deps = args.deps;
+            var callback = args.callback;
+
+            if (LOGGING) {
+                console.log('Requiring [ ' + (deps || [ ]).join(', ') + ' ]');
+            }
+
+            var effectiveConfig = mergeConfigs(baseConfig, config);
+
+            enqueueScriptCompleteCallback(function (err, config) {
+                if (err) throw err;
+
+                mergeConfigInto(effectiveConfig, config);
+
+                var scriptNames = map(deps, function (dep) {
+                    return getScriptName(dep, effectiveConfig);
+                });
+
+                requestAndPullMany(scriptNames, effectiveConfig, function (err, values) {
+                    if (err) throw err;
+
+                    context.userCallback(null, callback, values, scriptNames, deps.slice(), function (err, value) {
+                        if (err) throw err;
+
+                        // Ignore value
+                    });
+                });
+            });
+        }
+
+        function def() {
+            var args = defArgs.apply(null, arguments);
+            var name = args.name;
+            var config = args.config;
+            var deps = args.deps;
+            var callback = args.callback;
+
+            if (LOGGING) {
+                console.log('Defining ' + (name || 'unnamed package') + ' with dependencies [ ' + (deps || [ ]).join(', ') + ' ]');
+            }
+
+            var effectiveConfig = mergeConfigs(baseConfig, config);
+
+            enqueueScriptCompleteCallback(function (err, config) {
+                if (err) throw err;
+
+                var oldEffectiveConfig = clone(effectiveConfig);
+
+                // Script name resolution should occur *before* merging config into
+                // effectiveConfig
+                mergeConfigInto(effectiveConfig, config);
+
+                var scriptName;
+                if (name) {
+                    scriptName = getScriptName(name, effectiveConfig);
+                } else {
+                    scriptName = config.scriptName;
+                }
+
+                enqueueLoadCallback(scriptName, function () {
+                    var scriptNames = map(deps, function (dep) {
+                        return getScriptName(dep, effectiveConfig);
+                    });
+
+                    if (CHECK_CYCLES) {
+                        map(scriptNames, function (dep) {
+                            addDependency(scriptName, dep);
+                        });
+                    }
+
+                    checkCircularDependencies();
+
+                    requestAndPullMany(scriptNames, effectiveConfig, function (err, values) {
+                        if (err) throw err;
+
+                        context.userCallback(scriptName, callback, values, scriptNames, deps.slice(), function (err, value) {
+                            if (err) throw err;
+
+                            push(scriptName, value);
+                        });
+                    });
+                });
+            });
+        }
+
+        function debug() {
+            console.log('Pulling:', pulling);
+        }
+    }
+    // Entry points }}}
+
+    (function () {
+        var un;
+
+        if (ENABLE_SPACEPORT && typeof loadScript === 'function') {
+            // Must be first, because Spaceport has the window object, too.
+            un = create({
+                'loadScriptAsync': function (scriptName, callback) {
+                    loadScript(scriptName, function () {
+                        callback(null);
+                    });
+                },
+                'loadScriptSync': function (scriptName) {
+                    return false;
+                }
+            });
+
+            // Set globals
+            require = un['require'];
+            define = un['define'];
+        } else if (ENABLE_BROWSER && typeof window !== 'undefined') {
+            var goodResponseCodes = [ 200, 204, 206, 301, 302, 303, 304, 307 ];
+            var doc = window.document;
+
+            var onreadystatechange = 'onreadystatechange';
+            var onload = 'onload';
+            var onerror = 'onerror';
+
+            function isCleanPath(scriptName) {
+                // If the path is "back" too much, it's not clean.
+                var x = stringToPath(dirname(window.location.pathname))
+                    .concat(stringToPath(scriptName));
+                x = normalizePath(x);
+                return x[0] !== '..';
+            }
+
+            var webkitOnloadFlag = false;
+
+            un = create({
+                'loadScriptAsync': function loadScriptAsync(scriptName, callback) {
+                    if (!isCleanPath(scriptName)) {
+                        setTimeout(function () {
+                            callback(new Error('Path ' + scriptName + ' is not clean'));
+                        }, 0);
+                        return;
+                    }
+
+                    var script = doc.createElement('script');
+                    script.async = true;
+
+                    // Modelled after jQuery (src/ajax/script.js)
+                    script[onload] = script[onreadystatechange] = function () {
+                        if (!script.readyState || /loaded|complete/.test(script.readyState)) {
+                            // Remove from DOM
+                            var parent = script.parentNode;
+                            if (parent) {
+                                parent.removeChild(script);
+                            }
+
+                            // IE likes memleaks
+                            script[onload] = script[onreadystatechange] = script[onerror] = null;
+                            script = null;
+
+                            callback(null);
+                        }
+                    };
+
+                    script[onerror] = function () {
+                        callback(new Error('Failed to load script'));
+                    };
+
+                    // Remember: we need to attach event handlers before
+                    // assigning `src`.  Events may be fired as soon as we set
+                    // `src`.
+                    script.src = scriptName;
+
+                    doc['head'].appendChild(script);
+                },
+                'loadScriptSync': function loadScriptSync(scriptName) {
+                    // We provide synchronous script loading via XHR for
+                    // browsers specifically to work around a Webkit bug.
+                    // After document.onload is called, any script dynamically
+                    // loaded will be loaded from Webkit's local cache; *no
+                    // HTTP request is made at all*.
+
+                    if (!BROWSER_SYNC) {
+                        if (IS_WEBKIT) {
+                            if (/loaded|complete/.test(document.readyState)) {
+                                // Don't load synchronously if the document has already loaded
+                                if (WARNINGS && !webkitOnloadFlag) {
+                                    console.warn('Scripts being loaded after document.onload; scripts may be loaded from out-of-date cache');
+                                    webkitOnloadFlag = true;
+                                }
+
+                                if (WARNINGS) {
+                                    console.warn('Script possibly loaded from out-of-date cache: ' + scriptName);
+                                }
+
+                                return false;
+                            }
+
+                            // Fall through; load synchronously anyway
+                        } else {
+                            return false;
+                        }
+                    }
+
+                    if (!isCleanPath(scriptName)) {
+                        return false;
+                    }
+
+                    var scriptSource;
+
+                    try {
+                        var xhr = new XMLHttpRequest();
+                        xhr.open('GET', scriptName, false);
+                        xhr.send(null);
+
+                        if (goodResponseCodes.indexOf(xhr.status) < 0) {
+                            return false;
+                        }
+
+                        scriptSource = xhr.responseText;
+                        scriptSource += '\n\n//*/\n//@ sourceURL=' + scriptName;
+                    } catch (e) {
+                        return false;
+                    }
+
+                    var fn;
+                    try {
+                        fn = Function(scriptSource);
+                    } catch (e) {
+                        return false;
+                    }
+
+                    // Don't wrap user code in try/catch
+                    fn();
+
+                    return true;
+                }
+            });
+
+            window['require'] = un['require'];
+            window['define'] = un['define'];
+        } else if (ENABLE_NODEJS && typeof module !== 'undefined') {
+            un = module.exports = create({
+                'context': { },
+                'loadScriptSync': function (scriptName) {
+                    // require here is the Node.JS-provided require
+
+                    var code;
+                    try {
+                        code = require('fs')['readFileSync'](scriptName, 'utf8');
+                    } catch (e) {
+                        // TODO Detect file-not-found errors only
+                        return false;
+                    }
+
+                    require('vm')['runInNewContext'](code, un['context'] || { }, scriptName);
+
+                    return true;
+                }
+            });
+
+            un['context']['define'] = un['define'];
+            un['context']['require'] = un['require'];
+        } else {
+            throw new Error('Unsupported environment');
+        }
+    }());
+
+//@{{{
+}());
+//@}}}