/**
* @license r.js 1.0.8 Copyright (c) 2010-2012, The Dojo Foundation All Rights Reserved.
* Available via the MIT or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*
* This file has been modified by ForgeRock to fix the now missing, previously deprecated,
* path.existsSync in nodejs.
*
* Portions Copyright 2015 ForgeRock AS.
*/
/*
* This is a bootstrap script to allow running RequireJS in the command line
* dist.js file to inject other files to completely enable this file. It is
* the shell of the r.js file.
*/
/*jslint strict: false, evil: true, nomen: false */
/*global readFile: true, process: false, Packages: false, print: false,
console: false, java: false, module: false */
version = '1.0.8',
jsSuffixRegExp = /\.js$/,
commandOption = '',
useLibLoaded = {},
function showHelp() {
}
if (typeof Packages !== 'undefined') {
env = 'rhino';
}
//Set up execution context.
};
};
//Define a console.log for easier logging. Don't
//get fancy though.
if (typeof console === 'undefined') {
console = {
log: function () {
}
};
}
} else if (typeof process !== 'undefined') {
env = 'node';
//Get the fs module via Node's require before it
nodeDefine = define;
//Temporarily hide require and define to allow require.js to define
//them.
};
};
};
}
}
/** vim: et:ts=4:sw=4:sts=4
* @license RequireJS 1.0.8 Copyright (c) 2010-2012, The Dojo Foundation All Rights Reserved.
* Available via the MIT or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*jslint strict: false, plusplus: false, sub: true */
/*global window, navigator, document, importScripts, jQuery, setTimeout, opera */
(function () {
//Change this version number for each release.
var version = "1.0.8",
commentRegExp = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/mg,
currDirRegExp = /^\.\//,
jsSuffixRegExp = /\.js$/,
ostring = Object.prototype.toString,
ap = Array.prototype,
aps = ap.slice,
apsp = ap.splice,
//PS3 indicates loaded and complete, but need to wait for complete
//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.
empty = {},
contexts = {},
globalDefQueue = [],
interactiveScript = null,
checkLoadedDepth = 0,
useInteractive = false,
reservedDependencies = {
require: true,
module: true,
exports: true
},
req, cfg = {}, currentlyAddingScript, s, head, baseElement, scripts, script,
src, subPath, mainScript, dataMain, globalI, ctx, jQueryCheck, checkLoadedTimeoutId;
function isFunction(it) {
}
function isArray(it) {
}
/**
* Simple function to mix in properties from source into target,
* but only if target does not already have a property of the same name.
* This is not robust in IE for transferring methods that match
* Object.prototype names, but the uses of mixin here seem unlikely to
* trigger a problem related to that.
*/
function mixin(target, source, force) {
for (var prop in source) {
if (!(prop in empty) && (!(prop in target) || force)) {
target[prop] = source[prop];
}
}
return req;
}
/**
* 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) {
var e = new Error(msg + '\nhttp://requirejs.org/docs/errors.html#' + id);
if (err) {
e.originalError = err;
}
return e;
}
/**
* Used to set up package paths from a packagePaths or packages config object.
* @param {Object} pkgs the object to store the new package config
* @param {Array} currentPackages an array of packages to configure
* @param {String} [dir] a prefix dir to use.
*/
function configurePackageDir(pkgs, currentPackages, dir) {
var i, location, pkgObj;
for (i = 0; (pkgObj = currentPackages[i]); i++) {
location = pkgObj.location;
//Add dir to the path, but avoid paths that start with a slash
//or have a colon (indicates a protocol)
if (dir && (!location || (location.indexOf("/") !== 0 && location.indexOf(":") === -1))) {
location = dir + "/" + (location || pkgObj.name);
}
//Create a brand new object on pkgs, since currentPackages can
//be passed in again, and config.pkgs is the internal transformed
//state for all package configs.
pkgs[pkgObj.name] = {
name: pkgObj.name,
location: location || pkgObj.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.
.replace(currDirRegExp, '')
.replace(jsSuffixRegExp, '')
};
}
}
/**
* ready callbacks, but jQuery 1.6 supports a holdReady() API instead.
* with using holdReady.
*/
function jQueryHoldReady($, shouldHold) {
if ($.holdReady) {
$.holdReady(shouldHold);
} else if (shouldHold) {
$.readyWait += 1;
} else {
$.ready(true);
}
}
//If a define is already in play via another AMD loader,
//do not overwrite.
return;
}
if (isFunction(requirejs)) {
//Do not overwrite and existing requirejs instance.
return;
} else {
cfg = requirejs;
requirejs = undefined;
}
}
//Allow for a require config object
//assume it is a config object.
cfg = require;
require = undefined;
}
/**
* Creates a new context for use in require and define calls.
* Handle most of the heavy lifting. Do not want to use an object
* with prototype here to avoid using "this" in require, in case it
* needs to be used in more super secure envs that do not want this.
* Also there should not be that many contexts in the page. Usually just
* one for the default context, but could be extra for multiversion cases
* or if a package needs a special context for a dependency that conflicts
* with the standard context.
*/
function newContext(contextName) {
var context, resume,
config = {
waitSeconds: 7,
baseUrl: "./",
paths: {},
pkgs: {},
catchError: {}
},
defQueue = [],
specified = {
},
urlMap = {},
defined = {},
loaded = {},
waiting = {},
waitAry = [],
urlFetched = {},
managerCounter = 0,
managerCallbacks = {},
plugins = {},
//Used to indicate which modules in a build scenario
//need to be full executed.
needFullExec = {},
fullExec = {},
resumeDepth = 0;
/**
* 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; (part = ary[i]); i++) {
if (part === ".") {
ary.splice(i, 1);
i -= 1;
} else if (part === "..") {
if (i === 1 && (ary[2] === '..' || ary[0] === '..')) {
//End of the line. Keep at least one non-dot
//path segment at the front so it can be mapped
//correctly to disk. Otherwise, there is likely
//no path mapping for a path starting with '..'.
//This can still fail, but catches the most reasonable
//uses of ..
break;
} 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.
* @returns {String} normalized name
*/
function normalize(name, baseName) {
var pkgName, pkgConfig;
//Adjust any relative paths.
if (name && name.charAt(0) === ".") {
//If have a base name, try to normalize against it,
//otherwise, assume it is a top-level require that will
//be relative to baseUrl in the end.
if (baseName) {
if (config.pkgs[baseName]) {
//If the baseName is a package name, then just treat it as one
//name to concat the name with.
baseName = [baseName];
} else {
//Convert baseName to array, and lop off the last part,
//this normalization.
baseName = baseName.split("/");
baseName = baseName.slice(0, baseName.length - 1);
}
name = baseName.concat(name.split("/"));
trimDots(name);
//Some use of packages may use a . path to reference the
pkgConfig = config.pkgs[(pkgName = name[0])];
name = name.join("/");
if (pkgConfig && name === pkgName + '/' + pkgConfig.main) {
name = pkgName;
}
} else if (name.indexOf("./") === 0) {
// No baseName, so this is ID is resolved relative
// to baseUrl, pull off the leading dot.
name = name.substring(2);
}
}
return 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.
*
* @returns {Object}
*/
function makeModuleMap(name, parentModuleMap) {
var index = name ? name.indexOf("!") : -1,
prefix = null,
parentName = parentModuleMap ? parentModuleMap.name : null,
originalName = name,
normalizedName, url, pluginModule;
if (index !== -1) {
prefix = name.substring(0, index);
name = name.substring(index + 1, name.length);
}
if (prefix) {
prefix = normalize(prefix, parentName);
}
//Account for relative paths if there is a base name.
if (name) {
if (prefix) {
pluginModule = defined[prefix];
if (pluginModule && pluginModule.normalize) {
//Plugin is loaded, use its normalize method.
normalizedName = pluginModule.normalize(name, function (name) {
return normalize(name, parentName);
});
} else {
normalizedName = normalize(name, parentName);
}
} else {
//A regular module.
normalizedName = normalize(name, parentName);
url = urlMap[normalizedName];
if (!url) {
//Calculate url for the module, if it has a name.
//Use name here since nameToUrl also calls normalize,
//and for relative names that are outside the baseUrl
//this causes havoc. Was thinking of just removing
//parentModuleMap to avoid extra normalization, but
//normalize() still does a dot removal because of
//issue #142, so just pass in name here and redo
//the normalization. Paths outside baseUrl are just
//messy to support.
url = context.nameToUrl(name, null, parentModuleMap);
//Store the URL mapping for later.
urlMap[normalizedName] = url;
}
}
}
return {
prefix: prefix,
name: normalizedName,
parentMap: parentModuleMap,
url: url,
originalName: originalName,
fullName: prefix ? prefix + "!" + (normalizedName || '') : normalizedName
};
}
/**
* Determine if priority loading is done. If so clear the priorityWait
*/
function isPriorityDone() {
var priorityDone = true,
priorityWait = config.priorityWait,
priorityName, i;
if (priorityWait) {
for (i = 0; (priorityName = priorityWait[i]); i++) {
if (!loaded[priorityName]) {
priorityDone = false;
break;
}
}
if (priorityDone) {
delete config.priorityWait;
}
}
return priorityDone;
}
function makeContextModuleFunc(func, relModuleMap, enableBuildCallback) {
return function () {
//A version of a require function that passes a moduleName
//value for items that may need to
//look up paths relative to the moduleName
var args = aps.call(arguments, 0), lastArg;
if (enableBuildCallback &&
isFunction((lastArg = args[args.length - 1]))) {
lastArg.__requireJsBuild = true;
}
args.push(relModuleMap);
return func.apply(null, args);
};
}
/**
* Helper function that creates a require function object to give to
* modules that ask for it as a dependency. It needs to be specific
* per module because of the implication of path mappings that may
* need to be relative to the module name.
*/
function makeRequire(relModuleMap, enableBuildCallback, altRequire) {
var modRequire = makeContextModuleFunc(altRequire || context.require, relModuleMap, enableBuildCallback);
mixin(modRequire, {
nameToUrl: makeContextModuleFunc(context.nameToUrl, relModuleMap),
toUrl: makeContextModuleFunc(context.toUrl, relModuleMap),
defined: makeContextModuleFunc(context.requireDefined, relModuleMap),
specified: makeContextModuleFunc(context.requireSpecified, relModuleMap),
isBrowser: req.isBrowser
});
return modRequire;
}
/*
* Queues a dependency for checking after the loader is out of a
* in the browser, where it may have many modules defined in it.
*/
function queueDependency(manager) {
context.paused.push(manager);
}
function execManager(manager) {
var i, ret, err, errFile, errModuleTree,
cb = manager.callback,
map = manager.map,
fullName = map.fullName,
args = manager.deps,
listeners = manager.listeners,
cjsModule;
//Call the callback to define the module, if necessary.
if (cb && isFunction(cb)) {
if (config.catchError.define) {
try {
ret = req.execCb(fullName, manager.callback, args, defined[fullName]);
} catch (e) {
err = e;
}
} else {
ret = req.execCb(fullName, manager.callback, args, defined[fullName]);
}
if (fullName) {
//favor that over return value and exports. After that,
//favor a non-undefined return value over exports use.
cjsModule = manager.cjsModule;
if (cjsModule &&
cjsModule.exports !== undefined &&
//Make sure it is not already the exports value
cjsModule.exports !== defined[fullName]) {
ret = defined[fullName] = manager.cjsModule.exports;
} else if (ret === undefined && manager.usingExports) {
//exports already set the defined value.
ret = defined[fullName];
} else {
//Use the return value from the function.
defined[fullName] = ret;
//If this module needed full execution in a build
//environment, mark that now.
if (needFullExec[fullName]) {
fullExec[fullName] = true;
}
}
}
} else if (fullName) {
//May just be an object definition for the module. Only
//worry about defining if have a module name.
ret = defined[fullName] = cb;
//If this module needed full execution in a build
//environment, mark that now.
if (needFullExec[fullName]) {
fullExec[fullName] = true;
}
}
//Clean up waiting. Do this before error calls, and before
//calling back listeners, so that bookkeeping is correct
//in the event of an error and error is reported in correct order,
//since the listeners will likely have errors if the
//onError function does not throw.
if (waiting[manager.id]) {
delete waiting[manager.id];
manager.isDone = true;
context.waitCount -= 1;
if (context.waitCount === 0) {
//Clear the wait array used for cycles.
waitAry = [];
}
}
//Do not need to track manager callback now that it is defined.
delete managerCallbacks[fullName];
//Allow instrumentation like the optimizer to know the order
//of modules executed and their dependencies.
if (req.onResourceLoad && !manager.placeholder) {
req.onResourceLoad(context, map, manager.depArray);
}
if (err) {
errFile = (fullName ? makeModuleMap(fullName).url : '') ||
err.fileName || err.sourceURL;
errModuleTree = err.moduleTree;
err = makeError('defineerror', 'Error evaluating ' +
'module "' + fullName + '" at location "' +
errFile + '":\n' +
err + '\nfileName:' + errFile +
'\nlineNumber: ' + (err.lineNumber || err.line), err);
err.moduleName = fullName;
err.moduleTree = errModuleTree;
return req.onError(err);
}
//Let listeners know of this manager's value.
for (i = 0; (cb = listeners[i]); i++) {
cb(ret);
}
return undefined;
}
/**
* Helper that creates a callack function that is called when a dependency
* is ready, and sets the i-th dependency for the manager as the
* value passed to the callback generated by this function.
*/
function makeArgCallback(manager, i) {
return function (value) {
//Only do the work if it has not been done
//already for a dependency. Cycle breaking
//logic in forceExec could mean this function
//is called more than once for a given dependency.
if (!manager.depDone[i]) {
manager.depDone[i] = true;
manager.deps[i] = value;
manager.depCount -= 1;
if (!manager.depCount) {
//All done, execute!
execManager(manager);
}
}
};
}
function callPlugin(pluginName, depManager) {
var map = depManager.map,
fullName = map.fullName,
name = map.name,
plugin = plugins[pluginName] ||
(plugins[pluginName] = defined[pluginName]),
load;
//No need to continue if the manager is already
//in the process of loading.
if (depManager.loading) {
return;
}
depManager.loading = true;
load = function (ret) {
depManager.callback = function () {
return ret;
};
execManager(depManager);
loaded[depManager.id] = true;
//The loading of this plugin
//might have placed other things
//in the paused queue. In particular,
//a loader plugin that depends on
//a different plugin loaded resource.
resume();
};
//Allow plugins to load other code without having to know the
load.fromText = function (moduleName, text) {
/*jslint evil: true */
var hasInteractive = useInteractive;
//Indicate a the module is in process of loading.
loaded[moduleName] = false;
context.scriptCount += 1;
//for builds, it does not map to a real file.
context.fake[moduleName] = true;
//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;
}
req.exec(text);
if (hasInteractive) {
useInteractive = true;
}
//Support anonymous modules.
context.completeLoad(moduleName);
};
//No need to continue if the plugin value has already been
//defined by a build.
if (fullName in defined) {
load(defined[fullName]);
} else {
//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(name, makeRequire(map.parentMap, true, function (deps, cb) {
var moduleDeps = [],
i, dep, depMap;
//Convert deps to full names and hold on to them
//for reference later, when figuring out if they
//are blocked by a circular dependency.
for (i = 0; (dep = deps[i]); i++) {
depMap = makeModuleMap(dep, map.parentMap);
deps[i] = depMap.fullName;
if (!depMap.prefix) {
moduleDeps.push(deps[i]);
}
}
depManager.moduleDeps = (depManager.moduleDeps || []).concat(moduleDeps);
return context.require(deps, cb);
}), load, config);
}
}
/**
* Adds the manager to the waiting queue. Only fully
* resolved items should be in the waiting queue.
*/
function addWait(manager) {
if (!waiting[manager.id]) {
waiting[manager.id] = manager;
waitAry.push(manager);
context.waitCount += 1;
}
}
/**
* Function added to every manager object. Created out here
* to avoid new function creation for each manager instance.
*/
function managerAdd(cb) {
this.listeners.push(cb);
}
function getManager(map, shouldQueue) {
var fullName = map.fullName,
prefix = map.prefix,
plugin = prefix ? plugins[prefix] ||
(plugins[prefix] = defined[prefix]) : null,
manager, created, pluginManager, prefixMap;
if (fullName) {
manager = managerCallbacks[fullName];
}
if (!manager) {
created = true;
manager = {
//ID is just the full name, but if it is a plugin resource
//for a plugin that has not been loaded,
//then add an ID counter to it.
id: (prefix && !plugin ?
(managerCounter++) + '__p@:' : '') +
(fullName || '__r@' + (managerCounter++)),
map: map,
depCount: 0,
depDone: [],
depCallbacks: [],
deps: [],
listeners: [],
add: managerAdd
};
specified[manager.id] = true;
//resource. Also only track plugin resources once
//the plugin has been loaded, and so the fullName is the
//true normalized value.
if (fullName && (!prefix || plugins[prefix])) {
managerCallbacks[fullName] = manager;
}
}
//If there is a plugin needed, but it is not loaded,
//first load the plugin, then continue on.
if (prefix && !plugin) {
prefixMap = makeModuleMap(prefix);
//Clear out defined and urlFetched if the plugin was previously
//situation). However, only do this work if the plugin is in
//defined but does not have a module export value.
if (prefix in defined && !defined[prefix]) {
delete defined[prefix];
delete urlFetched[prefixMap.url];
}
pluginManager = getManager(prefixMap, true);
pluginManager.add(function (plugin) {
//Create a new manager for the normalized
//resource ID and have it call this manager when
//done.
var newMap = makeModuleMap(map.originalName, map.parentMap),
normalizedManager = getManager(newMap, true);
//Indicate this manager is a placeholder for the real,
//normalized thing. Important for when trying to map
//modules and dependencies, for instance, in a build.
manager.placeholder = true;
normalizedManager.add(function (resource) {
manager.callback = function () {
return resource;
};
execManager(manager);
});
});
} else if (created && shouldQueue) {
//Indicate the resource is not loaded yet if it is to be
//queued.
loaded[manager.id] = false;
queueDependency(manager);
addWait(manager);
}
return manager;
}
function main(inName, depArray, callback, relModuleMap) {
var moduleMap = makeModuleMap(inName, relModuleMap),
name = moduleMap.name,
fullName = moduleMap.fullName,
manager = getManager(moduleMap),
id = manager.id,
deps = manager.deps,
i, depArg, depName, depPrefix, cjsMod;
if (fullName) {
//If module already defined for context, or already loaded,
//then leave. Also leave if jQuery is registering but it does
//not match the desired version number in the config.
if (fullName in defined || loaded[id] === true ||
config.jQuery !== callback().fn.jquery)) {
return;
}
//as part of a layer, where onScriptLoad is not fired
//for those cases. Do this after the inline define and
//dependency tracing is done.
specified[id] = true;
loaded[id] = true;
//If module is jQuery set up delaying its dom ready listeners.
jQueryCheck(callback());
}
}
//Attach real depArray and callback to the manager. Do this
//only if the module has not been defined already, so do this after
//the fullName checks above. IE can call main() more than once
//for a module.
manager.depArray = depArray;
manager.callback = callback;
//Add the dependencies to the deps field, and register for callbacks
//on the dependencies.
for (i = 0; i < depArray.length; i++) {
depArg = depArray[i];
//There could be cases like in IE, where a trailing comma will
//introduce a null dependency, so only treat a real dependency
//value as a dependency.
if (depArg) {
//Split the dependency name into plugin and name parts
depArg = makeModuleMap(depArg, (name ? moduleMap : relModuleMap));
depName = depArg.fullName;
depPrefix = depArg.prefix;
//Fix the name in depArray to be just the name, since
//that is how it will be called back later.
depArray[i] = depName;
//Fast path CommonJS standard dependencies.
deps[i] = makeRequire(moduleMap);
//CommonJS module spec 1.1
deps[i] = defined[fullName] = {};
manager.usingExports = true;
//CommonJS module spec 1.1
manager.cjsModule = cjsMod = deps[i] = {
id: name,
uri: name ? context.nameToUrl(name, null, relModuleMap) : undefined,
exports: defined[fullName]
};
} else if (depName in defined && !(depName in waiting) &&
(!(fullName in needFullExec) ||
(fullName in needFullExec && fullExec[depName]))) {
//Module already defined, and not in a build situation
//where the module is a something that needs full
//execution and this dependency has not been fully
//executed. See r.js's requirePatch.js for more info
//on fullExec.
deps[i] = defined[depName];
} else {
//Mark this dependency as needing full exec if
//the current module needs full exec.
if (fullName in needFullExec) {
needFullExec[depName] = true;
//Reset state so fully executed code will get
//picked up correctly.
delete defined[depName];
urlFetched[depArg.url] = false;
}
//Either a resource that is not loaded yet, or a plugin
//resource for either a plugin that has not
//loaded yet.
manager.depCount += 1;
manager.depCallbacks[i] = makeArgCallback(manager, i);
getManager(depArg, true).add(manager.depCallbacks[i]);
}
}
}
//Do not bother tracking the manager if it is all done.
if (!manager.depCount) {
//All done, execute!
execManager(manager);
} else {
addWait(manager);
}
}
/**
* Convenience method to call main for a define call that was put on
* hold in the defQueue.
*/
function callDefMain(args) {
main.apply(null, args);
}
/**
* jQuery 1.4.3+ supports ways to hold off calling
* calling jQuery ready callbacks until all scripts are loaded. Be sure
* to track it if the capability exists.. Also, since jQuery 1.4.3 does
* not register as a module, need to do some global inference checking.
* Even if it does register as a module, not guaranteed to be the precise
* name of the global. If a jQuery is tracked for this context, then go
* ahead and register it as a module too, if not already in process.
*/
jQueryCheck = function (jqCandidate) {
if (!context.jQuery) {
if ($) {
//If a specific version of jQuery is wanted, make sure to only
//use this jQuery if it matches.
if (config.jQuery && $.fn.jquery !== config.jQuery) {
return;
}
context.jQuery = $;
//or in process. Note this could trigger an attempt at
//a second jQuery registration, but does no harm since
//the first one wins, and it is the same value anyway.
return jQuery;
}]);
//Ask jQuery to hold DOM ready callbacks.
if (context.scriptCount) {
jQueryHoldReady($, true);
context.jQueryIncremented = true;
}
}
}
}
};
function findCycle(manager, traced) {
var fullName = manager.map.fullName,
depArray = manager.depArray,
fullyLoaded = true,
i, depName, depManager, result;
if (manager.isDone || !fullName || !loaded[fullName]) {
return result;
}
//Found the cycle.
if (traced[fullName]) {
return manager;
}
traced[fullName] = true;
//Trace through the dependencies.
if (depArray) {
for (i = 0; i < depArray.length; i++) {
//Some array members may be null, like if a trailing comma
//IE, so do the explicit [i] access and check if it has a value.
depName = depArray[i];
if (!loaded[depName] && !reservedDependencies[depName]) {
fullyLoaded = false;
break;
}
depManager = waiting[depName];
if (depManager && !depManager.isDone && loaded[depName]) {
result = findCycle(depManager, traced);
if (result) {
break;
}
}
}
if (!fullyLoaded) {
//Discard the cycle that was found, since it cannot
//be forced yet. Also clear this module from traced.
result = undefined;
delete traced[fullName];
}
}
return result;
}
function forceExec(manager, traced) {
var fullName = manager.map.fullName,
depArray = manager.depArray,
i, depName, depManager, prefix, prefixManager, value;
if (manager.isDone || !fullName || !loaded[fullName]) {
return undefined;
}
if (fullName) {
if (traced[fullName]) {
return defined[fullName];
}
traced[fullName] = true;
}
//Trace through the dependencies.
if (depArray) {
for (i = 0; i < depArray.length; i++) {
//Some array members may be null, like if a trailing comma
//IE, so do the explicit [i] access and check if it has a value.
depName = depArray[i];
if (depName) {
//First, make sure if it is a plugin resource that the
//plugin is not blocked.
prefix = makeModuleMap(depName).prefix;
if (prefix && (prefixManager = waiting[prefix])) {
forceExec(prefixManager, traced);
}
depManager = waiting[depName];
if (depManager && !depManager.isDone && loaded[depName]) {
value = forceExec(depManager, traced);
manager.depCallbacks[i](value);
}
}
}
}
return defined[fullName];
}
/**
* Checks if all modules for a context are loaded, and if so, evaluates the
* new ones in right dependency order.
*
* @private
*/
function checkLoaded() {
var 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 = "", hasLoadedProp = false, stillLoading = false,
cycleDeps = [],
i, prop, err, manager, cycleManager, moduleDeps;
//If there are items still in the paused queue processing wait.
//This is particularly important in the sync case where each paused
//item is processed right away but there may be more waiting.
if (context.pausedCount > 0) {
return undefined;
}
//Determine if priority loading is done. If so clear the priority. If
//not, then do not check
if (config.priorityWait) {
if (isPriorityDone()) {
//Call resume, since it could have
//some waiting dependencies to trace.
resume();
} else {
return undefined;
}
}
//See if anything is still in flight.
for (prop in loaded) {
if (!(prop in empty)) {
hasLoadedProp = true;
if (!loaded[prop]) {
if (expired) {
noLoads += prop + " ";
} else {
stillLoading = true;
if (prop.indexOf('!') === -1) {
//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.
cycleDeps = [];
break;
} else {
moduleDeps = managerCallbacks[prop] && managerCallbacks[prop].moduleDeps;
if (moduleDeps) {
cycleDeps.push.apply(cycleDeps, moduleDeps);
}
}
}
}
}
}
//Check for exit conditions.
if (!hasLoadedProp && !context.waitCount) {
//If the loaded object had no items, then the rest of
//the work below does not need to be done.
return undefined;
}
if (expired && noLoads) {
//If wait time expired, throw error of unloaded modules.
err.requireModules = noLoads;
err.contextName = context.contextName;
return req.onError(err);
}
//If still loading but a plugin is waiting on a regular module cycle
//break the cycle.
if (stillLoading && cycleDeps.length) {
for (i = 0; (manager = waiting[cycleDeps[i]]); i++) {
if ((cycleManager = findCycle(manager, {}))) {
forceExec(cycleManager, {});
break;
}
}
}
//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 && (stillLoading || context.scriptCount)) {
//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);
}
return undefined;
}
//If still have items in the waiting cue, but all modules have
//been loaded, then it means there are some circular dependencies
//that need to be broken.
//However, as a waiting thing is fired, then it can add items to
//the waiting cue, and those items should not be fired yet, so
//make sure to redo the checkLoaded call after breaking a single
//cycle, if nothing else loaded then this logic will pick it up
//again.
if (context.waitCount) {
//Cycle through the waitAry, and call items in sequence.
for (i = 0; (manager = waitAry[i]); i++) {
forceExec(manager, {});
}
//If anything got placed in the paused queue, run it down.
if (context.paused.length) {
resume();
}
//Only allow this recursion to a certain depth. Only
//triggered by errors in calling a module in which its
//modules waiting on it cannot finish loading, or some circular
//dependencies that then may add more dependencies.
//The value of 5 is a bit arbitrary. Hopefully just one extra
//pass, or two for the case of circular dependencies generating
//more work that gets resolved in the sync node case.
if (checkLoadedDepth < 5) {
checkLoadedDepth += 1;
checkLoaded();
}
}
checkLoadedDepth = 0;
//Check for DOM ready, and nothing is waiting across contexts.
req.checkReadyState();
return undefined;
}
/**
* Resumes tracing of dependencies and then checks if everything is loaded.
*/
resume = function () {
var manager, map, url, i, p, args, fullName;
//Any defined modules in the global queue, intake them now.
context.takeGlobalQueue();
resumeDepth += 1;
if (context.scriptCount <= 0) {
//Synchronous envs will push the number below zero with the
//decrement above, be sure to set it back to zero for good measure.
//require() calls that also do not end up loading scripts could
//push the number negative too.
context.scriptCount = 0;
}
//Make sure any remaining defQueue items get properly processed.
while (defQueue.length) {
args = defQueue.shift();
if (args[0] === null) {
return req.onError(makeError('mismatch', 'Mismatched anonymous define() module: ' + args[args.length - 1]));
} else {
callDefMain(args);
}
}
//Skip the resume of paused dependencies
//if current context is in priority wait.
if (!config.priorityWait || isPriorityDone()) {
while (context.paused.length) {
p = context.paused;
context.pausedCount += p.length;
//Reset paused list
context.paused = [];
for (i = 0; (manager = p[i]); i++) {
map = manager.map;
url = map.url;
fullName = map.fullName;
//If the manager is for a plugin managed resource,
//ask the plugin to load it now.
if (map.prefix) {
callPlugin(map.prefix, manager);
} else {
//Regular dependency.
if (!urlFetched[url] && !loaded[fullName]) {
req.load(context, fullName, url);
//Mark the URL as fetched, but only if it is
//not an empty: URL, used by the optimizer.
//In that case we need to be sure to call
//load() for each module that is mapped to
//empty: so that dependencies are satisfied
//correctly.
if (url.indexOf('empty:') !== 0) {
urlFetched[url] = true;
}
}
}
}
//Move the start time for timeout forward.
context.startTime = (new Date()).getTime();
context.pausedCount -= p.length;
}
}
//Only check if loaded when resume depth is 1. It is likely that
//it is only greater than 1 in sync environments where a factory
//function also then calls the callback-style require. In those
//cases, the checkLoaded should not occur until the resume
//depth is back at the top level.
if (resumeDepth === 1) {
checkLoaded();
}
resumeDepth -= 1;
return undefined;
};
//Define the context object. Many of these fields are on here
//just to make debugging easier.
context = {
contextName: contextName,
config: config,
defQueue: defQueue,
waiting: waiting,
waitCount: 0,
specified: specified,
loaded: loaded,
urlMap: urlMap,
urlFetched: urlFetched,
scriptCount: 0,
defined: defined,
paused: [],
pausedCount: 0,
plugins: plugins,
needFullExec: needFullExec,
fake: {},
fullExec: fullExec,
managerCallbacks: managerCallbacks,
makeModuleMap: makeModuleMap,
normalize: normalize,
/**
* Set a configuration for the context.
* @param {Object} cfg config object to integrate.
*/
configure: function (cfg) {
var paths, prop, packages, pkgs, packagePaths, requireWait;
//Make sure the baseUrl ends in a slash.
if (cfg.baseUrl) {
if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== "/") {
cfg.baseUrl += "/";
}
}
//Save off the paths and packages since they require special processing,
//they are additive.
paths = config.paths;
packages = config.packages;
pkgs = config.pkgs;
//Mix in the config values, favoring the new values over
//existing ones in context.config.
mixin(config, cfg, true);
//Adjust paths if necessary.
if (cfg.paths) {
for (prop in cfg.paths) {
if (!(prop in empty)) {
paths[prop] = cfg.paths[prop];
}
}
config.paths = paths;
}
packagePaths = cfg.packagePaths;
if (packagePaths || cfg.packages) {
//Convert packagePaths into a packages config.
if (packagePaths) {
for (prop in packagePaths) {
if (!(prop in empty)) {
configurePackageDir(pkgs, packagePaths[prop], prop);
}
}
}
//Adjust packages if necessary.
if (cfg.packages) {
configurePackageDir(pkgs, cfg.packages);
}
//Done with modifications, assing packages back to context config
config.pkgs = pkgs;
}
//If priority loading is in effect, trigger the loads now
if (cfg.priority) {
//Hold on to requireWait value, and reset it after done
requireWait = context.requireWait;
//Allow tracing some require calls to allow the fetching
//of the priority config.
context.requireWait = false;
//But first, call resume to register any defined modules that may
//be in a data-main built file before the priority config
//call.
resume();
context.require(cfg.priority);
//Trigger a resume right away, for the case when
//the script with the priority load is done as part
//of a data-main call. In that case the normal resume
//call will not happen because the scriptCount will be
//at 1, since the script for data-main is being processed.
resume();
//Restore previous state.
context.requireWait = requireWait;
config.priorityWait = cfg.priority;
}
//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);
}
},
requireDefined: function (moduleName, relModuleMap) {
return makeModuleMap(moduleName, relModuleMap).fullName in defined;
},
requireSpecified: function (moduleName, relModuleMap) {
return makeModuleMap(moduleName, relModuleMap).fullName in specified;
},
require: function (deps, callback, relModuleMap) {
var moduleName, fullName, moduleMap;
if (isFunction(callback)) {
//Invalid call
}
//Synchronous access to one module. If require.get is
//available (as in the Node adapter), prefer that.
//In this case deps is the moduleName and callback is
//the relModuleMap
if (req.get) {
return req.get(context, deps, callback);
}
//Just return the module wanted. In this scenario, the
//second arg (if passed) is just the relModuleMap.
moduleName = deps;
relModuleMap = callback;
//Normalize module name, if it contains . or ..
moduleMap = makeModuleMap(moduleName, relModuleMap);
fullName = moduleMap.fullName;
if (!(fullName in defined)) {
moduleMap.fullName +
contextName));
}
return defined[fullName];
}
//Call main but only if there are dependencies or
//a callback to call.
if (deps && deps.length || callback) {
main(null, deps, callback, relModuleMap);
}
//If the require call does not trigger anything new to load,
//then resume the dependency processing.
if (!context.requireWait) {
while (!context.scriptCount && context.paused.length) {
resume();
}
}
return context.require;
},
/**
* Internal method to transfer globalQueue items to this context's
* defQueue.
*/
takeGlobalQueue: function () {
//Push all the globalDefQueue items into the context's defQueue
if (globalDefQueue.length) {
//Array splice in the values since the context code has a
//local var ref to defQueue, so cannot just reassign the one
//on context.
apsp.apply(context.defQueue,
[context.defQueue.length - 1, 0].concat(globalDefQueue));
globalDefQueue = [];
}
},
/**
* 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 args;
context.takeGlobalQueue();
while (defQueue.length) {
args = defQueue.shift();
if (args[0] === null) {
args[0] = moduleName;
break;
} else if (args[0] === moduleName) {
//Found matching define call for this script!
break;
} else {
//Some other named define call, most likely the result
//of a build layer that included many define calls.
callDefMain(args);
args = null;
}
}
if (args) {
callDefMain(args);
} else {
//A script that does not call define(), so just simulate
//the call for it. Special exception for jQuery dynamic load.
callDefMain([moduleName, [],
function () {
return jQuery;
} : null]);
}
//Doing this scriptCount decrement branching because sync envs
//need to decrement after resume, otherwise it looks like
//loading is complete after the first dependency is fetched.
//For browsers, it works fine to decrement after, but it means
//the checkLoaded setTimeout 50 ms cost is taken. To avoid
//that cost, decrement beforehand.
if (req.isAsync) {
context.scriptCount -= 1;
}
resume();
if (!req.isAsync) {
context.scriptCount -= 1;
}
},
/**
* 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, relModuleMap) {
var index = moduleNamePlusExt.lastIndexOf("."),
ext = null;
if (index !== -1) {
ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
}
return context.nameToUrl(moduleNamePlusExt, ext, relModuleMap);
},
/**
* Converts a module name to a file path. Supports cases where
* moduleName may actually be just an URL.
*/
nameToUrl: function (moduleName, ext, relModuleMap) {
var paths, pkgs, pkg, pkgPath, syms, i, parentModule, url,
config = context.config;
//Normalize module name if have a base relative module name to work from.
moduleName = normalize(moduleName, relModuleMap && relModuleMap.fullName);
//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 or ends with .js, it is just a plain file.
//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 ? ext : "");
} else {
//A module that needs to be converted to a path.
paths = config.paths;
pkgs = config.pkgs;
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--) {
parentModule = syms.slice(0, i).join("/");
if (paths[parentModule]) {
syms.splice(0, i, paths[parentModule]);
break;
} else if ((pkg = pkgs[parentModule])) {
//If module name is just the package name, then looking
//for the main module.
if (moduleName === pkg.name) {
pkgPath = pkg.location + '/' + pkg.main;
} else {
pkgPath = pkg.location;
}
syms.splice(0, i, pkgPath);
break;
}
}
//Join the path parts together, then figure out if baseUrl is needed.
url = (url.charAt(0) === '/' || url.match(/^\w+:/) ? "" : config.baseUrl) + url;
}
return config.urlArgs ? url +
((url.indexOf('?') === -1 ? '?' : '&') +
config.urlArgs) : url;
}
};
//Make these visible on the context so can be called at the very
//end of the file to bootstrap
context.jQueryCheck = jQueryCheck;
context.resume = resume;
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) {
//Find the right context, use default
var contextName = defContextName,
context, config;
// Determine if have config object in the call.
// deps is a config object
config = deps;
if (isArray(callback)) {
// Adjust args if there are dependencies
deps = callback;
callback = arguments[2];
} else {
deps = [];
}
}
if (config && config.context) {
contextName = config.context;
}
context = contexts[contextName] ||
(contexts[contextName] = newContext(contextName));
if (config) {
context.configure(config);
}
return context.require(deps, callback);
};
/**
* Support require.config() to make it easier to cooperate with other
* AMD loaders on globally agreed names.
*/
req.config = function (config) {
return req(config);
};
/**
* Export require as a global, but only if it does not already exist.
*/
if (!require) {
require = req;
}
/**
* Global require.toUrl(), to match global require, mostly useful
*/
req.toUrl = function (moduleNamePlusExt) {
return contexts[defContextName].toUrl(moduleNamePlusExt);
};
req.version = version;
//Used to filter out dependencies that are already paths.
req.jsExtRegExp = /^\/|:|\?|\.js$/;
s = req.s = {
contexts: contexts,
//Stores a list of URLs that should not get async script tag treatment.
skipAsync: {}
};
req.isAsync = req.isBrowser = isBrowser;
if (isBrowser) {
//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:
if (baseElement) {
head = s.head = baseElement.parentNode;
}
}
/**
* Any errors that require explicitly generates will be passed to this
* @param {Error} err the error object.
*/
req.onError = function (err) {
throw err;
};
/**
* 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) {
req.resourcesReady(false);
context.scriptCount += 1;
req.attach(url, context, moduleName);
//If tracking a jQuery, then make sure its ready callbacks
//are put on hold to prevent its ready callbacks from
//triggering too soon.
if (context.jQuery && !context.jQueryIncremented) {
jQueryHoldReady(context.jQuery, true);
context.jQueryIncremented = true;
}
};
function getInteractiveScript() {
var scripts, i, script;
if (interactiveScript && interactiveScript.readyState === 'interactive') {
return interactiveScript;
}
scripts = document.getElementsByTagName('script');
for (i = scripts.length - 1; i > -1 && (script = scripts[i]); i--) {
if (script.readyState === 'interactive') {
return (interactiveScript = script);
}
}
return null;
}
/**
* 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 functions
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 = [];
}
//If no name, and callback is a function, then figure out if it a
//CommonJS thing with dependencies.
if (!deps.length && isFunction(callback)) {
//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, "")
.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.
}
}
//If in IE 6-8 and hit an anonymous define() call, do the interactive
//work.
if (useInteractive) {
node = currentlyAddingScript || getInteractiveScript();
if (node) {
if (!name) {
}
}
}
//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.
(context ? context.defQueue : globalDefQueue).push([name, deps, callback]);
return undefined;
};
define.amd = {
multiversion: true,
plugins: true,
jQuery: true
};
/**
* Executes the text. Normally just uses eval, but can be modified
* to use a more environment specific call.
*/
req.exec = function (text) {
return eval(text);
};
/**
* Executes a module callack 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
*/
req.execCb = function (name, callback, args, exports) {
return callback.apply(exports, args);
};
/**
* Adds a node to the DOM. Public function since used by the order plugin.
* This method should not normally be called by outside code.
*/
req.addScriptToDom = function (node) {
//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;
};
/**
* callback for script loads, used to check status of loading.
*
* @param {Event} evt the event from the browser for the script
* that was loaded.
*
* @private
*/
req.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.
var node = evt.currentTarget || evt.srcElement, contextName, moduleName,
context;
//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.
context = contexts[contextName];
contexts[contextName].completeLoad(moduleName);
//Clean up script binding. 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.
} else {
}
}
};
/**
* Attaches the script represented by the URL to the current
* environment. Right now only supports browser loading,
* but can be redefined in other environments to do the right thing.
* @param {String} url the url of the script to attach.
* @param {Object} context the context that wants the script.
* @param {moduleName} the name of the module that is associated with the script.
* @param {Function} [callback] optional callback, defaults to require.onScriptLoad
* @param {String} [type] optional type, defaults to text/javascript
* @param {Function} [fetchOnlyFunction] optional function to indicate the script node
* should be set up to fetch the script but do not attach it to the DOM
* so that it can later be attached to execute it. This is a way for the
* order plugin to support ordered loading in IE. Once the script is fetched,
* but not executed, the fetchOnlyFunction will be called.
*/
req.attach = function (url, context, moduleName, callback, type, fetchOnlyFunction) {
var node;
if (isBrowser) {
//In the browser so use a script tag
callback = callback || req.onScriptLoad;
node = context && context.config && context.config.xhtml ?
"text/javascript";
//Use async so Gecko does not block on executing the script if something
//like a long-polling comet tag is being run first. Gecko likes
//to evaluate scripts in DOM order, even for dynamic scripts.
//It will fetch them async, but only evaluate the contents in DOM
//order, so a long-polling script tag can delay execution of scripts
//after it. But telling Gecko we expect async gets us the behavior
//we want -- execute it whenever it is finished downloading. Only
//Helps Firefox 3.6+
//Allow some URLs to not be fetched async. Mostly helps the order!
//plugin
if (context) {
}
//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:
//UNFORTUNATELY Opera implements attachEvent but does not follow the script
//script execution mode.
//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;
if (fetchOnlyFunction) {
//Need to use old school onreadystate here since
//when the event fires and the node is not attached
//to the DOM, the evt.srcElement is null, so use
//a closure to remember the node.
//Script loaded but not executed.
//Clear loaded handler, set the real one that
//waits for script execution.
node.onreadystatechange = null;
}
};
} else {
}
} else {
}
//Fetch only means waiting to attach to DOM after loaded.
if (!fetchOnlyFunction) {
}
return node;
} else if (isWebWorker) {
//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 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.
//Account for anonymous modules
}
return null;
};
//Look for a data-main script attribute, which could also adjust the baseUrl.
if (isBrowser) {
//Figure out baseUrl. Get it from the script tag with require.js in it.
//Set the "head" where we can append children by
//using the script's parent.
if (!head) {
}
//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.
//Pull off the directory of data-main for use as the
//baseUrl.
//Set final config.
//Strip off any trailing .js since dataMain is now
//like a module name.
}
//Put the data-main script in the files to load.
break;
}
}
}
//See if there is nothing waiting across contexts, and if not, trigger
//resourcesReady.
req.checkReadyState = function () {
return;
}
}
}
req.resourcesReady(true);
};
/**
* have been loaded by the loader. Can be overridden by other, for
* instance the domReady plugin, which wants to know when all resources
* are loaded.
*/
//First, set the public variable indicating that resources are loading.
if (req.resourcesDone) {
//If jQuery with DOM ready delayed, release it now.
if (context.jQueryIncremented) {
context.jQueryIncremented = false;
}
}
}
}
};
//FF < 3.6 readyState fix. Needed so that domReady plugin
//works well in that environment, since require.js is normally
//loaded via an HTML script tag so it will be there before window load,
//where the domReady plugin is more likely to be loaded after window load.
req.pageLoaded = function () {
}
};
if (isBrowser) {
if (document.addEventListener) {
if (!document.readyState) {
}
}
}
//Set up default context. If require was a configuration object, use that as base config.
//If modules are built into require.js, then need to make sure dependencies are
//traced. Use a setTimeout in the browser world, to allow all the modules to register
//themselves. In a non-browser env, assume that modules are not built into require.js,
//which seems odd to do on the server.
//Indicate that the script that includes require() is still loading,
//so that require()'d dependencies are not traced until the end of the
//file is parsed (approximated via the setTimeout call).
ctx.requireWait = true;
setTimeout(function () {
ctx.requireWait = false;
if (!ctx.scriptCount) {
}
}, 0);
}
}());
if (env === 'rhino') {
/**
* @license RequireJS rhino Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
* Available via the MIT or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*jslint strict: false */
/*global require: false, java: false, load: false */
(function () {
//Indicate a the module is in process of loading.
//Support anonymous modules.
};
}());
} else if (env === 'node') {
this.requirejsVars = {
};
/**
* @license RequireJS node Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
* Available via the MIT or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*jslint regexp: false, strict: false */
/*global require: false, define: false, requirejsVars: false, process: false */
/**
* This adapter assumes that x.js has loaded it and set up
* some variables. This adapter just allows limited RequireJS
* usage from within the requirejs directory. The general
* node adapater is r.js.
*/
(function () {
//Supply an implementation that allows synchronous get of a module.
}
var ret,
//Normalize module name, if it contains . or ..
} else {
//Try to dynamically fetch it.
//The above call is sync, so can do the next thing safely.
}
}
return ret;
};
//Add wrapper around the code so that it gets the requirejs
//API instead of the Node API, and it is done lexically so
//that it survives later execution.
return '(function (require, requirejs, define) { ' +
contents +
'\n}(requirejsVars.require, requirejsVars.requirejs, requirejsVars.define));';
};
//Indicate a the module is in process of loading.
try {
} catch (e) {
moduleName + '" failed with error: ' + e);
err.originalError = e;
}
} else {
def(moduleName, function () {
try {
} catch (e) {
moduleName + '") failed with error: ' + e);
err.originalError = e;
}
});
}
//Support anonymous modules.
return undefined;
};
/*jslint evil: true */
};
}());
}
//Support a default file name to execute. Useful for hosted envs
//like Joyent where it defaults to a server.js as the only executed
//script. But only do it if this is not an optimization run.
}
/**
* Loads the library files that can be used for the optimizer, or for other
* tasks.
*/
function loadLib() {
/**
* @license Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
* Available via the MIT or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*jslint strict: false */
/*global Packages: false, process: false, window: false, navigator: false,
document: false, define: false */
/**
* A plugin that modifies any /env/ path to be the right path based on
* the host environment. Right now only works for Node, Rhino and browser.
*/
(function () {
env = 'unknown';
if (typeof Packages !== 'undefined') {
env = 'rhino';
} else if (typeof process !== 'undefined') {
env = 'node';
env = 'browser';
}
define('env', {
//Allow override in the config.
}
} else {
return env;
}
});
});
}
});
}());
if(env === 'node') {
/**
* @license Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
* Available via the MIT or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*jslint strict: false */
/*global define: false, process: false */
//Do not return the "node" or "r.js" arguments
//Ignore any command option used for rq.js
}
return args;
});
}
if(env === 'rhino') {
/**
* @license Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
* Available via the MIT or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*jslint strict: false */
/*global define: false, process: false */
var jsLibRhinoArgs = (typeof rhinoArgs !== 'undefined' && rhinoArgs) || [].concat(Array.prototype.slice.call(arguments, 0));
var args = jsLibRhinoArgs;
//Ignore any command option used for rq.js
}
return args;
});
}
if(env === 'node') {
/**
* @license RequireJS Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
* Available via the MIT or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*jslint strict: false */
/*global define: false, console: false */
}
return load;
});
}
if(env === 'rhino') {
/**
* @license RequireJS Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
* Available via the MIT or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*jslint strict: false */
/*global define: false, load: false */
return load;
});
}
if(env === 'node') {
/**
* @license Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
* Available via the MIT or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*jslint plusplus: false, octal:false, strict: false */
/*global define: false, process: false */
windowsDriveRegExp = /^[a-zA-Z]\:\/$/,
file;
function frontSlash(path) {
}
}
try {
return true;
} catch (e) {
return false;
}
}
}
}
currDir = '',
first = true;
//First part may be empty string if path starts with a slash.
first = false;
if (part) {
}
});
}
file = {
backSlashRegExp: /\\/g,
exclusionRegExp: /^\./,
getLineSeparator: function () {
return '/';
},
},
},
/**
* Gets the absolute file path as a string, normalized
* to using front slashes for path separators.
* @param {String} fileName
*/
},
},
},
isDirectory: function (path) {
},
getFilteredFileList: function (/*String*/startDir, /*RegExp*/regExpFilters, /*boolean?*/makeUnixPaths) {
//summary: Recurses startDir and finds matches to the files that match regExpFilters.include
//and do not match regExpFilters.exclude. Or just one regexp can be passed in for regExpFilters,
//and it will be treated as the "include" case.
//Ignores files/directories that start with a period (.) unless exclusionRegExp
//is set to another value.
fileName = dirFileArray[i];
if (makeUnixPaths) {
//Make sure we have a JS string.
}
}
ok = true;
if (regExpInclude) {
}
if (ok && regExpExclude) {
}
}
} else if (stat.isDirectory() &&
}
}
}
return files; //Array
},
copyDir: function (/*String*/srcDir, /*String*/destDir, /*RegExp?*/regExpFilter, /*boolean?*/onlyCopyNew) {
//summary: copies files from srcDir to destDir using the regExpFilter to determine if the
//file should be copied. Returns a list file name strings of the destinations that were copied.
regExpFilter = regExpFilter || /\w/;
//Normalize th directory names, but keep front slashes.
//path module on windows now returns backslashed paths.
srcFileName = fileNames[i];
}
}
},
//summary: copies srcFileName to destFileName. If onlyCopyNew is set, it only copies the file if
//srcFileName is newer than destFileName. Returns a boolean indicating if the copy occurred.
var parentDir;
//logger.trace("Src filename: " + srcFileName);
//logger.trace("Dest filename: " + destFileName);
//If onlyCopyNew is true, then compare dates and only copy if the src is newer
//than dest.
if (onlyCopyNew) {
if (file.exists(destFileName) && fs.statSync(destFileName).mtime.getTime() >= fs.statSync(srcFileName).mtime.getTime()) {
return false; //Boolean
}
}
//Make sure destination dir exists.
}
return true; //Boolean
},
/**
* Renames a file. May fail if "to" already exists or is on another drive.
*/
},
/**
* Reads a *text* file.
*/
if (encoding === 'utf-8') {
encoding = 'utf8';
}
if (!encoding) {
encoding = 'utf8';
}
//Hmm, would not expect to get A BOM, but it seems to happen,
//remove it just in case.
}
return text;
},
//summary: saves a *text* file using UTF-8 encoding.
},
//summary: saves a *text* file.
var parentDir;
if (encoding === 'utf-8') {
encoding = 'utf8';
}
if (!encoding) {
encoding = 'utf8';
}
//Make sure destination directories exist.
}
},
//summary: deletes a file or directory if it exists.
if (stat.isDirectory()) {
}
} else {
}
}
}
};
return file;
});
}
if(env === 'rhino') {
/**
* @license RequireJS Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
* Available via the MIT or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
//Helper functions to deal with file I/O.
/*jslint plusplus: false, strict: false */
/*global java: false, define: false */
var file = {
backSlashRegExp: /\\/g,
exclusionRegExp: /^\./,
getLineSeparator: function () {
return file.lineSeparator;
},
},
},
},
},
isDirectory: function (path) {
},
/**
* Gets the absolute file path as a string, normalized
* to using front slashes for path separators.
* @param {java.io.File||String} file
*/
if (typeof fileObj === "string") {
}
},
getFilteredFileList: function (/*String*/startDir, /*RegExp*/regExpFilters, /*boolean?*/makeUnixPaths, /*boolean?*/startDirIsJavaObject) {
//summary: Recurses startDir and finds matches to the files that match regExpFilters.include
//and do not match regExpFilters.exclude. Or just one regexp can be passed in for regExpFilters,
//and it will be treated as the "include" case.
//Ignores files/directories that start with a period (.) unless exclusionRegExp
//is set to another value.
if (!startDirIsJavaObject) {
}
fileObj = dirFileArray[i];
if (makeUnixPaths) {
//Make sure we have a JS string.
}
}
ok = true;
if (regExpInclude) {
}
if (ok && regExpExclude) {
}
}
} else if (fileObj.isDirectory() &&
}
}
}
return files; //Array
},
copyDir: function (/*String*/srcDir, /*String*/destDir, /*RegExp?*/regExpFilter, /*boolean?*/onlyCopyNew) {
//summary: copies files from srcDir to destDir using the regExpFilter to determine if the
//file should be copied. Returns a list file name strings of the destinations that were copied.
regExpFilter = regExpFilter || /\w/;
srcFileName = fileNames[i];
}
}
},
//summary: copies srcFileName to destFileName. If onlyCopyNew is set, it only copies the file if
//srcFileName is newer than destFileName. Returns a boolean indicating if the copy occurred.
//logger.trace("Src filename: " + srcFileName);
//logger.trace("Dest filename: " + destFileName);
//If onlyCopyNew is true, then compare dates and only copy if the src is newer
//than dest.
if (onlyCopyNew) {
return false; //Boolean
}
}
//Make sure destination dir exists.
}
}
//Java's version of copy file.
srcChannel.close();
destChannel.close();
return true; //Boolean
},
/**
* Renames a file. May fail if "to" already exists or is on another drive.
*/
},
//A file read function that can deal with BOMs
input = new java.io.BufferedReader(new java.io.InputStreamReader(new java.io.FileInputStream(fileObj), encoding)),
try {
// Byte Order Mark (BOM) - The Unicode Standard, version 3.0, page 324
// Note that when we use utf-8, the BOM should appear as "EF BB BF", but it doesn't due to this bug in the JDK:
// Eat the BOM, since we've already found the encoding on this file,
// and we plan to concatenating this buffer with others; the BOM should
// only appear at the top of a file.
}
while (line !== null) {
}
//Make sure we return a JavaScript string and not a Java string.
} finally {
}
},
//summary: saves a file using UTF-8 encoding.
},
//summary: saves a file.
}
}
if (encoding) {
} else {
}
try {
} finally {
}
},
//summary: deletes a file or directory if it exists.
if (fileObj.isDirectory()) {
this.deleteFile(files[i]);
}
}
fileObj["delete"]();
}
}
};
return file;
});
}
/**
* @license Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
* Available via the MIT or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*jslint plusplus: true */
/*global define */
define('lang', function () {
'use strict';
var lang = {
backSlashRegExp: /\\/g,
},
isFunction: function(it) {
},
},
var name;
}
}
return dest; // Object
},
/**
* mixin({}, obj1, obj2) is allowed. If the last argument is a boolean,
* then the source objects properties are force copied over to dest.
*/
override, i, l;
}
}
return dest; // Object
},
delegate: (function () {
function TMP() {}
if (props) {
}
return tmp; // Object
};
}())
};
return lang;
});
if(env === 'node') {
/**
* @license RequireJS Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
* Available via the MIT or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*jslint strict: false */
/*global define: false, console: false */
}
return print;
});
}
if(env === 'rhino') {
/**
* @license RequireJS Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
* Available via the MIT or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*jslint strict: false */
/*global define: false, print: false */
return print;
});
}
/**
* @license RequireJS Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
* Available via the MIT or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*jslint nomen: false, strict: false */
/*global define: false */
var logger = {
TRACE: 0,
INFO: 1,
WARN: 2,
ERROR: 3,
SILENT: 4,
level: 0,
logPrefix: "",
},
}
},
}
},
}
},
}
},
},
}
};
return logger;
});
//Just a blank file to use when building the optimizer with the optimizer,
//so that the build does not attempt to inline some env modules,
//like Node's fs and path.
//Just a blank file to use when building the optimizer with the optimizer,
//so that the build does not attempt to inline some env modules,
//like Node's fs and path.
/***********************************************************************
A JavaScript tokenizer / parser / beautifier / compressor.
This version is suitable for Node.js. With minimal changes (the
exports stuff) it should work on any JS platform.
of parse-js [1], a JavaScript parser library written in Common Lisp
by Marijn Haverbeke. Thank you Marijn!
Exported functions:
- tokenizer(code) -- returns a function. Call the returned
function to fetch the next token.
- parse(code) -- returns an AST of the given JavaScript code.
-------------------------------- (C) ---------------------------------
Author: Mihai Bazon
<mihai.bazon@gmail.com>
Distributed under the BSD license:
Copyright 2010 (c) Mihai Bazon <mihai.bazon@gmail.com>
Based on parse-js (http://marijn.haverbeke.nl/parse-js/).
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
* Redistributions of source code must retain the above
copyright notice, this list of conditions and the following
disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
***********************************************************************/
/* -----[ Tokenizer (constants) ]----- */
var KEYWORDS = array_to_hash([
"break",
"case",
"catch",
"const",
"continue",
"default",
"delete",
"do",
"else",
"finally",
"for",
"function",
"if",
"in",
"instanceof",
"new",
"return",
"switch",
"throw",
"try",
"typeof",
"var",
"void",
"while",
"with"
]);
var RESERVED_WORDS = array_to_hash([
"abstract",
"boolean",
"byte",
"char",
"class",
"debugger",
"double",
"enum",
"export",
"extends",
"final",
"float",
"goto",
"implements",
"import",
"int",
"interface",
"long",
"native",
"package",
"private",
"protected",
"public",
"short",
"static",
"super",
"synchronized",
"throws",
"transient",
"volatile"
]);
"return",
"new",
"delete",
"throw",
"else",
"case"
]);
var KEYWORDS_ATOM = array_to_hash([
"false",
"null",
"true",
"undefined"
]);
var RE_DEC_NUMBER = /^\d*\.?\d*(?:e[+-]?\d*(?:\d\.?|\.?\d)\d*)?$/i;
var OPERATORS = array_to_hash([
"in",
"instanceof",
"typeof",
"new",
"void",
"delete",
"++",
"--",
"+",
"-",
"!",
"~",
"&",
"|",
"^",
"*",
"/",
"%",
">>",
"<<",
">>>",
"<",
">",
"<=",
">=",
"==",
"===",
"!=",
"!==",
"?",
"=",
"+=",
"-=",
"/=",
"*=",
"%=",
">>=",
"<<=",
">>>=",
"|=",
"^=",
"&=",
"&&",
"||"
]);
var WHITESPACE_CHARS = array_to_hash(characters(" \u00a0\n\r\t\f\u000b\u200b\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000"));
/* -----[ Tokenizer ]----- */
// regexps adapted from http://xregexp.com/plugins/#unicode
var UNICODE = {
letter: new RegExp("[\\u0041-\\u005A\\u0061-\\u007A\\u00AA\\u00B5\\u00BA\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u0523\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0621-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971\\u0972\\u097B-\\u097F\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C33\\u0C35-\\u0C39\\u0C3D\\u0C58\\u0C59\\u0C60\\u0C61\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D28\\u0D2A-\\u0D39\\u0D3D\\u0D60\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC\\u0EDD\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8B\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10D0-\\u10FA\\u10FC\\u1100-\\u1159\\u115F-\\u11A2\\u11A8-\\u11F9\\u1200-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F4\\u1401-\\u166C\\u166F-\\u1676\\u1681-\\u169A\\u16A0-\\u16EA\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u18A8\\u18AA\\u1900-\\u191C\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19A9\\u19C1-\\u19C7\\u1A00-\\u1A16\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u2094\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2183\\u2184\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2C6F\\u2C71-\\u2C7D\\u2C80-\\u2CE4\\u2D00-\\u2D25\\u2D30-\\u2D65\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005\\u3006\\u3031-\\u3035\\u303B\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31B7\\u31F0-\\u31FF\\u3400\\u4DB5\\u4E00\\u9FC3\\uA000-\\uA48C\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA65F\\uA662-\\uA66E\\uA67F-\\uA697\\uA717-\\uA71F\\uA722-\\uA788\\uA78B\\uA78C\\uA7FB-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA90A-\\uA925\\uA930-\\uA946\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAC00\\uD7A3\\uF900-\\uFA2D\\uFA30-\\uFA6A\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]"),
non_spacing_mark: new RegExp("[\\u0300-\\u036F\\u0483-\\u0487\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u0610-\\u061A\\u064B-\\u065E\\u0670\\u06D6-\\u06DC\\u06DF-\\u06E4\\u06E7\\u06E8\\u06EA-\\u06ED\\u0711\\u0730-\\u074A\\u07A6-\\u07B0\\u07EB-\\u07F3\\u0816-\\u0819\\u081B-\\u0823\\u0825-\\u0827\\u0829-\\u082D\\u0900-\\u0902\\u093C\\u0941-\\u0948\\u094D\\u0951-\\u0955\\u0962\\u0963\\u0981\\u09BC\\u09C1-\\u09C4\\u09CD\\u09E2\\u09E3\\u0A01\\u0A02\\u0A3C\\u0A41\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A70\\u0A71\\u0A75\\u0A81\\u0A82\\u0ABC\\u0AC1-\\u0AC5\\u0AC7\\u0AC8\\u0ACD\\u0AE2\\u0AE3\\u0B01\\u0B3C\\u0B3F\\u0B41-\\u0B44\\u0B4D\\u0B56\\u0B62\\u0B63\\u0B82\\u0BC0\\u0BCD\\u0C3E-\\u0C40\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C62\\u0C63\\u0CBC\\u0CBF\\u0CC6\\u0CCC\\u0CCD\\u0CE2\\u0CE3\\u0D41-\\u0D44\\u0D4D\\u0D62\\u0D63\\u0DCA\\u0DD2-\\u0DD4\\u0DD6\\u0E31\\u0E34-\\u0E3A\\u0E47-\\u0E4E\\u0EB1\\u0EB4-\\u0EB9\\u0EBB\\u0EBC\\u0EC8-\\u0ECD\\u0F18\\u0F19\\u0F35\\u0F37\\u0F39\\u0F71-\\u0F7E\\u0F80-\\u0F84\\u0F86\\u0F87\\u0F90-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u102D-\\u1030\\u1032-\\u1037\\u1039\\u103A\\u103D\\u103E\\u1058\\u1059\\u105E-\\u1060\\u1071-\\u1074\\u1082\\u1085\\u1086\\u108D\\u109D\\u135F\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17B7-\\u17BD\\u17C6\\u17C9-\\u17D3\\u17DD\\u180B-\\u180D\\u18A9\\u1920-\\u1922\\u1927\\u1928\\u1932\\u1939-\\u193B\\u1A17\\u1A18\\u1A56\\u1A58-\\u1A5E\\u1A60\\u1A62\\u1A65-\\u1A6C\\u1A73-\\u1A7C\\u1A7F\\u1B00-\\u1B03\\u1B34\\u1B36-\\u1B3A\\u1B3C\\u1B42\\u1B6B-\\u1B73\\u1B80\\u1B81\\u1BA2-\\u1BA5\\u1BA8\\u1BA9\\u1C2C-\\u1C33\\u1C36\\u1C37\\u1CD0-\\u1CD2\\u1CD4-\\u1CE0\\u1CE2-\\u1CE8\\u1CED\\u1DC0-\\u1DE6\\u1DFD-\\u1DFF\\u20D0-\\u20DC\\u20E1\\u20E5-\\u20F0\\u2CEF-\\u2CF1\\u2DE0-\\u2DFF\\u302A-\\u302F\\u3099\\u309A\\uA66F\\uA67C\\uA67D\\uA6F0\\uA6F1\\uA802\\uA806\\uA80B\\uA825\\uA826\\uA8C4\\uA8E0-\\uA8F1\\uA926-\\uA92D\\uA947-\\uA951\\uA980-\\uA982\\uA9B3\\uA9B6-\\uA9B9\\uA9BC\\uAA29-\\uAA2E\\uAA31\\uAA32\\uAA35\\uAA36\\uAA43\\uAA4C\\uAAB0\\uAAB2-\\uAAB4\\uAAB7\\uAAB8\\uAABE\\uAABF\\uAAC1\\uABE5\\uABE8\\uABED\\uFB1E\\uFE00-\\uFE0F\\uFE20-\\uFE26]"),
space_combining_mark: new RegExp("[\\u0903\\u093E-\\u0940\\u0949-\\u094C\\u094E\\u0982\\u0983\\u09BE-\\u09C0\\u09C7\\u09C8\\u09CB\\u09CC\\u09D7\\u0A03\\u0A3E-\\u0A40\\u0A83\\u0ABE-\\u0AC0\\u0AC9\\u0ACB\\u0ACC\\u0B02\\u0B03\\u0B3E\\u0B40\\u0B47\\u0B48\\u0B4B\\u0B4C\\u0B57\\u0BBE\\u0BBF\\u0BC1\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCC\\u0BD7\\u0C01-\\u0C03\\u0C41-\\u0C44\\u0C82\\u0C83\\u0CBE\\u0CC0-\\u0CC4\\u0CC7\\u0CC8\\u0CCA\\u0CCB\\u0CD5\\u0CD6\\u0D02\\u0D03\\u0D3E-\\u0D40\\u0D46-\\u0D48\\u0D4A-\\u0D4C\\u0D57\\u0D82\\u0D83\\u0DCF-\\u0DD1\\u0DD8-\\u0DDF\\u0DF2\\u0DF3\\u0F3E\\u0F3F\\u0F7F\\u102B\\u102C\\u1031\\u1038\\u103B\\u103C\\u1056\\u1057\\u1062-\\u1064\\u1067-\\u106D\\u1083\\u1084\\u1087-\\u108C\\u108F\\u109A-\\u109C\\u17B6\\u17BE-\\u17C5\\u17C7\\u17C8\\u1923-\\u1926\\u1929-\\u192B\\u1930\\u1931\\u1933-\\u1938\\u19B0-\\u19C0\\u19C8\\u19C9\\u1A19-\\u1A1B\\u1A55\\u1A57\\u1A61\\u1A63\\u1A64\\u1A6D-\\u1A72\\u1B04\\u1B35\\u1B3B\\u1B3D-\\u1B41\\u1B43\\u1B44\\u1B82\\u1BA1\\u1BA6\\u1BA7\\u1BAA\\u1C24-\\u1C2B\\u1C34\\u1C35\\u1CE1\\u1CF2\\uA823\\uA824\\uA827\\uA880\\uA881\\uA8B4-\\uA8C3\\uA952\\uA953\\uA983\\uA9B4\\uA9B5\\uA9BA\\uA9BB\\uA9BD-\\uA9C0\\uAA2F\\uAA30\\uAA33\\uAA34\\uAA4D\\uAA7B\\uABE3\\uABE4\\uABE6\\uABE7\\uABE9\\uABEA\\uABEC]"),
connector_punctuation: new RegExp("[\\u005F\\u203F\\u2040\\u2054\\uFE33\\uFE34\\uFE4D-\\uFE4F\\uFF3F]")
};
};
};
function is_alphanumeric_char(ch) {
};
function is_unicode_combining_mark(ch) {
};
function is_unicode_connector_punctuation(ch) {
};
function is_identifier_start(ch) {
};
function is_identifier_char(ch) {
return is_identifier_start(ch)
;
};
function parse_js_number(num) {
return parseFloat(num);
}
};
};
return this.message + " (line: " + this.line + ", col: " + this.col + ", pos: " + this.pos + ")" + "\n\n" + this.stack;
};
};
};
var EX_EOF = {};
var S = {
pos : 0,
tokpos : 0,
line : 0,
tokline : 0,
col : 0,
tokcol : 0,
newline_before : false,
regex_allowed : false,
comments_before : []
};
if (signal_eof && !ch)
throw EX_EOF;
if (ch == "\n") {
++S.line;
S.col = 0;
} else {
++S.col;
}
return ch;
};
function eof() {
return !S.peek();
};
return pos;
};
function start_token() {
};
var ret = {
nlb : S.newline_before
};
if (!is_comment) {
S.comments_before = [];
}
S.newline_before = false;
return ret;
};
function skip_whitespace() {
next();
};
function read_while(pred) {
}
return ret;
};
function parse_error(err) {
};
if (has_x) return false;
return has_x = true;
}
if (has_e) return false;
}
if (ch == "-") {
return false;
}
after_e = false;
if (ch == ".") {
return has_dot = true;
return false;
}
return is_alphanumeric_char(ch);
});
if (prefix)
} else {
}
};
function read_escaped_char(in_string) {
switch (ch) {
case "n" : return "\n";
case "r" : return "\r";
case "t" : return "\t";
case "b" : return "\b";
case "v" : return "\u000b";
case "f" : return "\f";
case "0" : return "\0";
case "\n": return "";
default : return ch;
}
};
function hex_bytes(n) {
var num = 0;
for (; n > 0; --n) {
parse_error("Invalid hex-character pattern in string");
}
return num;
};
function read_string() {
return with_eof_error("Unterminated string constant", function(){
for (;;) {
if (ch == "\\") {
// read OctalEscapeSequence (XXX: deprecated if "strict mode")
if (!first) {
return ++octal_len;
}
}
return false;
});
else ch = read_escaped_char(true);
}
}
});
};
function read_line_comment() {
next();
if (i == -1) {
} else {
S.pos = i;
}
};
function read_multiline_comment() {
next();
return with_eof_error("Unterminated multiline comment", function(){
var i = find("*/", true),
S.pos = i + 2;
// https://github.com/mishoo/UglifyJS/issues/#issue/100
warn("*** UglifyJS DISCARDS ALL COMMENTS. This means your code might no longer work properly in Internet Explorer.");
}
});
};
function read_name() {
if (!backslash) {
else break;
}
else {
ch = read_escaped_char();
if (!is_identifier_char(ch)) parse_error("Unicode char: " + ch.charCodeAt(0) + " is not valid in identifier");
backslash = false;
}
}
return name;
};
function read_regexp(regexp) {
return with_eof_error("Unterminated regular expression", function(){
prev_backslash = false;
} else if (ch == "[") {
in_class = true;
in_class = false;
break;
} else if (ch == "\\") {
prev_backslash = true;
} else {
}
});
};
function read_operator(prefix) {
next();
} else {
return op;
}
};
};
function handle_slash() {
next();
var regex_allowed = S.regex_allowed;
switch (peek()) {
case "/":
return next_token();
case "*":
return next_token();
}
};
function handle_dot() {
next();
? read_num(".")
};
function read_word() {
};
try {
return cont();
} catch(ex) {
else throw ex;
}
};
function next_token(force_regexp) {
if (force_regexp != null)
return read_regexp(force_regexp);
start_token();
};
return S;
};
return next_token;
};
/* -----[ Parser (constants) ]----- */
var UNARY_PREFIX = array_to_hash([
"typeof",
"void",
"delete",
"--",
"++",
"!",
"~",
"-",
"+"
]);
var ASSIGNMENT = (function(a, ret, i){
while (i < a.length) {
i++;
}
return ret;
})(
["+=", "-=", "/=", "*=", "%=", ">>=", "<<=", ">>>=", "|=", "^=", "&="],
{ "=": true },
0
);
var PRECEDENCE = (function(a, ret){
var b = a[i];
for (var j = 0; j < b.length; ++j) {
ret[b[j]] = n;
}
}
return ret;
})(
[
["||"],
["&&"],
["|"],
["^"],
["&"],
["==", "===", "!=", "!=="],
["<", ">", "<=", ">=", "in", "instanceof"],
[">>", "<<", ">>>"],
["+", "-"],
["*", "/", "%"]
],
{}
);
/* -----[ Parser ]----- */
};
var S = {
token : null,
prev : null,
peeked : null,
in_function : 0,
in_loop : 0,
labels : []
};
};
function next() {
if (S.peeked) {
S.peeked = null;
} else {
}
return S.token;
};
function prev() {
return S.prev;
};
};
};
function unexpected(token) {
if (token == null)
};
return next();
}
};
function can_insert_semicolon() {
return !exigent_mode && (
);
};
function semicolon() {
else if (!can_insert_semicolon()) unexpected();
};
function as() {
};
function parenthesised() {
expect("(");
var ex = expression();
expect(")");
return ex;
};
};
function maybe_embed_tokens(parser) {
if (embed_tokens) return function() {
return ast;
};
else return parser;
};
var statement = maybe_embed_tokens(function() {
S.peeked = null;
}
case "num":
case "string":
case "regexp":
case "operator":
case "atom":
return simple_statement();
case "name":
: simple_statement();
case "punc":
case "{":
case "[":
case "(":
return simple_statement();
case ";":
next();
return as("block");
default:
unexpected();
}
case "keyword":
case "break":
return break_cont("break");
case "continue":
return break_cont("continue");
case "debugger":
semicolon();
return as("debugger");
case "do":
return (function(body){
case "for":
return for_();
case "function":
return function_(true);
case "if":
return if_();
case "return":
if (S.in_function == 0)
croak("'return' outside of function");
return as("return",
? (next(), null)
? null
case "switch":
case "throw":
croak("Illegal newline after 'throw'");
case "try":
return try_();
case "var":
case "const":
case "while":
case "with":
default:
unexpected();
}
}
});
function labeled_statement(label) {
};
function simple_statement() {
};
function break_cont(type) {
var name;
if (!can_insert_semicolon()) {
}
if (name != null) {
next();
}
else if (S.in_loop == 0)
semicolon();
};
function for_() {
expect("(");
var init = null;
: expression(true, true);
}
return regular_for(init);
};
function regular_for(init) {
expect(";");
expect(";");
expect(")");
};
next();
var obj = expression();
expect(")");
};
var function_ = function(in_statement) {
if (in_statement && !name)
unexpected();
expect("(");
name,
// arguments
(function(first, a){
next();
}
next();
return a;
})(true, []),
// body
(function(){
++S.in_function;
S.in_loop = 0;
var a = block_();
--S.in_function;
return a;
})());
};
function if_() {
next();
}
};
function block_() {
expect("{");
var a = [];
}
next();
return a;
};
expect("{");
var a = [], cur = null;
next();
cur = [];
expect(":");
}
next();
expect(":");
cur = [];
}
else {
if (!cur) unexpected();
}
}
next();
return a;
});
function try_() {
next();
expect("(");
if (!is("name"))
croak("Name expected");
next();
expect(")");
}
next();
}
};
var a = [];
for (;;) {
if (!is("name"))
unexpected();
next();
next();
} else {
}
break;
next();
}
return a;
};
};
function const_() {
};
function new_() {
next();
} else {
args = [];
}
};
next();
return new_();
}
if (is("punc")) {
case "(":
next();
case "[":
next();
case "{":
next();
}
unexpected();
}
next();
}
}
unexpected();
});
var first = true, a = [];
} else {
a.push(expression(false));
}
}
next();
return a;
};
function array_() {
};
function object_() {
var first = true, a = [];
// allow trailing comma
break;
var name = as_property_name();
} else {
expect(":");
}
}
next();
return as("object", a);
};
function as_property_name() {
case "num":
case "string":
}
return as_name();
};
function as_name() {
case "name":
case "operator":
case "keyword":
case "atom":
default:
unexpected();
}
};
next();
}
next();
}
next();
}
return expr;
};
function maybe_unary(allow_calls) {
return make_unary("unary-prefix",
}
next();
}
return val;
};
};
next();
}
return left;
};
};
function maybe_conditional(no_in) {
next();
var yes = expression(false);
expect(":");
}
return expr;
};
function is_assignable(expr) {
if (!exigent_mode) return true;
case "dot":
case "sub":
case "new":
case "call":
return true;
case "name":
}
};
function maybe_assign(no_in) {
if (is_assignable(left)) {
next();
}
croak("Invalid assignment");
}
return left;
};
commas = true;
next();
}
return expr;
});
try {
++S.in_loop;
return cont();
} finally {
--S.in_loop;
}
};
return as("toplevel", (function(a){
while (!is("eof"))
return a;
})([]));
};
/* -----[ Utilities ]----- */
function curry(f) {
};
if (ret instanceof Function)
arguments[i]();
return ret;
};
function array_to_hash(a) {
var ret = {};
for (var i = 0; i < a.length; ++i)
ret[a[i]] = true;
return ret;
};
};
function characters(str) {
};
return true;
return false;
};
};
var warn = function() {};
/* -----[ Exports ]----- */
};
});
define('uglifyjs/squeeze-more', ["require", "exports", "module", "./parse-js", "./process"], function(require, exports, module) {
function ast_squeeze_more(ast) {
function with_scope(s, cont) {
scope = s;
return ret;
};
};
return w.with_walkers({
"toplevel": function(body) {
},
"function": _lambda,
"defun": _lambda,
return [ "array", args ];
} else {
}
return [ "object", [] ];
} else {
}
} else if ((ctor[1] == "RegExp" || ctor[1] == "Function" || ctor[1] == "Error") && !scope.has(ctor[1])) {
}
}
},
// foo.toString() ==> foo+""
}
return [ "array", args ];
}
return [ "object", [] ];
}
}
}
}
}, function() {
});
};
});define('uglifyjs/process', ["require", "exports", "module", "./parse-js", "./squeeze-more"], function(require, exports, module) {
/***********************************************************************
A JavaScript tokenizer / parser / beautifier / compressor.
This version is suitable for Node.js. With minimal changes (the
exports stuff) it should work on any JS platform.
This file implements some AST processors. They work on data built
by parse-js.
Exported functions:
in the AST. Returns an AST.
- ast_squeeze(ast) -- employs various optimizations to make the
final generated code even smaller. Returns an AST.
- gen_code(ast, options) -- generates JS code from the AST. Pass
true (or an object, see the code for some options) as second
argument to get "pretty" (indented) code.
-------------------------------- (C) ---------------------------------
Author: Mihai Bazon
<mihai.bazon@gmail.com>
Distributed under the BSD license:
Copyright 2010 (c) Mihai Bazon <mihai.bazon@gmail.com>
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
* Redistributions of source code must retain the above
copyright notice, this list of conditions and the following
disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
***********************************************************************/
/* -----[ helper for AST traversal ]----- */
function ast_walker() {
var a = [ def[0] ];
return a;
}) ];
};
function _block(statements) {
var out = [ this[0] ];
if (statements != null)
return out;
};
var walkers = {
"string": function(str) {
return [ this[0], str ];
},
"num": function(num) {
return [ this[0], num ];
},
"name": function(name) {
return [ this[0], name ];
},
"toplevel": function(statements) {
},
"block": _block,
"splice": _block,
"var": _vardefs,
"const": _vardefs,
"try": function(t, c, f) {
return [
this[0],
];
},
"throw": function(expr) {
},
},
}) ];
},
"break": function(label) {
return [ this[0], label ];
},
"continue": function(label) {
return [ this[0], label ];
},
"conditional": function(cond, t, e) {
},
},
"dot": function(expr) {
},
},
},
},
"if": function(conditional, t, e) {
},
},
},
},
},
"return": function(expr) {
},
},
},
},
},
"object": function(props) {
return p.length == 2
}) ];
},
},
"array": function(elements) {
},
"stat": function(stat) {
},
"seq": function() {
},
},
},
"atom": function(name) {
return [ this[0], name ];
}
};
var user = {};
var stack = [];
if (ast == null)
return null;
try {
if (gen) {
if (ret != null)
return ret;
}
} finally {
}
};
if (ast == null)
return null;
try {
} finally {
}
};
var save = {}, i;
}
}
return ret;
};
return {
parent: function() {
},
stack: function() {
return stack;
}
};
};
/* -----[ Scope and mangling ]----- */
this.names = {}; // names defined in this scope
this.mangled = {}; // mangled names (orig.name => mangled)
this.rev_mangled = {}; // reverse lookup (mangled => orig.name)
this.refs = {}; // names referenced from this scope
this.uses_with = false; // will become TRUE if with() is detected in this or any subscopes
this.uses_eval = false; // will become TRUE if eval() is detected in this or any subscopes
this.children = []; // sub-scopes
if (parent) {
} else {
this.level = 0;
}
};
var base54 = (function(){
var DIGITS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_";
return function(num) {
var ret = "";
do {
} while (num > 0);
return ret;
};
})();
for (var s = this; s; s = s.parent)
return s;
},
has_mangled: function(mname) {
for (var s = this; s; s = s.parent)
return s;
},
toJSON: function() {
return {
};
},
next_mangled: function() {
// we must be careful that the new mangled name:
//
// 1. doesn't shadow a mangled name from a parent
// scope, unless we don't reference the original
// name from this scope OR from any sub-scopes!
// This will get slow.
//
// 2. doesn't shadow an original name from a parent
// scope, in the event that the name is not mangled
// in the parent scope and we reference that name
// here OR IN ANY SUBSCOPES!
//
// 3. doesn't shadow a name that is referenced but not
// defined (possibly global defined elsewhere).
for (;;) {
// case 1.
prior = this.has_mangled(m);
continue;
// case 2.
continue;
// case 3.
continue;
// I got "do" once. :-/
if (!is_identifier(m))
continue;
return m;
}
},
set_mangle: function(name, m) {
this.rev_mangled[m] = name;
},
if (!s) return name; // not in visible scope, no mangle
},
references: function(name) {
},
if (name != null) {
return name;
}
}
};
function ast_add_scope(ast) {
var current_scope = null;
var having_eval = [];
function with_new_scope(cont) {
return ret;
};
};
};
})];
};
return function(defs) {
});
};
};
if (label)
};
return with_new_scope(function(){
// process AST
var ret = w.with_walkers({
"function": _lambda,
"defun": _lambda,
"break": _breacont,
"continue": _breacont,
for (var s = current_scope; s; s = s.parent)
s.uses_with = true;
},
"try": function(t, c, f) {
if (c != null) return [
this[0],
];
},
"name": function(name) {
if (name == "eval")
}
}, function(){
});
// the reason why we need an additional pass here is
// that names can be used prior to their definition.
// scopes where eval was detected and their parents
// are marked with uses_eval, unless they define the
// "eval" name.
}
});
// for referenced names it might be useful to know
// their origin scope. current_scope here is the
// toplevel one.
// do children first; order shouldn't matter
// find origin scope and propagate the reference to origin
if (s === origin) break;
}
}
};
return ret;
});
};
/* -----[ mangle names ]----- */
return name;
};
function get_define(name) {
// we always lookup a defined symbol for the current scope FIRST, so declared
// vars trump a DEFINE symbol, but if no such var is found, then match a DEFINE value
}
}
return null;
}
};
if (!options.no_functions) {
if (name) {
extra = {};
else
}
else name = null;
}
}
}, extra);
};
scope = s;
s.set_mangle(i, extra[i]);
}
get_mangled(i, true);
}
return ret;
};
}) ];
};
};
return w.with_walkers({
"function": _lambda,
"defun": function() {
// move function declarations to the top when
// they are not in some block.
switch (w.parent()[0]) {
case "toplevel":
case "function":
case "defun":
}
return ast;
},
this[0],
];
},
"break": _breacont,
"continue": _breacont,
"var": _vardefs,
"const": _vardefs,
"name": function(name) {
},
"try": function(t, c, f) {
return [ this[0],
},
"toplevel": function(body) {
var self = this;
});
}
}, function() {
});
};
/* -----[
- compress foo["bar"] into foo.bar,
- remove block brackets {} where possible
- join consecutive var declarations
- various optimizations for IFs:
- if (cond) foo(); else bar(); ==> cond?foo():bar();
- if (cond) foo(); ==> cond&&foo();
- if (foo) return bar(); else return baz(); ==> return foo?bar():baz(); // also for throw
- if (foo) return bar(); else something(); ==> {if(foo)return bar();something()}
]----- */
var warn = function(){};
};
function last_stat(b) {
return b;
}
function aborts(t) {
if (t) switch (last_stat(t)[0]) {
case "return":
case "break":
case "continue":
case "throw":
return true;
}
};
function boolean_expr(expr) {
&& expr[1] === true
);
};
function empty(b) {
};
};
var when_constant = (function(){
var $NOT_CONSTANT = {};
// this can only evaluate constant expressions. If it finds anything
// not constant, it throws $NOT_CONSTANT.
switch (expr[0]) {
case "string":
case "num":
return expr[1];
case "name":
case "atom":
switch (expr[1]) {
case "true": return true;
case "false": return false;
case "null": return null;
}
break;
case "unary-prefix":
switch (expr[1]) {
}
break;
case "binary":
switch (expr[1]) {
}
}
throw $NOT_CONSTANT;
};
try {
switch (typeof val) {
}
} catch(ex) {
if (ex === $NOT_CONSTANT) {
}
// the whole expression is not constant but the lval may be...
try {
expr);
} catch(ex2) {
// IGNORE... lval is not constant
}
}
}
else throw ex;
}
};
})();
function warn_unreachable(ast) {
};
function prepare_ifs(ast) {
// In this first pass, we rewrite ifs which abort with no else with an
// if-else. For example:
//
// if (x) {
// blah();
// return y;
// }
// foobar();
//
// is rewritten into:
//
// if (x) {
// blah();
// return y;
// } else {
// foobar();
// }
function redo_if(statements) {
var fi = statements[i];
if (!aborts(t)) continue;
conditional, // conditional
t, // then
e // else
] ]);
}
return statements;
};
};
function redo_if_block(statements) {
};
return w.with_walkers({
"defun": redo_if_lambda,
"function": redo_if_lambda,
"block": redo_if_block,
"splice": redo_if_block,
"toplevel": function(statements) {
},
"try": function(t, c, f) {
return [
this[0],
redo_if(t),
f != null ? redo_if(f) : null
];
}
}, function() {
});
};
};
return w.with_walkers({
"try": found,
"throw": found,
"return": found,
"new": found,
"switch": found,
"break": found,
"continue": found,
"assign": found,
"call": found,
"if": found,
"for": found,
"for-in": found,
"while": found,
"do": found,
"return": found,
"unary-prefix": unary,
"unary-postfix": unary,
"defun": found
}, function(){
while (true) try {
break;
} catch(ex) {
throw ex;
}
});
};
function ast_lift_variables(ast) {
return [ name ];
});
// looking for assignments to any of these variables.
// we can save considerable space by moving the definitions
// in the var declaration.
&& ast[1] === true
// insert the definition into the var declaration
stop();
break;
}
}
// remove this assignment from the AST.
if (p[0] == "seq") {
var a = p[2];
}
else if (p[0] == "stat") {
}
else {
stop();
}
restart();
}
stop();
});
}
return body;
};
var ret = null;
var d = defs[i];
if (!d[1]) continue;
d = [ "assign", true, [ "name", d[0] ], d[1] ];
}
if (ret == null) {
}
return [ "stat", ret ];
};
};
return w.with_walkers({
},
},
"var": _vardefs,
"toplevel": _toplevel
}, function(){
});
};
make_seqs : true,
dead_code : true,
no_warnings : false,
keep_comps : true
});
function negate(c) {
switch (c[0]) {
case "unary-prefix":
case "seq":
c = slice(c);
return c;
case "conditional":
case "binary":
}
switch (op) {
}
break;
}
return not_c;
};
function make_conditional(c, t, e) {
var make_real_conditional = function() {
if (c[0] == "unary-prefix" && c[1] == "!") {
return e ? [ "conditional", c[2], e, t ] : [ "binary", "||", c[2], t ];
} else {
return e ? best_of(
[ "conditional", c, t, e ],
[ "conditional", negate(c), e, t ]
) : [ "binary", "&&", c, t ];
}
};
// shortcut the conditional if the expression has a constant value
warn_unreachable(val ? e : t);
return (val ? t : e);
};
block = [ "block" ];
}
return block;
};
};
// this function does a few things:
// 1. discard useless blocks
// 2. join consecutive var declarations
// 3. remove obviously dead code
// 4. transform consecutive statements using the comma operator
// 5. if block_type == "lambda" and it detects constructs like if(foo) return ... - rewrite like if (!foo) { ... }
if (stat[1]) {
}
} else {
}
return a;
}, []);
statements = (function(a, prev){
} else {
}
});
return a;
})([]);
if (has_quit) {
}
if (!options.no_warnings)
warn("Variables declared in unreachable code");
return [ def[0] ];
});
}
else if (!options.no_warnings)
}
else {
has_quit = true;
}
});
return a;
})([]);
} else {
}
});
if (a.length >= 2
{
}
return a;
})([]);
// this increases jQuery by 1K. Probably not such a good idea after all..
// part of this is done in prepare_ifs anyway.
// if (block_type == "lambda") statements = (function(i, a, stat){
// while (i < statements.length) {
// stat = statements[i++];
// if (stat[0] == "if" && !stat[3]) {
// if (stat[2][0] == "return" && stat[2][1] == null) {
// a.push(make_if(negate(stat[1]), [ "block", statements.slice(i) ]));
// break;
// }
// var last = last_stat(stat[2]);
// if (last[0] == "return" && last[1] == null) {
// a.push(make_if(stat[1], [ "block", stat[2][1].slice(0, -1) ], [ "block", statements.slice(i) ]));
// break;
// }
// }
// a.push(stat);
// }
// return a;
// })(0, []);
return statements;
};
function make_if(c, t, e) {
if (val) {
t = walk(t);
warn_unreachable(e);
return t || [ "block" ];
} else {
e = walk(e);
warn_unreachable(t);
return e || [ "block" ];
}
}, function() {
return make_real_if(c, t, e);
});
};
function make_real_if(c, t, e) {
c = walk(c);
t = walk(t);
e = walk(e);
if (empty(t)) {
c = negate(c);
t = e;
e = null;
} else if (empty(e)) {
e = null;
} else {
// if we have both else and then, maybe it makes sense to switch them?
(function(){
var a = gen_code(c);
var n = negate(c);
var b = gen_code(n);
var tmp = t;
t = e;
e = tmp;
c = n;
}
})();
}
return [ "stat", c ];
var ret = [ "if", c, t, e ];
}
else if (t[0] == "stat") {
if (e) {
if (e[0] == "stat") {
}
}
else {
}
}
else if (e && t[0] == e[0] && (t[0] == "return" || t[0] == "throw") && t[1] && e[1]) {
}
else if (e && aborts(t)) {
ret = [ [ "if", c, t ] ];
if (e[0] == "block") {
}
else {
}
}
else if (t && aborts(e)) {
if (t[0] == "block") {
} else {
}
}
return ret;
};
if (!val) {
return [ "block" ];
} else {
}
});
};
return w.with_walkers({
if (is_identifier(name))
}
},
"if": make_if,
"toplevel": function(body) {
},
}
}) ];
},
"function": _lambda,
"defun": _lambda,
"block": function(body) {
},
}, function no() {
return function(){
if(l && l[0] == "unary-prefix" && l[1] == "!" && l[2][0] == "num")
else if (r && r[0] == "unary-prefix" && r[1] == "!" && r[2][0] == "num")
}() || this;
});
},
"conditional": function(c, t, e) {
},
"try": function(t, c, f) {
return [
"try",
tighten(t),
f != null ? tighten(f) : null
];
},
if (op == "!")
}, function() { return ret });
},
"name": function(name) {
switch (name) {
case "true": return [ "unary-prefix", "!", [ "num", 0 ]];
case "false": return [ "unary-prefix", "!", [ "num", 1 ]];
}
},
"while": _do_while,
}
}
}, function() {
for (var i = 0; i < 2; ++i) {
}
return ast;
});
};
/* -----[ re-generate code from the AST ]----- */
"name",
"array",
"object",
"string",
"dot",
"sub",
"call",
"regexp",
"defun"
]);
switch (s) {
case "\\": return "\\\\";
case "\b": return "\\b";
case "\f": return "\\f";
case "\n": return "\\n";
case "\r": return "\\r";
case "\t": return "\\t";
case "\u2028": return "\\u2028";
case "\u2029": return "\\u2029";
case "\0": return "\\0";
}
return s;
});
};
return "\\u" + code;
});
};
indent_start : 0,
indent_level : 4,
quote_keys : false,
space_colon : false,
beautify : false,
ascii_only : false,
inline_script: false
});
var indentation = 0,
function encode_string(str) {
if (options.inline_script)
return ret;
};
if (options.ascii_only)
return name;
};
if (line == null)
line = "";
if (beautify)
return line;
};
indentation += incr;
finally { indentation -= incr; }
};
function add_spaces(a) {
if (beautify)
return a.join(" ");
var b = [];
for (var i = 0; i < a.length; ++i) {
var next = a[i + 1];
b.push(a[i]);
if (next &&
b.push(" ");
}
}
return b.join("");
};
function add_commas(a) {
};
function parenthesize(expr) {
}
return gen;
};
function best_of(a) {
if (a.length == 1) {
return a[0];
}
if (a.length == 2) {
var b = a[1];
a = a[0];
}
};
function needs_parens(expr) {
// function literal itself to be parenthesized
// only if it's the first "thing" in a
// statement. This means that the parent is
// "stat", but it could also be a "seq" and
// we're the first in this "seq" and the
// parent is "stat", and so on. Messy stuff,
// but it worths the trouble.
while (p) {
if (p[0] == "stat") return true;
if (((p[0] == "seq" || p[0] == "call" || p[0] == "dot" || p[0] == "sub" || p[0] == "conditional") && p[1] === self) ||
self = p;
p = a.pop();
} else {
return false;
}
}
}
};
if (num >= 0) {
} else {
}
}
}
return best_of(a);
};
var w = ast_walker();
return w.with_walkers({
"string": encode_string,
"num": make_num,
"name": make_name,
"toplevel": function(statements) {
return make_block_statements(statements)
},
"splice": function(statements) {
// we need block brackets in this case
} else {
function(line, i) {
// the first line is already indented
}
},
"block": make_block,
"var": function(defs) {
},
"const": function(defs) {
},
return add_spaces(out);
},
"throw": function(expr) {
},
})) + ")" : "";
return add_spaces([ "new", parenthesize(ctor, "seq", "binary", "conditional", "assign", function(expr){
var w = ast_walker(), has_call = {};
try {
w.with_walkers({
"call": function() { throw has_call },
"function": function() { return this }
}, function(){
});
} catch(ex) {
return true;
throw ex;
}
}) + args ]);
},
},
"break": function(label) {
var out = "break";
if (label != null)
return out + ";";
},
"continue": function(label) {
var out = "continue";
if (label != null)
return out + ";";
},
},
else op = "=";
},
"dot": function(expr) {
out += ".";
} else if (needs_parens(expr))
return out;
},
f = "(" + f + ")";
})) + ")";
},
"function": make_function,
"defun": make_function,
if (el) {
}
return add_spaces(out);
},
var out = [ "for" ];
return add_spaces(out);
},
"in",
},
},
},
"return": function(expr) {
var out = [ "return" ];
},
// XXX: I'm pretty sure other cases will bite here.
// we need to be smarter.
// adding parens all the time is the safest bet.
}
}
}
},
if (!(expr[0] == "num" || (expr[0] == "unary-prefix" && !HOP(OPERATORS, operator + expr[1])) || !needs_parens(expr)))
},
if (!(expr[0] == "num" || (expr[0] == "unary-postfix" && !HOP(OPERATORS, operator + expr[1])) || !needs_parens(expr)))
},
if (needs_parens(expr))
},
"object": function(props) {
var obj_needs_parens = needs_parens(this);
if (p.length == 3) {
// body in p[1][3] and type ("get" / "set") in p[2].
}
if (options.quote_keys) {
} else if (!is_identifier(key)) {
}
},
},
"array": function(elements) {
if (!beautify && el[0] == "atom" && el[1] == "undefined") return i === elements.length - 1 ? "," : "";
})), "]" ]);
},
"stat": function(stmt) {
},
"seq": function() {
},
},
},
"atom": function(name) {
}
// The squeezer replaces "block"-s that contain only a single
// statement with the statement itself; technically, the AST
// is correct, but this can create problems when we output an
// IF having an ELSE clause where the THEN clause ends in an
// IF *without* an ELSE block (then the outer ELSE would refer
// to the inner IF). This function checks for this case and
// adds the block brackets if needed.
if (th == null) return ";";
// https://github.com/mishoo/UglifyJS/issues/#issue/57
// IE croaks with "syntax error" on code like this:
// if (foo) do ... while(cond); else ...
return make_block([ th ]);
}
var b = th;
while (true) {
var type = b[0];
if (type == "if") {
if (!b[3])
// no else, we must add the block
b = b[3];
}
else break;
}
};
if (name) {
}
};
function must_has_semicolon(node) {
switch (node[0]) {
case "with":
case "while":
case "for":
case "for-in":
case "if":
if (node[3]) {
}
}
};
var stat = statements[i];
if (code != ";") {
}
}
}
};
function make_switch_block(body) {
if (n == 0) return "{}";
: "default:");
}) : "");
code += ";";
return code;
};
function make_block(statements) {
if (!statements) return ";";
};
function make_1vardef(def) {
if (val != null)
return name;
};
};
var splits = [ 0 ];
var last_split = 0;
var prev_token;
function current_length(tok) {
};
function split_here(tok) {
};
function custom(){
out: {
if (prev_token) {
}
case "keyword":
case "atom":
case "name":
case "punc":
break out;
}
}
}
prev_token = tok;
return tok;
};
};
return custom;
}());
}).join("\n");
};
/* -----[ Utilities ]----- */
function repeat_string(str, i) {
if (i <= 0) return "";
if (i == 1) return str;
d += d;
if (i & 1) d += str;
return d;
};
var ret = {};
if (args === true)
args = {};
}
return ret;
};
function is_identifier(name) {
&& name != "this"
};
};
// some utilities
var MAP;
(function(){
MAP = function(a, f, o) {
function doit() {
} else {
}
}
} else {
}
}
};
};
})();
/* -----[ Exports ]----- */
// keep this last!
});define('uglifyjs/index', ["require", "exports", "module", "./parse-js", "./process"], function(require, exports, module) {
//convienence function(src, [options]);
return final_code;
};
});/**
* @license Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
* Available via the MIT or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*jslint plusplus: false, strict: false */
/*global define: false */
if (Array.isArray) {
} else {
};
}
/**
* Determines if the AST node is an array literal
*/
function isArrayLiteral(node) {
}
/**
* Determines if the AST node is an object literal
*/
function isObjectLiteral(node) {
}
/**
* Converts a regular JS array of strings to an AST node that
* represents that array.
* @param {Array} ary
* @param {Node} an AST node that represents an array of strings.
*/
function toAstArray(ary) {
var output = [
'array',
[]
],
i, item;
'string',
]);
}
return output;
}
/**
* Validates a node as being an object literal (like for i18n bundles)
* or an array literal with just string members. If an array literal,
* only return array members that are full strings. So the caller of
* this function should use the return value as the new value for the
* node.
*
* This function does not need to worry about comments, they are not
* present in this AST.
*
* @param {Node} node an AST node.
*
* @returns {Node} an AST node to use for the valid dependencies.
* If null is returned, then it means the input node was not a valid
* dependency.
*/
function validateDeps(node) {
var newDeps = ['array', []],
if (!node) {
return null;
}
return node;
}
//Dependencies can be an object literal or an array.
if (!isArrayLiteral(node)) {
return null;
}
}
}
}
/**
* Gets dependencies from a node, but only if it is an array literal,
* and only if the dependency is a string literal.
*
* This function does not need to worry about comments, they are not
* present in this AST.
*
* @param {Node} node an AST node.
*
* @returns {Array} of valid dependencies.
* If null is returned, then it means the input node was not a valid
* array literal, or did not have any string literals..
*/
function getValidDeps(node) {
var newDeps = [],
if (!node) {
return null;
}
return null;
}
//Dependencies can be an object literal or an array.
if (!isArrayLiteral(node)) {
return null;
}
}
}
}
/**
* Main parse function. Returns a string of any valid require or define/require.def
* calls as part of one JavaScript source string.
* @param {String} moduleName the module name that represents this file.
* It is used to create a default define if there is not one already for the file.
* This allows properly tracing dependencies for builds. Otherwise, if
* the file just has a require() call, the file dependencies will not be
* properly reflected: the file will come before its dependencies.
* @param {String} moduleName
* @param {String} fileName
* @param {String} fileContents
* @param {Object} options optional options. insertNeedsDefine: true will
* add calls to require.needsDefine() if appropriate.
* @returns {String} JS source string or null, if no require or define/require.def
* calls are found.
*/
//Set up source input
var moduleDeps = [],
result = '',
moduleList = [],
needsDefine = true,
i, moduleCall, depString;
//If name is an array, it means it is an anonymous module,
//so adjust args appropriately. An anonymous module could
//have a FUNCTION as the name type, but just ignore those
//since we just want to find dependencies.
name = null;
}
deps = [];
}
//Get the name as a string literal, if it is available.
} else {
name = null;
}
needsDefine = false;
}
if (!name) {
//If there is no module name, the dependencies are for
} else {
});
}
//If define was found, no need to dive deeper, unless
//the config explicitly wants to dig deeper.
return !options.findNestedDependencies;
}, options);
}
if (result) {
result += '\n';
}
//If this is the main module for this file, combine any
//"anonymous" dependencies (could come from a nested require
//call) with this module.
moduleDeps = [];
}
}
if (moduleDeps.length) {
if (result) {
result += '\n';
}
}
}
}
//Add some private methods to object for use in derived objects.
/**
* Handles parsing a file recursively for require calls.
* @param {Array} parentNode the AST node to start with.
* @param {Function} onMatch function to call on a parse match.
* @param {Object} [options] This is normally the build config options if
* it is passed.
* @param {Function} [recurseCallback] function to call on each valid
* node, defaults to parse.parseNode.
*/
i, node;
if (isArray(parentNode)) {
node = parentNode[i];
//If has config is in play, if calls have been converted
//options has a 'has' value, skip if branches that have
//literal false values.
//uglify returns if constructs in an array:
//[0]: 'if'
//[1]: the condition, ['name', true | false] for the has replaced case.
//[2]: the block to process if true
//[3]: the block to process if false
//so only ever have to deal with this structure.
} else {
}
} else {
//The onMatch indicated parsing should
//stop for children of this node.
continue;
}
}
}
}
}
};
/**
* Determines if the file defines require().
* @param {String} fileName
* @param {String} fileContents
* @returns {Boolean}
*/
return this.nodeHasRequire(astRoot);
};
/**
* Finds require("") calls inside a CommonJS anonymous module wrapped in a
* define(function(require, exports, module){}) wrapper. These dependencies
* will be added to a modified define() call that lists the dependencies
* on the outside of the function.
* @param {String} fileName
* @param {String} fileContents
* @returns {Array} an array of module names that are dependencies. Always
* returns an array, but could be of length zero.
*/
};
/**
* Finds require("") calls inside a CommonJS anonymous module wrapped
* in a define function, given an AST node for the definition function.
* @param {Node} node the AST node for the definition function.
* @returns {Array} and array of dependency names. Can be of zero length.
*/
var deps = [],
if (node) {
//If no deps, still add the standard CommonJS require, exports, module,
//in that order, to the deps, but only if specified as function args.
//In particular, if exports is used, it is favored over the return
//value of the function, so only add it if asked.
if (funcArgLength) {
}
}
return deps;
};
/**
* Finds the function in define(function (require, exports, module){});
* @param {Array} node
* @returns {Boolean}
*/
//There should only be one argument and it should be a function,
//or a named module with function as second arg
return args[0];
return args[1];
}
}
}
//Check child nodes
n = node[i];
if ((callback = this.findAnonDefineFactory(n))) {
return callback;
}
}
}
return null;
};
/**
* Finds any config that is passed to requirejs.
* @param {String} fileName
* @param {String} fileContents
*
* @returns {Object} a config object. Will be null if no config.
* Can throw an error if the config in the file cannot be evaluated in
* a build context to valid JavaScript.
*/
/*jslint evil: true */
//This is a litle bit inefficient, it ends up with two uglifyjs parser
//calls. Can revisit later, but trying to build out larger functional
//pieces first.
var foundConfig = null,
var jsConfig;
if (!foundConfig && configNode) {
return foundConfig;
}
return undefined;
}, null, parse.parseConfigNode);
return foundConfig;
};
/**
* Finds all dependencies specified in dependency arrays and inside
* simplified commonjs wrappers.
* @param {String} fileName
* @param {String} fileContents
*
* @returns {Array} an array of dependency strings. The dependencies
* have not been normalized, they may be relative IDs.
*/
//This is a litle bit inefficient, it ends up with two uglifyjs parser
//calls. Can revisit later, but trying to build out larger functional
//pieces first.
var dependencies = [],
//Normalize the input args.
name = null;
}
}
}, options);
return dependencies;
};
/**
* Finds only CJS dependencies, ones that are the form require('stringLiteral')
*/
//This is a litle bit inefficient, it ends up with two uglifyjs parser
//calls. Can revisit later, but trying to build out larger functional
//pieces first.
var dependencies = [],
return false;
}
if (call) {
//A require('') use.
}
}
}
return false;
});
return dependencies;
};
/**
* Determines if define(), require({}|[]) or requirejs was called in the
* file. Also finds out if define() is declared and if define.amd is called.
*/
uses;
if (!uses) {
uses = {};
}
return uses;
};
/**
* Determines if require(''), exports.x =, module.exports =,
* __dirname, __filename are used. So, not strictly traditional CommonJS,
* also checks for Node variants.
*/
var uses = null,
assignsExports = false,
if (prop === 'varExports') {
assignsExports = true;
if (!uses) {
uses = {};
}
}
return false;
}
//Hmm, a variable assignment for exports, so does not use cjs exports.
return onMatch('varExports');
if (args) {
//An exports or module.exports assignment.
return onMatch('moduleExports');
return onMatch('exports');
}
}
if (call) {
//A require('') use.
return onMatch('require');
}
}
}
return false;
});
return uses;
};
}
}
}
//Check child nodes
n = node[i];
this.findRequireDepNames(n, deps);
}
}
};
/**
* Determines if a given node contains a require() definition.
* @param {Array} node
* @returns {Boolean}
*/
if (this.isDefineNode(node)) {
return true;
}
n = node[i];
if (this.nodeHasRequire(n)) {
return true;
}
}
}
return false;
};
/**
* Is the given node the actual definition of define(). Actually uses
* the definition of define.amd to find require.
* @param {Array} node
* @returns {Boolean}
*/
//Actually look for the define.amd = assignment, since
//that is more indicative of RequireJS vs a plain require definition.
var assign;
if (!node) {
return null;
}
return true;
}
}
return false;
};
/**
* Determines if a specific node is a valid require or define/require.def call.
* @param {Array} node
* @param {Function} onMatch a function to call when a match is found.
* It is passed the match name, and the config, name, deps possible args.
* The config, name and deps args are not normalized.
*
* Otherwise null.
*/
return false;
}
if (call) {
//It is a plain require() call.
if (isArrayLiteral(config)) {
config = null;
}
return null;
}
//A define call
//Only allow define calls that match what is expected
//in an AMD call:
//* first arg should be string, array, function or object
//* second arg optional, or array, function or object.
//This helps weed out calls to a non-AMD define, but it is
//not completely robust. Someone could create a define
//function that still matches this shape, but this is the
//best that is possible, and at least allows UglifyJS,
//which does create its own internal define in one file,
//to be inlined.
// allow define(['dep'], factory) pattern
//If first arg is a function, could be a commonjs wrapper,
//look inside for commonjs dependencies.
//Also, if deps is a function look for commonjs deps.
}
}
}
}
}
}
}
return false;
};
/**
* Looks for define(), require({} || []), requirejs({} || []) calls.
*/
return false;
}
type = 'declaresDefine';
type = 'defineAmd';
if (call) {
//A require.config() or requirejs.config() call.
//A require() or requirejs() config call.
//Only want ones that start with an object or an array.
}
//A define call.
type = 'define';
}
}
}
if (type) {
}
return false;
};
/**
* call. That includes calls to require/requirejs.config().
* @param {Array} node
* @param {Function} onMatch a function to call when a match is found.
* It is passed the match name, and the config, name, deps possible args.
* The config, name and deps args are not normalized.
*
* Otherwise null.
*/
return false;
}
if (call) {
//A require.config() or requirejs.config() call.
//A require() or requirejs() config call.
) {
//It is a plain require() call.
return null;
}
return onMatch(configNode);
}
}
}
return false;
};
/**
* Converts an AST node into a JS source string. Does not maintain formatting
* or even comments from original source, just returns valid JS source.
* @param {Array} node
* @returns {String} a JS source string.
*/
};
return parse;
});
/**
* @license Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
* Available via the MIT or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*jslint regexp: false, strict: false, plusplus: false */
/*global define: false */
function Temp() {}
//Avoid any extra memory hanging around
if (mixin) {
}
}
}
return temp; // Object
}
var pragma = {
useStrictRegExp: /['"]use strict['"];/g,
defineJQueryRegExp: /typeof\s+define\s*===\s*["']function["']\s*&&\s*define\s*\.\s*amd\s*&&\s*define\s*\.\s*amd\s*\.\s*jQuery/g,
defineHasRegExp: /typeof\s+define\s*==(=)?\s*['"]function['"]\s*&&\s*typeof\s+define\.amd\s*==(=)?\s*['"]object['"]\s*&&\s*define\.amd/g,
defineTernaryRegExp: /typeof\s+define\s*===\s*['"]function["']\s*&&\s*define\s*\.\s*amd\s*\?\s*define/,
amdefineRegExp: /if\s*\(\s*typeof define\s*\!==\s*'function'\s*\)\s*\{\s*[^\{\}]+amdefine[^\{\}]+\}/g,
},
if (ns) {
//Namespace define ternary use:
//Namespace define jquery use:
"typeof " + ns + ".define === 'function' && " + ns + ".define.amd && " + ns + ".define.amd.jQuery");
//Namespace has.js define use:
"typeof " + ns + ".define === 'function' && typeof " + ns + ".define.amd === 'object' && " + ns + ".define.amd");
//Namespace define checks.
//Do this one last, since it is a subset of the more specific
//checks above.
//Check for require.js with the require/define definitions
//Wrap the file contents in a typeof check, and a function
//to contain the API globals.
ns + " === 'undefined') {\n" +
ns + ' = {};\n' +
"\n" +
ns + ".requirejs = requirejs;" +
ns + ".require = require;" +
ns + ".define = define;\n" +
"}\n}());";
}
//Finally, if the file wants a special wrapper because it ties
//in to the requirejs internals in a way that would not fit
//the above matches, do that. Look for /*requirejs namespace: true*/
//Remove the pragma.
//Alter the contents.
fileContents = '(function () {\n' +
'\n}());'
}
}
return fileContents;
},
/**
* processes the fileContents for some //>> conditional statements
*/
/*jslint evil: true */
i, dep, moduleName,
//Legacy arg defined to help in dojo conversion script. Remove later
//when dojo no longer needs conversion:
//Mix in a specific lifecycle scoped object, to allow targeting
//lifecycle events. Do not bother with kwArgs in this section, since
//the old dojo kwArgs were for all points in the build lifecycle.
if (onLifecycleName) {
if (lifecyclePragmas) {
}
if (lifecycleHas) {
}
}
//Replace has references if desired
if (hasConfig) {
}
return match;
});
}
if (!config.skipPragmas) {
//Found a conditional. Get the conditional line.
if (lineEndIndex === -1) {
}
//Increment startIndex past the line so the next conditional search can be done.
//Break apart the conditional.
if (matches) {
isTrue = false;
//See if the condition is true.
try {
} catch (e) {
throw "Error in file: " +
fileName +
". Conditional comment: " +
" failed with this error: " + e;
}
//Find the endpoint marker.
endRegExp = new RegExp('\\/\\/\\>\\>\\s*' + type + 'End\\(\\s*[\'"]' + marker + '[\'"]\\s*\\)', "g");
if (endMatches) {
//Find the next line return based on the match position.
if (lineEndIndex === -1) {
}
//Should we include the segment?
//Remove the conditional comments, and optionally remove the content inside
//the conditional comments.
//Move startIndex to foundIndex, since that is the new position in the file
//where we need to look for more conditionals in the next while loop pass.
} else {
throw "Error in file: " +
fileName +
". Cannot find end marker for conditional comment: " +
}
}
}
}
//If need to find all plugin resources to optimize, do that now,
//before namespacing, since the namespacing will change the API
//names.
//If there is a plugin collector, scan the file for plugin resources.
try {
}
}
}
} catch (eDep) {
fileName + ', skipping.');
}
}
//Strip amdefine use for node-shared modules.
//Do namespacing
}
}
};
return pragma;
});
if(env === 'node') {
/**
* @license Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
* Available via the MIT or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*jslint strict: false */
/*global define: false */
}
if(env === 'rhino') {
/**
* @license Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
* Available via the MIT or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*jslint strict: false, plusplus: false */
/*global define: false, java: false, Packages: false */
//Add .reduce to Rhino so UglifyJS can run in Rhino,
//but rewritten for brevity, and to be good enough for use by UglifyJS.
var i = 0,
} else {
do {
if (i in this) {
accumulator = this[i++];
break;
}
}
while (true);
}
for (; i < length; i++) {
if (i in this) {
}
}
return accumulator;
};
}
var JSSourceFilefromCode, optimize;
//Bind to Closure compiler, but if it is not available, do not sweat it.
try {
JSSourceFilefromCode = java.lang.Class.forName('com.google.javascript.jscomp.JSSourceFile').getMethod('fromCode', [java.lang.String, java.lang.String]);
} catch (e) {}
//Helper for closure compiler, because of weird Java-JavaScript interactions.
}
optimize = {
//Fake extern
//Set up source input
//Set up options
// options are false by default and jslint wanted an if statement in this for loop
}
}
FLAG_compilation_level = jscomp.CompilationLevel[config.CompilationLevel || 'SIMPLE_OPTIMIZATIONS'];
//Trigger the compiler
} else {
}
return fileContents;
}
};
return optimize;
});
}
/**
* @license Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
* Available via the MIT or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*jslint plusplus: false, nomen: false, regexp: false */
/*global define: false */
var optimize,
cssImportRegExp = /\@import\s+(url\()?\s*([^);]+)\s*(\))?([\w, ]*)(;)?/g,
cssUrlRegExp = /\url\(\s*([^\)]+)\s*\)?/g;
/**
* This is not done in the regexp, since my regexp fu is not that strong,
* and the CSS spec allows for ' and " in the URL if they are backslash escaped.
* @param {String} url
*/
function cleanCssUrlQuotes(url) {
//Make sure we are not ending in whitespace.
//Not very confident of the css regexps above that there will not be ending
//whitespace.
}
return url;
}
/**
* Inlines nested stylesheets that have @import calls in them.
* @param {String} fileName
* @param {String} fileContents
* @param {String} [cssImportIgnore]
*/
//Find the last slash in the name.
//Make a file path based on the last slash.
//If no slash, so must be just a file name. Use empty string then.
//Make sure we have a delimited ignore list to make matching faster
cssImportIgnore += ",";
}
return fileContents.replace(cssImportRegExp, function (fullMatch, urlStart, importFileName, urlEnd, mediaTypes) {
//Only process media type "all" or empty media type rules.
return fullMatch;
}
//Ignore the file import if it is part of an ignore list.
return fullMatch;
}
//Make sure we have a unix path for the rest of the operation.
try {
//if a relative path, then tack on the filePath.
//If it is not a relative path, then the readFile below will fail,
//and we will just skip that import.
var fullImportFileName = importFileName.charAt(0) === "/" ? importFileName : filePath + importFileName,
//Make sure to flatten any nested imports.
//Make the full import path
//Make a file path based on the last slash.
//If no slash, so must be just a file name. Use empty string then.
//fix url() on relative import (#5)
//Modify URL paths to match the path represented by this file.
//Only do the work for relative URLs. Skip things that start with / or have
//a protocol.
if (fixedUrlMatch.charAt(0) !== "/" && (colonIndex === -1 || colonIndex > fixedUrlMatch.indexOf("/"))) {
//It is a relative URL, tack on the path prefix
} else {
}
//Collapse .. and .
if (parts[i] === ".") {
} else if (parts[i] === "..") {
i -= 1;
}
}
}
});
return importContents;
} catch (e) {
return fullMatch;
}
});
}
optimize = {
licenseCommentRegExp: /\/\*[\s\S]*?\*\//g,
/**
* Optimizes a file that contains JavaScript content. Optionally collects
* plugin resources mentioned in a file, and then passes the content
* through an minifier if one is specified via config.optimize.
*
* @param {String} fileName the name of the file to optimize
* @param {String} outFileName the name of the file to use for the
* saved optimized content.
* @param {Object} config the build config object.
* @param {String} [moduleName] the module name to use for the file.
* Used for plugin resource collection.
* @param {Array} [pluginCollector] storage for any plugin resources
* found.
*/
},
/**
* Optimizes a file that contains JavaScript content. Optionally collects
* plugin resources mentioned in a file, and then passes the content
* through an minifier if one is specified via config.optimize.
*
* @param {String} fileName the name of the file that matches the
* fileContents.
* @param {String} fileContents the string of JS to optimize.
* @param {String} [optimizerName] optional name of the optimizer to
* use. 'uglify' is default.
* @param {Boolean} [keepLines] whether to keep line returns in the optimization.
* @param {Object} [config] the build config object.
* @param {Array} [pluginCollector] storage for any plugin resources
* found.
*/
var licenseContents = '',
//Optimize the JS files if asked.
if (!optFunc) {
throw new Error('optimizer with name of "' +
'" not found for this environment');
}
if (config.preserveLicenseComments) {
//Pull out any license comments for prepending after optimization.
//Only keep the comments if they are license comments.
}
}
}
}
return fileContents;
},
/**
* Optimizes one CSS file, inlining @import calls, stripping comments, and
* optionally removes line returns.
* @param {String} fileName the path to the CSS file to optimize
* @param {String} outFileName the path to save the optimized file.
* @param {Object} config the config object with the optimizeCss and
* cssImportIgnore options.
*/
//Read in the file. Make sure we have a JS string.
//Do comment removal.
try {
startIndex = -1;
//Get rid of comments.
if (endIndex === -1) {
throw "Improper comment in CSS file: " + fileName;
}
fileContents = fileContents.substring(0, startIndex) + fileContents.substring(endIndex + 2, fileContents.length);
}
//Get rid of newlines.
} else {
//Remove multiple empty lines.
}
} catch (e) {
}
},
/**
* Optimizes CSS files, inlining @import calls, stripping comments, and
* optionally removes line returns.
* @param {String} startDir the path to the top level directory
* @param {Object} config the config object with the optimizeCss and
* cssImportIgnore options.
*/
var i, fileName,
if (fileList) {
}
}
}
},
optimizers: {
ast;
try {
} catch (e) {
}
return fileContents;
}
}
};
return optimize;
});
/**
* @license RequireJS Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
* Available via the MIT or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*
* This file patches require.js to communicate with the build system.
*/
/*jslint nomen: false, plusplus: false, regexp: false, strict: false */
/*global require: false, define: true */
//NOT asking for require as a dependency since the goal is to modify the
//global require below
var allowRun = true;
//This method should be called when the patches to require should take hold.
return function () {
if (!allowRun) {
return;
}
allowRun = false;
var layer,
/** Print out some extrs info about the module tree that caused the error. **/
var msg = '\nIn module tree:\n',
standardIndent = ' ',
i, j, mod;
msg += standardIndent;
}
}
}
throw err;
};
//Stored cached file contents for reuse in other layers.
require._cachedFileContents = {};
/** Reset state for each build layer pass. */
require._buildReset = function () {
//Clear up the existing context.
//Set up new context, so the layer object can hold onto it.
require({});
buildPathMap: {},
buildFileToModule: {},
buildFilePaths: [],
pathAdded: {},
modulesWithNames: {},
needsDefine: {},
existingRequireUrl: "",
};
//Return the previous context in case it is needed, like for
//the basic config object.
return oldContext;
};
/**
* Makes sure the URL is something that can be supported by the
* optimization tool.
* @param {String} url
* @returns {Boolean}
*/
//Ignore URLs with protocols, hosts or question marks, means either network
//access is needed to fetch it or it is too dynamic. Note that
//on Windows, full paths are used for some urls, which include
//the drive, like c:/something, so need to test for something other
//than just a colon.
};
//Override define() to catch modules that just define an object, so that
//a dummy define call is not put in the build file for them. They do
//not end up getting defined via require.execCb, so we need to catch them
//at the define call.
//This function signature does not have to be exact, just match what we
//are looking for.
}
};
//Add some utilities for plugins
};
//Adjust the URL if it was not transformed to use baseUrl.
}
return url;
}
//Override load so that the file paths can be collected.
/*jslint evil: true */
//Only handle urls that can be inlined, so that means avoiding some
//URLs like ones that require network access or may be too dynamic,
//like JSONP
//Adjust the URL if it was not transformed to use baseUrl.
//Save the module name to path and path to module name mappings.
//plugins need to have their source evaled as-is.
}
try {
} else {
//Load the file contents, process for conditionals, then
//evaluate it.
//If there is a read filter, run it now.
}
//Find out if the file contains a require() definition. Need to know
//this so we can inject plugins right after it, but before they are needed,
//and to make sure this file is first, so that define calls work.
//This situation mainly occurs when the build is done on top of the output
//of another build, where the first build may include require somewhere in it.
try {
}
} catch (e1) {
throw new Error('Parse error using UglifyJS ' +
}
//This is a loader plugin, check to see if it has a build extension,
//otherwise the plugin will act as the plugin builder too.
if (pluginBuilderMatch) {
//Load the plugin builder for the plugin contents.
}
}
//Parse out the require and define calls.
//Do this even for plugins in case they have their own
//dependencies that may be separate to how the pluginBuilder works.
try {
insertNeedsDefine: true,
});
}
} catch (e2) {
throw new Error('Parse error using UglifyJS ' +
}
}
if (contents) {
}
//Need to close out completion of this module
//so that listeners will get notified that it is available.
try {
} catch (e) {
//Track which module could not complete loading.
throw e;
}
} catch (eOuter) {
}
throw eOuter;
}
} else {
//With unsupported URLs still need to call completeLoad to
//finish loading.
}
//Mark the module loaded.
};
//Called when execManager runs for a dependency. Used to figure out
//what order of execution.
url;
//Ignore "fake" modules, usually generated by plugin code, since
//they do not map back to a real file to include in the optimizer,
//or it will be included, but in a different form.
return;
}
//A plugin.
//For plugins the real path is not knowable, use the name
//for both module to file and file to module mappings.
}
//If the url has not been added to the layer yet, and it
//is from an actual file that was loaded, add it now.
//Remember the list of dependencies for this layer.
}
}
};
//Called by output of the parse() function, when a file does not
//explicitly call define, probably just require, but the parse()
//function normalizes on define() for dependency mapping and file
//ordering works correctly.
};
//Marks module has having a name, and optionally executes the
//callback, but only if it meets certain criteria.
}
}
return undefined;
};
};
});
/**
* @license RequireJS Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
* Available via the MIT or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*jslint plusplus: false, regexp: false, strict: false */
/*global define: false, console: false */
var commonJs = {
//Set this to false in non-rhino environments. If rhino, then it uses
//otherwise, it will use a crude regexp approach to remove comments. The
//rhino way is more robust, but he regexp is more portable across environments.
useRhino: true,
//Set to false if you do not want this file to log. Useful in environments
//like node where you want the work to happen without noise.
useLog: true,
var fileList, i,
jsFileRegExp = /\.js$/,
//Get list of files to convert.
//Normalize on front slashes and make sure the paths do not end in a slash.
}
}
//Cycle through all the JS files and convert them.
if (commonJsPath === "convert") {
//A request just to convert one file.
} else {
}
}
} else {
//Handle JS files.
} else {
//Just copy the file over.
}
}
}
},
/**
* Removes the comments from a string.
*
* @param {String} fileContents
* @param {String} fileName mostly used for informative reasons if an error.
*
* @returns {String} a string of JS with comments removed.
*/
//Uglify's ast generation removes comments, so just convert to ast,
//then back to source code to get rid of comments.
},
/**
* Regexp for testing if there is already a require.def call in the file,
* in which case do not try to convert it.
*/
/**
* Regexp for testing if there is a require([]) or require(function(){})
* call, indicating the file is already in requirejs syntax.
*/
rjsRegExp: /require\s*\(\s*(\[|function)/,
/**
* Does the actual file conversion.
*
* @param {String} fileName the name of the file.
*
* @param {String} fileContents the contents of a file :)
*
* @param {Boolean} skipDeps if true, require("") dependencies
* will not be searched, but the contents will just be wrapped in the
* standard require, exports, module dependencies. Only usable in sync
* environments like Node where the require("") calls can be resolved on
* the fly.
*
* @returns {String} the converted contents
*/
convert: function (fileName, fileContents, skipDeps) {
//Strip out comments.
try {
var deps = [], depName, match,
//Remove comments
tempContents = commonJs.removeComments(fileContents, fileName);
//First see if the module is not already RequireJS-formatted.
if (commonJs.defRegExp.test(tempContents) || commonJs.rjsRegExp.test(tempContents)) {
return fileContents;
}
//Reset the regexp to start at beginning of file. Do this
//since the regexp is reused across files.
commonJs.depRegExp.lastIndex = 0;
if (!skipDeps) {
//Find dependencies in the code that was not in comments.
while ((match = commonJs.depRegExp.exec(tempContents))) {
depName = match[1];
if (depName) {
deps.push('"' + depName + '"');
}
}
}
//Construct the wrapper boilerplate.
(deps.length ? ', ' + deps.join(",") : '') + '], ' +
'function(require, exports, module) {\n' +
fileContents +
'\n});\n';
} catch (e) {
return fileContents;
}
return fileContents;
}
};
return commonJs;
});
/**
* @license Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
* Available via the MIT or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*jslint plusplus: true, nomen: true */
/*global define, require */
function (lang, logger, file, parse, optimize, pragma,
load, requirePatch) {
'use strict';
var build, buildBaseConfig,
endsWithSemiColonRegExp = /;\s*$/;
buildBaseConfig = {
appDir: "",
pragmas: {},
paths: {},
inlineText: true,
isBuild: true,
optimizeAllPluginResources: false,
findNestedDependencies: false,
preserveLicenseComments: true,
//By default, all files/directories are copied, unless
//they match this regexp, by default just excludes .folders
dirExclusionRegExp: file.dirExclusionRegExp
};
/**
* Some JS may not be valid if concatenated with other JS, in particular
* the style of omitting semicolons and rely on ASI. Add a semicolon in
* those cases.
*/
function addSemiColon(text) {
if (endsWithSemiColonRegExp.test(text)) {
return text;
} else {
return text + ";";
}
}
/**
* If the path looks like an URL, throw an error. This is to prevent
* people from using URLs with protocols in the build config, since
* the optimizer is not set up to do network access. However, be
* sure to allow absolute paths on Windows, like C:\directory.
*/
function disallowUrls(path) {
if ((path.indexOf('://') !== -1 || path.indexOf('//') === 0) && path !== 'empty:') {
throw new Error('Path is not supported: ' + path +
'\nOptimizer can only handle' +
' local paths. Download the locally if necessary' +
' and update the config to use a local path.\n' +
'http://requirejs.org/docs/errors.html#pathnotsupported');
}
}
function endsWithSlash(dirName) {
if (dirName.charAt(dirName.length - 1) !== "/") {
dirName += "/";
}
disallowUrls(dirName);
return dirName;
}
//Method used by plugin writeFile calls, defined up here to avoid
function makeWriteFile(anonDefRegExp, namespaceWithDot, layer) {
function writeFile(name, contents) {
logger.trace('Saving plugin-optimized file: ' + name);
file.saveUtf8File(name, contents);
}
writeFile.asModule = function (moduleName, fileName, contents) {
writeFile(fileName,
build.toTransport(anonDefRegExp, namespaceWithDot, moduleName, fileName, contents, layer));
};
return writeFile;
}
/**
* Main API entry point into the build. The args argument can either be
* an array of arguments (like the onese passed on a command-line),
* or it can be a JavaScript object that has the format of a build profile
* file.
*
* If it is an object, then in addition to the normal properties allowed in
* a build profile file, the object should contain one other property:
*
* that is the file path to a build profile that contains the rest
* of the build profile directives.
*
* This function does not return a status, it should throw an error if
* there is a problem completing the build.
*/
build = function (args) {
var buildFile, cmdConfig;
if (!args || lang.isArray(args)) {
if (!args || args.length < 1) {
"where buildProfile.js is the name of the build file (see example.build.js for hints on how to make a build file).");
return undefined;
}
//Next args can include a build file path as well as other build args.
//build file path comes first. If it does not contain an = then it is
//a build file path. Otherwise, just all build args.
if (args[0].indexOf("=") === -1) {
buildFile = args[0];
args.splice(0, 1);
}
//Remaining args are options to the build
cmdConfig = build.convertArrayToObject(args);
cmdConfig.buildFile = buildFile;
} else {
cmdConfig = args;
}
return build._run(cmdConfig);
};
build._run = function (cmdConfig) {
var buildFileContents = "",
pluginCollector = {},
buildPaths, fileName, fileNames,
prop, paths, i,
baseConfig, config,
modules, builtModule, srcPath, buildContext,
destPath, moduleName, moduleMap, parentModuleMap, context,
resources, resource, pluginProcessed = {}, plugin;
//Can now run the patches to require.js to allow it to be used for
//build generation. Do it here instead of at the top of the module
//because we want normal require behavior to load the build tool
//then want to switch to build mode.
requirePatch();
config = build.createConfig(cmdConfig);
paths = config.paths;
if (config.logLevel) {
logger.logLevel(config.logLevel);
}
if (!config.out && !config.cssIn) {
//This is not just a one-off file build but a full build profile, with
//lots of files to process.
//First copy all the baseUrl content
file.copyDir((config.appDir || config.baseUrl), config.dir, /\w/, true);
//Adjust baseUrl if config.appDir is in play, and set up build output paths.
buildPaths = {};
if (config.appDir) {
//All the paths should be inside the appDir, so just adjust
//the paths to use the dirBaseUrl
for (prop in paths) {
if (paths.hasOwnProperty(prop)) {
buildPaths[prop] = paths[prop].replace(config.baseUrl, config.dirBaseUrl);
}
}
} else {
//If no appDir, then make sure to copy the other paths to this directory.
for (prop in paths) {
if (paths.hasOwnProperty(prop)) {
//Set up build path for each path prefix.
buildPaths[prop] = paths[prop] === 'empty:' ? 'empty:' : prop.replace(/\./g, "/");
//Make sure source path is fully formed with baseUrl,
//if it is a relative URL.
srcPath = paths[prop];
if (srcPath.indexOf('/') !== 0 && srcPath.indexOf(':') === -1) {
srcPath = config.baseUrl + srcPath;
}
destPath = config.dirBaseUrl + buildPaths[prop];
//Skip empty: paths
if (srcPath !== 'empty:') {
//If the srcPath is a directory, copy the whole directory.
if (file.exists(srcPath) && file.isDirectory(srcPath)) {
//Copy files to build area. Copy all files (the /\w/ regexp)
file.copyDir(srcPath, destPath, /\w/, true);
} else {
//Try a .js extension
srcPath += '.js';
destPath += '.js';
file.copyFile(srcPath, destPath);
}
}
}
}
}
}
//Figure out source file location for each module layer. Do this by seeding require
//with source area configuration. This is needed so that later the module layers
//can be manually copied over to the source area, since the build may be
//require multiple times and the above copyDir call only copies newer files.
require({
baseUrl: config.baseUrl,
paths: paths,
packagePaths: config.packagePaths,
packages: config.packages
});
buildContext = require.s.contexts._;
modules = config.modules;
if (modules) {
modules.forEach(function (module) {
if (module.name) {
module._sourcePath = buildContext.nameToUrl(module.name);
//If the module does not exist, and this is not a "new" module layer,
//it is not a plugin-loaded resource, then throw an error.
if (!file.exists(module._sourcePath) && !module.create &&
module.name.indexOf('!') === -1) {
}
}
});
}
if (config.out) {
//Just set up the _buildPath for the module layer.
require(config);
if (!config.cssIn) {
config.modules[0]._buildPath = config.out;
}
} else if (!config.cssIn) {
//Now set up the config for require to use the build area, and calculate the
//build file locations. Pass along any config info too.
baseConfig = {
baseUrl: config.dirBaseUrl,
paths: buildPaths
};
lang.mixin(baseConfig, config);
require(baseConfig);
if (modules) {
modules.forEach(function (module) {
if (module.name) {
module._buildPath = buildContext.nameToUrl(module.name, null);
if (!module.create) {
file.copyFile(module._sourcePath, module._buildPath);
}
}
});
}
}
//Run CSS optimizations before doing JS module tracing, to allow
//things like text loader plugins loading CSS to get the optimized
//CSS.
optimize.css(config.dir, config);
}
if (modules) {
//For each module layer, call require to calculate dependencies.
modules.forEach(function (module) {
module.layer = build.traceDependencies(module, config);
});
//Now build up shadow layers for anything that should be excluded.
//Do this after tracing dependencies for each module, in case one
//of those modules end up being one of the excluded values.
modules.forEach(function (module) {
if (module.exclude) {
module.excludeLayers = [];
module.exclude.forEach(function (exclude, i) {
//See if it is already in the list of modules.
//If not trace dependencies for it.
module.excludeLayers[i] = build.findBuildModule(exclude, modules) ||
{layer: build.traceDependencies({name: exclude}, config)};
});
}
});
modules.forEach(function (module) {
if (module.exclude) {
//module.exclude is an array of module names. For each one,
//get the nested dependencies for it via a matching entry
//in the module.excludeLayers array.
module.exclude.forEach(function (excludeModule, i) {
var excludeLayer = module.excludeLayers[i].layer, map = excludeLayer.buildPathMap, prop;
for (prop in map) {
if (map.hasOwnProperty(prop)) {
build.removeModulePath(prop, map[prop], module.layer);
}
}
});
}
if (module.excludeShallow) {
//module.excludeShallow is an array of module names.
//shallow exclusions are just that module itself, and not
//its nested dependencies.
module.excludeShallow.forEach(function (excludeShallowModule) {
var path = module.layer.buildPathMap[excludeShallowModule];
if (path) {
build.removeModulePath(excludeShallowModule, path, module.layer);
}
});
}
//Flatten them and collect the build output for each module.
builtModule = build.flattenModule(module, module.layer, config);
//Save it to a temp file for now, in case there are other layers that
//contain optimized content that should not be included in later
//layer optimizations. See issue #56.
file.saveUtf8File(module._buildPath + '-temp', builtModule.text);
buildFileContents += builtModule.buildText;
});
//Now move the build layers to their final position.
modules.forEach(function (module) {
var finalPath = module._buildPath;
if (file.exists(finalPath)) {
file.deleteFile(finalPath);
}
file.renameFile(finalPath + '-temp', finalPath);
});
}
//Do other optimizations.
if (config.out && !config.cssIn) {
//Just need to worry about one JS file.
fileName = config.modules[0]._buildPath;
optimize.jsFile(fileName, fileName, config);
} else if (!config.cssIn) {
//Normal optimizations across modules.
//JS optimizations.
fileNames = file.getFilteredFileList(config.dir, /\.js$/, true);
for (i = 0; (fileName = fileNames[i]); i++) {
//Generate the module name from the config.dir root.
moduleName = fileName.replace(config.dir, '');
//Get rid of the extension
moduleName = moduleName.substring(0, moduleName.length - 3);
optimize.jsFile(fileName, fileName, config, moduleName, pluginCollector);
}
//Normalize all the plugin resources.
context = require.s.contexts._;
for (moduleName in pluginCollector) {
if (pluginCollector.hasOwnProperty(moduleName)) {
parentModuleMap = context.makeModuleMap(moduleName);
resources = pluginCollector[moduleName];
for (i = 0; (resource = resources[i]); i++) {
moduleMap = context.makeModuleMap(resource, parentModuleMap);
if (!context.plugins[moduleMap.prefix]) {
//Set the value in context.plugins so it
//will be evaluated as a full plugin.
context.plugins[moduleMap.prefix] = true;
//Do not bother if the plugin is not available.
if (!file.exists(require.toUrl(moduleMap.prefix + '.js'))) {
continue;
}
//Rely on the require in the build environment
//to be synchronous
context.require([moduleMap.prefix]);
//Now that the plugin is loaded, redo the moduleMap
//since the plugin will need to normalize part of the path.
moduleMap = context.makeModuleMap(resource, parentModuleMap);
}
//Only bother with plugin resources that can be handled
//processed by the plugin, via support of the writeFile
//method.
if (!pluginProcessed[moduleMap.fullName]) {
//Only do the work if the plugin was really loaded.
//Using an internal access because the file may
//not really be loaded.
plugin = context.defined[moduleMap.prefix];
if (plugin && plugin.writeFile) {
plugin.writeFile(
moduleMap.prefix,
moduleMap.name,
require,
makeWriteFile(
config.anonDefRegExp,
config.namespaceWithDot
),
);
}
pluginProcessed[moduleMap.fullName] = true;
}
}
}
}
//console.log('PLUGIN COLLECTOR: ' + JSON.stringify(pluginCollector, null, " "));
//All module layers are done, write out the build.txt file.
}
//If just have one CSS file to optimize, do that here.
if (config.cssIn) {
optimize.cssFile(config.cssIn, config.out, config);
}
//Print out what was built into which layers.
if (buildFileContents) {
logger.info(buildFileContents);
return buildFileContents;
}
return '';
};
/**
* name=value splitting has already happened.
*/
function stringDotToObj(result, prop, name, value) {
if (!result[prop]) {
result[prop] = {};
}
name = name.substring((prop + '.').length, name.length);
result[prop][name] = value;
}
//Used by convertArrayToObject to convert some things from prop.name=value
//to a prop: { name: value}
build.dotProps = [
'paths.',
'wrap.',
'pragmas.',
'pragmasOnSave.',
'has.',
'hasOnSave.',
'wrap.',
'uglify.',
'closure.'
];
build.hasDotPropMatch = function (prop) {
return build.dotProps.some(function (dotProp) {
return prop.indexOf(dotProp) === 0;
});
};
/**
* into an object, where the properties on the object are the names in the array.
* Also converts the strings "true" and "false" to booleans for the values.
* arrays.
* @param {Array} ary
*/
build.convertArrayToObject = function (ary) {
var result = {}, i, separatorIndex, prop, value,
needArray = {
};
for (i = 0; i < ary.length; i++) {
separatorIndex = ary[i].indexOf("=");
if (separatorIndex === -1) {
}
value = ary[i].substring(separatorIndex + 1, ary[i].length);
if (value === "true") {
value = true;
} else if (value === "false") {
value = false;
}
prop = ary[i].substring(0, separatorIndex);
//Convert to array if necessary
if (needArray[prop]) {
value = value.split(",");
}
if (build.hasDotPropMatch(prop)) {
stringDotToObj(result, prop.split('.')[0], prop, value);
} else {
result[prop] = value;
}
}
return result; //Object
};
build.makeAbsPath = function (path, absFilePath) {
//Add abspath if necessary. If path starts with a slash or has a colon,
//then already is an abolute path.
if (path.indexOf('/') !== 0 && path.indexOf(':') === -1) {
path = absFilePath +
(absFilePath.charAt(absFilePath.length - 1) === '/' ? '' : '/') +
path;
path = file.normalize(path);
}
return path.replace(lang.backSlashRegExp, '/');
};
build.makeAbsObject = function (props, obj, absFilePath) {
var i, prop;
if (obj) {
for (i = 0; (prop = props[i]); i++) {
if (obj.hasOwnProperty(prop)) {
obj[prop] = build.makeAbsPath(obj[prop], absFilePath);
}
}
}
};
/**
* For any path in a possible config, make it absolute relative
* to the absFilePath passed in.
*/
build.makeAbsConfig = function (config, absFilePath) {
var props, prop, i;
for (i = 0; (prop = props[i]); i++) {
if (config[prop]) {
//Add abspath if necessary, make sure these paths end in
//slashes
config.originalBaseUrl = config.baseUrl;
if (config.appDir) {
//If baseUrl with an appDir, the baseUrl is relative to
//the appDir, *not* the absFilePath. appDir and dir are
//made absolute before baseUrl, so this will work.
config.baseUrl = build.makeAbsPath(config.originalBaseUrl, config.appDir);
} else {
//The dir output baseUrl is same as regular baseUrl, both
//relative to the absFilePath.
config.baseUrl = build.makeAbsPath(config[prop], absFilePath);
}
} else {
config[prop] = build.makeAbsPath(config[prop], absFilePath);
}
config[prop] = endsWithSlash(config[prop]);
}
}
//Do not allow URLs for paths resources.
if (config.paths) {
for (prop in config.paths) {
if (config.paths.hasOwnProperty(prop)) {
config.paths[prop] = build.makeAbsPath(config.paths[prop],
(config.baseUrl || absFilePath));
}
}
}
};
build.nestedMix = {
paths: true,
has: true,
hasOnSave: true,
pragmas: true,
pragmasOnSave: true
};
/**
* Mixes additional source config into target config, and merges some
* nested config, like paths, correctly.
*/
function mixConfig(target, source) {
var prop, value;
for (prop in source) {
if (source.hasOwnProperty(prop)) {
//If the value of the property is a plain object, then
//allow a one-level-deep mixing of it.
value = source[prop];
if (typeof value === 'object' && value &&
!lang.isArray(value) && !lang.isFunction(value) &&
!lang.isRegExp(value)) {
target[prop] = lang.mixin({}, target[prop], value, true);
} else {
target[prop] = value;
}
}
}
}
/**
* Creates a config object for an optimization build.
* It will also read the build profile if it is available, to create
* the configuration.
*
* @param {Object} cfg config options that take priority
* over defaults and ones in the build file. These options could
* be from a command line, for instance.
*
* @param {Object} the created config object.
*/
build.createConfig = function (cfg) {
/*jslint evil: true */
var config = {}, buildFileContents, buildFileConfig, mainConfig,
mainConfigFile, prop, buildFile, absFilePath;
//Make sure all paths are relative to current directory.
absFilePath = file.absPath('.');
build.makeAbsConfig(cfg, absFilePath);
build.makeAbsConfig(buildBaseConfig, absFilePath);
lang.mixin(config, buildBaseConfig);
lang.mixin(config, cfg, true);
if (config.buildFile) {
//A build file exists, load it to get more config.
buildFile = file.absPath(config.buildFile);
//Find the build file, and make sure it exists, if this is a build
//that has a build profile, and not just command line args with an in=path
if (!file.exists(buildFile)) {
}
absFilePath = config.baseUrl = file.absPath(file.parent(buildFile));
//Load build file options.
buildFileContents = file.readFile(buildFile);
try {
buildFileConfig = eval("(" + buildFileContents + ")");
build.makeAbsConfig(buildFileConfig, absFilePath);
if (!buildFileConfig.out && !buildFileConfig.dir) {
}
} catch (e) {
}
}
mainConfigFile = config.mainConfigFile || (buildFileConfig && buildFileConfig.mainConfigFile);
if (mainConfigFile) {
mainConfigFile = build.makeAbsPath(mainConfigFile, absFilePath);
try {
mainConfig = parse.findConfig(mainConfigFile, file.readFile(mainConfigFile));
} catch (configError) {
throw new Error('The config in mainConfigFile ' +
mainConfigFile +
' cannot be used because it cannot be evaluated' +
' correctly while running in the optimizer. Try only' +
' using a config that is also valid JSON, or do not use' +
' mainConfigFile and instead copy the config values needed' +
' into a build file or command line arguments given to the optimizer.');
}
if (mainConfig) {
//If no baseUrl, then use the directory holding the main config.
if (!mainConfig.baseUrl) {
mainConfig.baseUrl = mainConfigFile.substring(0, mainConfigFile.lastIndexOf('/'));
}
build.makeAbsConfig(mainConfig, mainConfigFile);
mixConfig(config, mainConfig);
}
}
//Mix in build file config, but only after mainConfig has been mixed in.
if (buildFileConfig) {
mixConfig(config, buildFileConfig);
}
//Re-apply the override config values. Command line
//args should take precedence over build file values.
mixConfig(config, cfg);
//Set final output dir
if (config.appDir) {
config.dirBaseUrl = build.makeAbsPath(config.originalBaseUrl, config.dir);
} else {
config.dirBaseUrl = config.dir || config.baseUrl;
}
//Make sure dirBaseUrl ends in a slash, since it is
//concatenated with other strings.
config.dirBaseUrl = endsWithSlash(config.dirBaseUrl);
}
//Check for errors in config
if (config.cssIn && !config.out) {
}
if (!config.cssIn && !config.baseUrl) {
}
if (!config.out && !config.dir) {
}
if (config.appDir && config.out) {
'instead. appDir is used to copy whole projects, ' +
}
if (config.out && config.dir) {
' or baseUrl directories optimized.');
}
if ((config.name || config.include) && !config.modules) {
//Just need to build one file, but may be part of a whole appDir/
//baseUrl copy, but specified on the command line, so cannot do
//the modules array setup. So create a modules section in that
//case.
config.modules = [
{
name: config.name,
out: config.out,
include: config.include,
exclude: config.exclude,
excludeShallow: config.excludeShallow
}
];
}
if (config.out && !config.cssIn) {
//Just one file to optimize.
//Does not have a build file, so set up some defaults.
//Optimizing CSS should not be allowed, unless explicitly
//asked for on command line. In that case the only task is
//to optimize a CSS file.
if (!cfg.optimizeCss) {
}
}
//Do not allow URLs for paths resources.
if (config.paths) {
for (prop in config.paths) {
if (config.paths.hasOwnProperty(prop)) {
disallowUrls(config.paths[prop]);
}
}
}
//Get any wrap text.
try {
if (config.wrap) {
if (config.wrap === true) {
//Use default values.
config.wrap = {
start: '(function () {',
end: '}());'
};
} else {
config.wrap.start = config.wrap.start ||
file.readFile(build.makeAbsPath(config.wrap.startFile, absFilePath));
config.wrap.end = config.wrap.end ||
file.readFile(build.makeAbsPath(config.wrap.endFile, absFilePath));
}
}
} catch (wrapError) {
}
//Set up proper info for namespaces and using namespaces in transport
//wrappings.
config.namespaceWithDot = config.namespace ? config.namespace + '.' : '';
config.anonDefRegExp = build.makeAnonDefRegExp(config.namespaceWithDot);
//Do final input verification
if (config.context) {
' in a build. It should only be used in web' +
' pages.');
}
//Set file.fileExclusionRegExp if desired
if ('fileExclusionRegExp' in config) {
file.exclusionRegExp = new RegExp(config.fileExclusionRegExp);
} else {
file.exclusionRegExp = config.fileExclusionRegExp;
}
} else if ('dirExclusionRegExp' in config) {
//Set file.dirExclusionRegExp if desired, this is the old
//name for fileExclusionRegExp before 1.0.2. Support for backwards
//compatibility
file.exclusionRegExp = config.dirExclusionRegExp;
}
return config;
};
/**
* or returns null.
* @param {String} moduleName
* @param {Array} modules
* @returns {Object} the module object from the build profile, or null.
*/
build.findBuildModule = function (moduleName, modules) {
var i, module;
for (i = 0; (module = modules[i]); i++) {
if (module.name === moduleName) {
return module;
}
}
return null;
};
/**
* Removes a module name and path from a layer, if it is supposed to be
* excluded from the layer.
* @param {String} moduleName the name of the module
* @param {String} path the file path for the module
*/
build.removeModulePath = function (module, path, layer) {
var index = layer.buildFilePaths.indexOf(path);
if (index !== -1) {
layer.buildFilePaths.splice(index, 1);
}
//Take it out of the specified modules. Specified modules are mostly
//used to find require modifiers.
delete layer.specified[module];
};
/**
* Uses the module build config object to trace the dependencies for the
* given module.
*
* @param {Object} module the module object from the build config info.
* @param {Object} the build config object.
*
* @returns {Object} layer information about what paths and modules should
* be in the flattened module.
*/
build.traceDependencies = function (module, config) {
var include, override, layer, context, baseConfig, oldContext;
//Reset some state set up in requirePatch.js, and clean up require's
//current context.
oldContext = require._buildReset();
//Grab the reset layer and context after the reset, but keep the
//old config to reuse in the new context.
baseConfig = oldContext.config;
layer = require._layer;
context = layer.context;
//Put back basic config, use a fresh object for it.
//WARNING: probably not robust for paths and packages/packagePaths,
//since those property's objects can be modified. But for basic
//config clone it works out.
require(lang.delegate(baseConfig));
include = module.name && !module.create ? [module.name] : [];
if (module.include) {
include = include.concat(module.include);
}
//If there are overrides to basic config, set that up now.;
if (module.override) {
override = lang.delegate(baseConfig);
lang.mixin(override, module.override, true);
require(override);
}
//Figure out module layer dependencies by calling require to do the work.
require(include);
//Pull out the layer dependencies.
layer.specified = context.specified;
//Reset config
if (module.override) {
require(baseConfig);
}
return layer;
};
/**
* Uses the module build config object to create an flattened version
* of the module, with deep dependencies included.
*
* @param {Object} module the module object from the build config info.
*
* @param {Object} layer the layer object returned from build.traceDependencies.
*
* @param {Object} the build config object.
*
* included in the flattened module text.
*/
build.flattenModule = function (module, layer, config) {
var buildFileContents = "",
namespace = config.namespace ? config.namespace + '.' : '',
context = layer.context,
anonDefRegExp = config.anonDefRegExp,
path, reqIndex, fileContents, currContents,
i, moduleName,
parts, builder, writeApi;
//Use override settings, particularly for pragmas
if (module.override) {
config = lang.delegate(config);
lang.mixin(config, module.override, true);
}
//Start build output for the module.
buildFileContents += "\n" +
(config.dir ? module._buildPath.replace(config.dir, "") : module._buildPath) +
"\n----------------\n";
//If there was an existing file with require in it, hoist to the top.
if (layer.existingRequireUrl) {
reqIndex = layer.buildFilePaths.indexOf(layer.existingRequireUrl);
if (reqIndex !== -1) {
layer.buildFilePaths.splice(reqIndex, 1);
layer.buildFilePaths.unshift(layer.existingRequireUrl);
}
}
//Write the built module to disk, and build up the build output.
fileContents = "";
for (i = 0; (path = layer.buildFilePaths[i]); i++) {
moduleName = layer.buildFileToModule[path];
//Figure out if the module is a result of a build plugin, and if so,
//then delegate to that plugin.
parts = context.makeModuleMap(moduleName);
builder = parts.prefix && context.defined[parts.prefix];
if (builder) {
if (builder.write) {
writeApi = function (input) {
fileContents += "\n" + addSemiColon(input);
if (config.onBuildWrite) {
fileContents = config.onBuildWrite(moduleName, path, fileContents);
}
};
writeApi.asModule = function (moduleName, input) {
fileContents += "\n" +
addSemiColon(
build.toTransport(anonDefRegExp, namespace, moduleName, path, input, layer));
if (config.onBuildWrite) {
fileContents = config.onBuildWrite(moduleName, path, fileContents);
}
};
builder.write(parts.prefix, parts.name, writeApi);
}
} else {
currContents = file.readFile(path);
if (config.onBuildRead) {
currContents = config.onBuildRead(moduleName, path, currContents);
}
if (config.namespace) {
currContents = pragma.namespace(currContents, config.namespace);
}
currContents = build.toTransport(anonDefRegExp, namespace, moduleName, path, currContents, layer);
if (config.onBuildWrite) {
currContents = config.onBuildWrite(moduleName, path, currContents);
}
//Semicolon is for files that are not well formed when
//concatenated with other content.
fileContents += "\n" + addSemiColon(currContents);
}
buildFileContents += path.replace(config.dir, "") + "\n";
//Some files may not have declared a require module, and if so,
//put in a placeholder call so the require does not try to load them
//after the module is processed.
//If we have a name, but no defined module, then add in the placeholder.
if (moduleName && !layer.modulesWithNames[moduleName] && !config.skipModuleInsertion) {
//If including jquery, register the module correctly, otherwise
//register an empty function. For jquery, make sure jQuery is
//a real object, and perhaps not some other file mapping, like
//to zepto.
if (moduleName === 'jquery') {
fileContents += '\n(function () {\n' +
namespace +
'}());\n';
} else {
fileContents += '\n' + namespace + 'define("' + moduleName + '", function(){});\n';
}
}
}
return {
text: config.wrap ?
config.wrap.start + fileContents + config.wrap.end :
fileContents,
buildText: buildFileContents
};
};
/**
* Creates the regexp to find anonymous defines.
* @param {String} namespace an optional namespace to use. The namespace
* should *include* a trailing dot. So a valid value would be 'foo.'
* @returns {RegExp}
*/
build.makeAnonDefRegExp = function (namespace) {
//This regexp is not bullet-proof, and it has one optional part to
//avoid issues with some Dojo transition modules that use a
//define(\n//begin v1.x content
//for a comment.
return new RegExp('(^|[^\\.])(' + (namespace || '').replace(/\./g, '\\.') +
'define|define)\\s*\\(\\s*(\\/\\/[^\\n\\r]*[\\r\\n])?(\\[|function|[\\w\\d_\\-\\$]+\\s*\\)|\\{|["\']([^"\']+)["\'])(\\s*,\\s*f)?');
};
build.leadingCommaRegExp = /^\s*,/;
//If anonymous module, insert the module name.
return contents.replace(anonDefRegExp, function (match, start, callName, possibleComment, suffix, namedModule, namedFuncStart) {
//A named module with either listed dependencies or an object
//literal for a value. Skip it. If named module, only want ones
//whose next argument is a function literal to scan for
//require('') dependecies.
if (namedModule && !namedFuncStart) {
return match;
}
//Only mark this module as having a name if not a named module,
//or if a named module and the name matches expectations.
}
var deps = null;
//Look for CommonJS require calls inside the function if this is
//an anonymous define call that just has a function registered.
//Also look if a named define function but has a factory function
//as the second arg that should be scanned for dependencies.
});
} else {
deps = [];
}
}
});
};
return build;
});
}
/**
* Sets the default baseUrl for requirejs to be directory of top level
* script.
*/
function setBaseUrl(fileName) {
//Use the file name's directory as the baseUrl if available.
}
}
//If in Node, and included via a require('requirejs'), just export and
//THROW IT ON THE GROUND!
//Create a method that will run the optimzer given an object
//config.
if (!loadedOptimizedLib) {
loadLib();
loadedOptimizedLib = true;
}
//Create the function that will be called once build modules
//have been loaded.
//Make sure config has a log level, and if not,
//make it "silent" by default.
//Reset build internals on each run.
if (callback) {
}
};
//Enable execution of this callback in a build setting.
//Normally, once requirePatch is run, by default it will
//not execute callbacks, unless this property is set on
//the callback.
runBuild.__requireJsBuild = true;
context: 'build'
};
if (!callback) {
contextName = 'uselib';
}
if (!useLibLoaded[contextName]) {
loadLib();
useLibLoaded[contextName] = true;
}
});
req(['build'], function () {
});
}
};
return;
}
if (commandOption === 'o') {
//Do the optimizer work.
loadLib();
/**
* @license Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
* Available via the MIT or new BSD license.
* see: http://github.com/jrburke/requirejs for details
*/
/*
* Create a build.js file that has the build options you want and pass that
* build file to this file to do the build. See example.build.js for more information.
*/
/*jslint strict: false, nomen: false */
/*global require: false */
require({
//Use a separate context than the default context so that the
//build can use the default context.
context: 'build',
catchError: {
define: true
}
});
} else if (commandOption === 'v') {
} else if (commandOption === 'convert') {
loadLib();
return;
}
});
} else {
//Just run an app
//Load the bundled libraries for use in the app.
if (commandOption === 'lib') {
loadLib();
}
} else {
showHelp();
}
}