/** @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');
}
}());
//@{{{
}());
//@}}}
Codebase Browser
chromium