aboutsummaryrefslogtreecommitdiffstats
path: root/build
diff options
context:
space:
mode:
authorTimmy Willison <timmywillisn@gmail.com>2013-08-15 14:15:49 -0400
committerTimmy Willison <timmywillisn@gmail.com>2013-08-15 14:15:49 -0400
commit6318ae6ab90d4b450dfadf32ab95fe52ed6331cb (patch)
tree50b247fed8569e909e380b281e9145bd1458a39e /build
parent7627b8b6d9ef6e57dbd20a55b946bd1991c1223e (diff)
downloadjquery-6318ae6ab90d4b450dfadf32ab95fe52ed6331cb.tar.gz
jquery-6318ae6ab90d4b450dfadf32ab95fe52ed6331cb.zip
AMD-ify jQuery sourcegit s! Woo! Fixes #14113, #14163.
Diffstat (limited to 'build')
-rw-r--r--build/build.js238
-rw-r--r--build/r.js25762
2 files changed, 26000 insertions, 0 deletions
diff --git a/build/build.js b/build/build.js
new file mode 100644
index 000000000..249b27924
--- /dev/null
+++ b/build/build.js
@@ -0,0 +1,238 @@
+/**
+ * Special concat/build task to handle various jQuery build requirements
+ * Concats AMD modules, removes their definitions, and includes/excludes specified modules
+ */
+
+module.exports = function( grunt ) {
+
+ var fs = require("fs"),
+ srcFolder = __dirname + "/../src/",
+ rdefineEnd = /\}\);[^}\w]*$/,
+ // This is temporary until the skipSemiColonInsertion option makes it to NPM
+ requirejs = require("./r"),
+ config = {
+ baseUrl: "src",
+ name: "jquery",
+ out: "dist/jquery.js",
+ // We have multiple minify steps
+ optimize: "none",
+ skipSemiColonInsertion: true,
+ wrap: {
+ startFile: "src/intro.js",
+ endFile: "src/outro.js"
+ },
+ onBuildWrite: convert
+ };
+
+ /**
+ * Strip all definitions generated by requirejs
+ * Convert "var" modules to var declarations
+ * "var module" means the module only contains a return statement that should be converted to a var declaration
+ * This is indicated by including the file in any "var" folder
+ * @param {String} name
+ * @param {String} path
+ * @param {String} contents The contents to be written (including their AMD wrappers)
+ */
+ function convert( name, path, contents ) {
+ // Convert var modules
+ if ( /\/var\//.test( path ) ) {
+ contents = contents
+ .replace( /define\([\w\W]*?return/, "var " + (/var\/([\w-]+)/.exec(name)[1]) + " =" )
+ .replace( rdefineEnd, "" );
+
+ // Sizzle treatment
+ } else if ( /\/sizzle$/.test( name ) ) {
+ contents = "var Sizzle =\n" + contents
+ // Remove EXPOSE lines from Sizzle
+ .replace( /\/\/\s*EXPOSE[\w\W]*\/\/\s*EXPOSE/, "return Sizzle;" );
+
+ } else {
+
+ // Ignore jQuery's return statement (the only necessary one)
+ if ( name !== "jquery" ) {
+ contents = contents
+ .replace( /return\s+[^\}]+(\}\);[^\w\}]*)$/, "$1" );
+ }
+
+ // Remove define wrappers, closure ends, and empty declarations
+ contents = contents
+ .replace( /define\([^{]*?{/, "" )
+ .replace( rdefineEnd, "" )
+ // Remove empty definitions
+ .replace( /define\(\[[^\]]+\]\)[\W\n]+$/, "" );
+ }
+ return contents;
+ }
+
+ grunt.registerMultiTask(
+ "build",
+ "Concatenate source, remove sub AMD definitions, (include/exclude modules with +/- flags), embed date/version",
+ function() {
+ var flag, index,
+ done = this.async(),
+ flags = this.flags,
+ name = this.data.dest,
+ minimum = this.data.minimum,
+ removeWith = this.data.removeWith,
+ excluded = [],
+ included = [],
+ version = grunt.config( "pkg.version" ),
+ /**
+ * Recursively calls the excluder to remove on all modules in the list
+ * @param {Array} list
+ * @param {String} [prepend] Prepend this to the module name. Indicates we're walking a directory
+ */
+ excludeList = function( list, prepend ) {
+ if ( list ) {
+ prepend = prepend ? prepend + "/" : "";
+ list.forEach(function( module ) {
+ // Exclude var modules as well
+ if ( module === "var" ) {
+ excludeList( fs.readdirSync( srcFolder + prepend + module ), prepend + module );
+ return;
+ }
+ if ( prepend ) {
+ // Skip if this is not a js file and we're walking files in a dir
+ if ( !(module = /([\w-\/]+)\.js$/.exec( module )) ) {
+ return;
+ }
+ // Prepend folder name if passed
+ // Remove .js extension
+ module = prepend + module[1];
+ }
+
+ // Avoid infinite recursion
+ if ( excluded.indexOf( module ) === -1 ) {
+ excluder( "-" + module );
+ }
+ });
+ }
+ },
+ /**
+ * Adds the specified module to the excluded or included list, depending on the flag
+ * @param {String} flag A module path relative to the src directory starting with + or - to indicate whether it should included or excluded
+ */
+ excluder = function( flag ) {
+ var m = /^(\+|\-|)([\w\/-]+)$/.exec( flag ),
+ exclude = m[1] === "-",
+ module = m[2];
+
+ if ( exclude ) {
+ // Can't exclude certain modules
+ if ( minimum.indexOf( module ) === -1 ) {
+ // Add to excluded
+ if ( excluded.indexOf( module ) === -1 ) {
+ grunt.log.writeln( flag );
+ excluded.push( module );
+ // Exclude all files in the folder of the same name
+ // These are the removable dependencies
+ // It's fine if the directory is not there
+ try {
+ excludeList( fs.readdirSync( srcFolder + module ), module );
+ } catch( e ) {
+ grunt.verbose.writeln( e );
+ }
+ }
+ // Check removeWith list
+ excludeList( removeWith[ module ] );
+ } else {
+ grunt.log.error( "Module \"" + module + "\" is a mimimum requirement.");
+ if ( module === "selector" ) {
+ grunt.log.error( "If you meant to replace Sizzle, use -sizzle instead." );
+ }
+ }
+ } else {
+ grunt.log.writeln( flag );
+ included.push( module );
+ }
+ };
+
+ // append commit id to version
+ if ( process.env.COMMIT ) {
+ version += " " + process.env.COMMIT;
+ }
+
+ // figure out which files to exclude based on these rules in this order:
+ // dependency explicit exclude
+ // > explicit exclude
+ // > explicit include
+ // > dependency implicit exclude
+ // > implicit exclude
+ // examples:
+ // * none (implicit exclude)
+ // *:* all (implicit include)
+ // *:*:-css all except css and dependents (explicit > implicit)
+ // *:*:-css:+effects same (excludes effects because explicit include is trumped by explicit exclude of dependency)
+ // *:+effects none except effects and its dependencies (explicit include trumps implicit exclude of dependency)
+ for ( flag in flags ) {
+ if ( flag !== "*" ) {
+ excluder( flag );
+ }
+ }
+
+ // Handle Sizzle exclusion
+ // Replace with selector-native
+ if ( (index = excluded.indexOf("sizzle")) > -1 ) {
+ config.rawText = {
+ selector: "define(['./selector-native']);"
+ };
+ excluded.splice( index, 1 );
+ }
+
+ grunt.verbose.writeflags( excluded, "Excluded" );
+ grunt.verbose.writeflags( included, "Included" );
+
+ // append excluded modules to version
+ if ( excluded.length ) {
+ version += " -" + excluded.join( ",-" );
+ // set pkg.version to version with excludes, so minified file picks it up
+ grunt.config.set( "pkg.version", version );
+ grunt.verbose.writeln( "Version changed to " + version );
+ // Have to use shallow or core will get excluded since it is a dependency
+ config.excludeShallow = excluded;
+ }
+ config.include = included;
+
+ /**
+ * Handle Final output from the optimizer
+ * @param {String} compiled
+ */
+ config.out = function( compiled ) {
+ compiled = compiled
+ // Embed Version
+ .replace( /@VERSION/g, version )
+ // Embed Date
+ // yyyy-mm-ddThh:mmZ
+ .replace( /@DATE/g, ( new Date() ).toISOString().replace( /:\d+\.\d+Z$/, "Z" ) );
+
+ // Write concatenated source to file
+ grunt.file.write( name, compiled );
+ };
+
+ // Trace dependencies and concatenate files
+ requirejs.optimize( config, function( response ) {
+ grunt.verbose.writeln( response );
+ grunt.log.ok( "File '" + name + "' created." );
+ done();
+ }, function( err ) {
+ done( err );
+ });
+ });
+
+ // Special "alias" task to make custom build creation less grawlix-y
+ // Translation example
+ //
+ // grunt custom:+ajax,-dimensions,-effects,-offset
+ //
+ // Becomes:
+ //
+ // grunt build:*:*:+ajax:-dimensions:-effects:-offset
+ grunt.registerTask( "custom", function() {
+ var args = [].slice.call(arguments),
+ modules = args.length ? args[0].replace(/,/g, ":") : "";
+
+ grunt.log.writeln( "Creating custom build...\n" );
+
+ grunt.task.run([ "build:*:*:" + modules, "pre-uglify", "uglify", "dist" ]);
+ });
+};
diff --git a/build/r.js b/build/r.js
new file mode 100644
index 000000000..2708f51dd
--- /dev/null
+++ b/build/r.js
@@ -0,0 +1,25762 @@
+/**
+ * @license r.js 2.1.8+ Tue, 13 Aug 2013 02:54:07 GMT 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 is a bootstrap script to allow running RequireJS in the command line
+ * in either a Java/Rhino or Node environment. It is modified by the top-level
+ * dist.js file to inject other files to completely enable this file. It is
+ * the shell of the r.js file.
+ */
+
+/*jslint evil: true, nomen: true, sloppy: true */
+/*global readFile: true, process: false, Packages: false, print: false,
+console: false, java: false, module: false, requirejsVars, navigator,
+document, importScripts, self, location, Components, FileUtils */
+
+var requirejs, require, define, xpcUtil;
+(function (console, args, readFileFunc) {
+ var fileName, env, fs, vm, path, exec, rhinoContext, dir, nodeRequire,
+ nodeDefine, exists, reqMain, loadedOptimizedLib, existsForNode, Cc, Ci,
+ version = '2.1.8+ Tue, 13 Aug 2013 02:54:07 GMT',
+ jsSuffixRegExp = /\.js$/,
+ commandOption = '',
+ useLibLoaded = {},
+ //Used by jslib/rhino/args.js
+ rhinoArgs = args,
+ //Used by jslib/xpconnect/args.js
+ xpconnectArgs = args,
+ readFile = typeof readFileFunc !== 'undefined' ? readFileFunc : null;
+
+ function showHelp() {
+ console.log('See https://github.com/jrburke/r.js for usage.');
+ }
+
+ if ((typeof navigator !== 'undefined' && typeof document !== 'undefined') ||
+ (typeof importScripts !== 'undefined' && typeof self !== 'undefined')) {
+ env = 'browser';
+
+ readFile = function (path) {
+ return fs.readFileSync(path, 'utf8');
+ };
+
+ exec = function (string) {
+ return eval(string);
+ };
+
+ exists = function () {
+ console.log('x.js exists not applicable in browser env');
+ return false;
+ };
+
+ } else if (typeof Packages !== 'undefined') {
+ env = 'rhino';
+
+ fileName = args[0];
+
+ if (fileName && fileName.indexOf('-') === 0) {
+ commandOption = fileName.substring(1);
+ fileName = args[1];
+ }
+
+ //Set up execution context.
+ rhinoContext = Packages.org.mozilla.javascript.ContextFactory.getGlobal().enterContext();
+
+ exec = function (string, name) {
+ return rhinoContext.evaluateString(this, string, name, 0, null);
+ };
+
+ exists = function (fileName) {
+ return (new java.io.File(fileName)).exists();
+ };
+
+ //Define a console.log for easier logging. Don't
+ //get fancy though.
+ if (typeof console === 'undefined') {
+ console = {
+ log: function () {
+ print.apply(undefined, arguments);
+ }
+ };
+ }
+ } else if (typeof process !== 'undefined' && process.versions && !!process.versions.node) {
+ env = 'node';
+
+ //Get the fs module via Node's require before it
+ //gets replaced. Used in require/node.js
+ fs = require('fs');
+ vm = require('vm');
+ path = require('path');
+ //In Node 0.7+ existsSync is on fs.
+ existsForNode = fs.existsSync || path.existsSync;
+
+ nodeRequire = require;
+ nodeDefine = define;
+ reqMain = require.main;
+
+ //Temporarily hide require and define to allow require.js to define
+ //them.
+ require = undefined;
+ define = undefined;
+
+ readFile = function (path) {
+ return fs.readFileSync(path, 'utf8');
+ };
+
+ exec = function (string, name) {
+ return vm.runInThisContext(this.requirejsVars.require.makeNodeWrapper(string),
+ name ? fs.realpathSync(name) : '');
+ };
+
+ exists = function (fileName) {
+ return existsForNode(fileName);
+ };
+
+
+ fileName = process.argv[2];
+
+ if (fileName && fileName.indexOf('-') === 0) {
+ commandOption = fileName.substring(1);
+ fileName = process.argv[3];
+ }
+ } else if (typeof Components !== 'undefined' && Components.classes && Components.interfaces) {
+ env = 'xpconnect';
+
+ Components.utils['import']('resource://gre/modules/FileUtils.jsm');
+ Cc = Components.classes;
+ Ci = Components.interfaces;
+
+ fileName = args[0];
+
+ if (fileName && fileName.indexOf('-') === 0) {
+ commandOption = fileName.substring(1);
+ fileName = args[1];
+ }
+
+ xpcUtil = {
+ isWindows: ('@mozilla.org/windows-registry-key;1' in Cc),
+ cwd: function () {
+ return FileUtils.getFile("CurWorkD", []).path;
+ },
+
+ //Remove . and .. from paths, normalize on front slashes
+ normalize: function (path) {
+ //There has to be an easier way to do this.
+ var i, part, ary,
+ firstChar = path.charAt(0);
+
+ if (firstChar !== '/' &&
+ firstChar !== '\\' &&
+ path.indexOf(':') === -1) {
+ //A relative path. Use the current working directory.
+ path = xpcUtil.cwd() + '/' + path;
+ }
+
+ ary = path.replace(/\\/g, '/').split('/');
+
+ for (i = 0; i < ary.length; i += 1) {
+ part = ary[i];
+ if (part === '.') {
+ ary.splice(i, 1);
+ i -= 1;
+ } else if (part === '..') {
+ ary.splice(i - 1, 2);
+ i -= 2;
+ }
+ }
+ return ary.join('/');
+ },
+
+ xpfile: function (path) {
+ var fullPath;
+ try {
+ fullPath = xpcUtil.normalize(path);
+ if (xpcUtil.isWindows) {
+ fullPath = fullPath.replace(/\//g, '\\');
+ }
+ return new FileUtils.File(fullPath);
+ } catch (e) {
+ throw new Error((fullPath || path) + ' failed: ' + e);
+ }
+ },
+
+ readFile: function (/*String*/path, /*String?*/encoding) {
+ //A file read function that can deal with BOMs
+ encoding = encoding || "utf-8";
+
+ var inStream, convertStream,
+ readData = {},
+ fileObj = xpcUtil.xpfile(path);
+
+ //XPCOM, you so crazy
+ try {
+ inStream = Cc['@mozilla.org/network/file-input-stream;1']
+ .createInstance(Ci.nsIFileInputStream);
+ inStream.init(fileObj, 1, 0, false);
+
+ convertStream = Cc['@mozilla.org/intl/converter-input-stream;1']
+ .createInstance(Ci.nsIConverterInputStream);
+ convertStream.init(inStream, encoding, inStream.available(),
+ Ci.nsIConverterInputStream.DEFAULT_REPLACEMENT_CHARACTER);
+
+ convertStream.readString(inStream.available(), readData);
+ return readData.value;
+ } catch (e) {
+ throw new Error((fileObj && fileObj.path || '') + ': ' + e);
+ } finally {
+ if (convertStream) {
+ convertStream.close();
+ }
+ if (inStream) {
+ inStream.close();
+ }
+ }
+ }
+ };
+
+ readFile = xpcUtil.readFile;
+
+ exec = function (string) {
+ return eval(string);
+ };
+
+ exists = function (fileName) {
+ return xpcUtil.xpfile(fileName).exists();
+ };
+
+ //Define a console.log for easier logging. Don't
+ //get fancy though.
+ if (typeof console === 'undefined') {
+ console = {
+ log: function () {
+ print.apply(undefined, arguments);
+ }
+ };
+ }
+ }
+
+ /** vim: et:ts=4:sw=4:sts=4
+ * @license RequireJS 2.1.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
+ */
+//Not using strict: uneven strict support in browsers, #392, and causes
+//problems with requirejs.exec()/transpiler plugins that may not be strict.
+/*jslint regexp: true, nomen: true, sloppy: true */
+/*global window, navigator, document, importScripts, setTimeout, opera */
+
+
+(function (global) {
+ var req, s, head, baseElement, dataMain, src,
+ interactiveScript, currentlyAddingScript, mainScript, subPath,
+ version = '2.1.8',
+ commentRegExp = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/mg,
+ cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,
+ jsSuffixRegExp = /\.js$/,
+ currDirRegExp = /^\.\//,
+ op = Object.prototype,
+ ostring = op.toString,
+ hasOwn = op.hasOwnProperty,
+ ap = Array.prototype,
+ apsp = ap.splice,
+ isBrowser = !!(typeof window !== 'undefined' && navigator && window.document),
+ isWebWorker = !isBrowser && typeof importScripts !== 'undefined',
+ //PS3 indicates loaded and complete, but need to wait for complete
+ //specifically. Sequence is 'loading', 'loaded', execution,
+ // then 'complete'. The UA check is unfortunate, but not sure how
+ //to feature test w/o causing perf issues.
+ readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ?
+ /^complete$/ : /^(complete|loaded)$/,
+ defContextName = '_',
+ //Oh the tragedy, detecting opera. See the usage of isOpera for reason.
+ isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]',
+ contexts = {},
+ cfg = {},
+ globalDefQueue = [],
+ useInteractive = false;
+
+ function isFunction(it) {
+ return ostring.call(it) === '[object Function]';
+ }
+
+ function isArray(it) {
+ return ostring.call(it) === '[object Array]';
+ }
+
+ /**
+ * Helper function for iterating over an array. If the func returns
+ * a true value, it will break out of the loop.
+ */
+ function each(ary, func) {
+ if (ary) {
+ var i;
+ for (i = 0; i < ary.length; i += 1) {
+ if (ary[i] && func(ary[i], i, ary)) {
+ break;
+ }
+ }
+ }
+ }
+
+ /**
+ * Helper function for iterating over an array backwards. If the func
+ * returns a true value, it will break out of the loop.
+ */
+ function eachReverse(ary, func) {
+ if (ary) {
+ var i;
+ for (i = ary.length - 1; i > -1; i -= 1) {
+ if (ary[i] && func(ary[i], i, ary)) {
+ break;
+ }
+ }
+ }
+ }
+
+ function hasProp(obj, prop) {
+ return hasOwn.call(obj, prop);
+ }
+
+ function getOwn(obj, prop) {
+ return hasProp(obj, prop) && obj[prop];
+ }
+
+ /**
+ * Cycles over properties in an object and calls a function for each
+ * property value. If the function returns a truthy value, then the
+ * iteration is stopped.
+ */
+ function eachProp(obj, func) {
+ var prop;
+ for (prop in obj) {
+ if (hasProp(obj, prop)) {
+ if (func(obj[prop], prop)) {
+ break;
+ }
+ }
+ }
+ }
+
+ /**
+ * Simple function to mix in properties from source into target,
+ * but only if target does not already have a property of the same name.
+ */
+ function mixin(target, source, force, deepStringMixin) {
+ if (source) {
+ eachProp(source, function (value, prop) {
+ if (force || !hasProp(target, prop)) {
+ if (deepStringMixin && typeof value !== 'string') {
+ if (!target[prop]) {
+ target[prop] = {};
+ }
+ mixin(target[prop], value, force, deepStringMixin);
+ } else {
+ target[prop] = value;
+ }
+ }
+ });
+ }
+ return target;
+ }
+
+ //Similar to Function.prototype.bind, but the 'this' object is specified
+ //first, since it is easier to read/figure out what 'this' will be.
+ function bind(obj, fn) {
+ return function () {
+ return fn.apply(obj, arguments);
+ };
+ }
+
+ function scripts() {
+ return document.getElementsByTagName('script');
+ }
+
+ function defaultOnError(err) {
+ throw err;
+ }
+
+ //Allow getting a global that expressed in
+ //dot notation, like 'a.b.c'.
+ function getGlobal(value) {
+ if (!value) {
+ return value;
+ }
+ var g = global;
+ each(value.split('.'), function (part) {
+ g = g[part];
+ });
+ return g;
+ }
+
+ /**
+ * Constructs an error with a pointer to an URL with more information.
+ * @param {String} id the error ID that maps to an ID on a web page.
+ * @param {String} message human readable error.
+ * @param {Error} [err] the original error, if there is one.
+ *
+ * @returns {Error}
+ */
+ function makeError(id, msg, err, requireModules) {
+ var e = new Error(msg + '\nhttp://requirejs.org/docs/errors.html#' + id);
+ e.requireType = id;
+ e.requireModules = requireModules;
+ if (err) {
+ e.originalError = err;
+ }
+ return e;
+ }
+
+ if (typeof define !== 'undefined') {
+ //If a define is already in play via another AMD loader,
+ //do not overwrite.
+ return;
+ }
+
+ if (typeof requirejs !== 'undefined') {
+ if (isFunction(requirejs)) {
+ //Do not overwrite and existing requirejs instance.
+ return;
+ }
+ cfg = requirejs;
+ requirejs = undefined;
+ }
+
+ //Allow for a require config object
+ if (typeof require !== 'undefined' && !isFunction(require)) {
+ //assume it is a config object.
+ cfg = require;
+ require = undefined;
+ }
+
+ function newContext(contextName) {
+ var inCheckLoaded, Module, context, handlers,
+ checkLoadedTimeoutId,
+ config = {
+ //Defaults. Do not set a default for map
+ //config to speed up normalize(), which
+ //will run faster if there is no default.
+ waitSeconds: 7,
+ baseUrl: './',
+ paths: {},
+ pkgs: {},
+ shim: {},
+ config: {}
+ },
+ registry = {},
+ //registry of just enabled modules, to speed
+ //cycle breaking code when lots of modules
+ //are registered, but not activated.
+ enabledRegistry = {},
+ undefEvents = {},
+ defQueue = [],
+ defined = {},
+ urlFetched = {},
+ requireCounter = 1,
+ unnormalizedCounter = 1;
+
+ /**
+ * Trims the . and .. from an array of path segments.
+ * It will keep a leading path segment if a .. will become
+ * the first path segment, to help with module name lookups,
+ * which act like paths, but can be remapped. But the end result,
+ * all paths that use this function should look normalized.
+ * NOTE: this method MODIFIES the input array.
+ * @param {Array} ary the array of path segments.
+ */
+ function trimDots(ary) {
+ var i, part;
+ for (i = 0; ary[i]; i += 1) {
+ part = ary[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.
+ * @param {Boolean} applyMap apply the map config to the value. Should
+ * only be done if this normalization is for a dependency ID.
+ * @returns {String} normalized name
+ */
+ function normalize(name, baseName, applyMap) {
+ var pkgName, pkgConfig, mapValue, nameParts, i, j, nameSegment,
+ foundMap, foundI, foundStarMap, starI,
+ baseParts = baseName && baseName.split('/'),
+ normalizedBaseParts = baseParts,
+ map = config.map,
+ starMap = map && map['*'];
+
+ //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 (getOwn(config.pkgs, baseName)) {
+ //If the baseName is a package name, then just treat it as one
+ //name to concat the name with.
+ normalizedBaseParts = baseParts = [baseName];
+ } else {
+ //Convert baseName to array, and lop off the last part,
+ //so that . matches that 'directory' and not name of the baseName's
+ //module. For instance, baseName of 'one/two/three', maps to
+ //'one/two/three.js', but we want the directory, 'one/two' for
+ //this normalization.
+ normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
+ }
+
+ name = normalizedBaseParts.concat(name.split('/'));
+ trimDots(name);
+
+ //Some use of packages may use a . path to reference the
+ //'main' module name, so normalize for that.
+ pkgConfig = getOwn(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);
+ }
+ }
+
+ //Apply map config if available.
+ if (applyMap && map && (baseParts || starMap)) {
+ nameParts = name.split('/');
+
+ for (i = nameParts.length; i > 0; i -= 1) {
+ nameSegment = nameParts.slice(0, i).join('/');
+
+ if (baseParts) {
+ //Find the longest baseName segment match in the config.
+ //So, do joins on the biggest to smallest lengths of baseParts.
+ for (j = baseParts.length; j > 0; j -= 1) {
+ mapValue = getOwn(map, baseParts.slice(0, j).join('/'));
+
+ //baseName segment has config, find if it has one for
+ //this name.
+ if (mapValue) {
+ mapValue = getOwn(mapValue, nameSegment);
+ if (mapValue) {
+ //Match, update name to the new value.
+ foundMap = mapValue;
+ foundI = i;
+ break;
+ }
+ }
+ }
+ }
+
+ if (foundMap) {
+ break;
+ }
+
+ //Check for a star map match, but just hold on to it,
+ //if there is a shorter segment match later in a matching
+ //config, then favor over this star map.
+ if (!foundStarMap && starMap && getOwn(starMap, nameSegment)) {
+ foundStarMap = getOwn(starMap, nameSegment);
+ starI = i;
+ }
+ }
+
+ if (!foundMap && foundStarMap) {
+ foundMap = foundStarMap;
+ foundI = starI;
+ }
+
+ if (foundMap) {
+ nameParts.splice(0, foundI, foundMap);
+ name = nameParts.join('/');
+ }
+ }
+
+ return name;
+ }
+
+ function removeScript(name) {
+ if (isBrowser) {
+ each(scripts(), function (scriptNode) {
+ if (scriptNode.getAttribute('data-requiremodule') === name &&
+ scriptNode.getAttribute('data-requirecontext') === context.contextName) {
+ scriptNode.parentNode.removeChild(scriptNode);
+ return true;
+ }
+ });
+ }
+ }
+
+ function hasPathFallback(id) {
+ var pathConfig = getOwn(config.paths, id);
+ if (pathConfig && isArray(pathConfig) && pathConfig.length > 1) {
+ removeScript(id);
+ //Pop off the first array value, since it failed, and
+ //retry
+ pathConfig.shift();
+ context.require.undef(id);
+ context.require([id]);
+ return true;
+ }
+ }
+
+ //Turns a plugin!resource to [plugin, resource]
+ //with the plugin being undefined if the name
+ //did not have a plugin prefix.
+ function splitPrefix(name) {
+ var prefix,
+ index = name ? name.indexOf('!') : -1;
+ if (index > -1) {
+ prefix = name.substring(0, index);
+ name = name.substring(index + 1, name.length);
+ }
+ return [prefix, name];
+ }
+
+ /**
+ * Creates a module mapping that includes plugin prefix, module
+ * name, and path. If parentModuleMap is provided it will
+ * also normalize the name via require.normalize()
+ *
+ * @param {String} name the module name
+ * @param {String} [parentModuleMap] parent module map
+ * for the module name, used to resolve relative names.
+ * @param {Boolean} isNormalized: is the ID already normalized.
+ * This is true if this call is done for a define() module ID.
+ * @param {Boolean} applyMap: apply the map config to the ID.
+ * Should only be true if this map is for a dependency.
+ *
+ * @returns {Object}
+ */
+ function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {
+ var url, pluginModule, suffix, nameParts,
+ prefix = null,
+ parentName = parentModuleMap ? parentModuleMap.name : null,
+ originalName = name,
+ isDefine = true,
+ normalizedName = '';
+
+ //If no name, then it means it is a require call, generate an
+ //internal name.
+ if (!name) {
+ isDefine = false;
+ name = '_@r' + (requireCounter += 1);
+ }
+
+ nameParts = splitPrefix(name);
+ prefix = nameParts[0];
+ name = nameParts[1];
+
+ if (prefix) {
+ prefix = normalize(prefix, parentName, applyMap);
+ pluginModule = getOwn(defined, prefix);
+ }
+
+ //Account for relative paths if there is a base name.
+ if (name) {
+ if (prefix) {
+ if (pluginModule && pluginModule.normalize) {
+ //Plugin is loaded, use its normalize method.
+ normalizedName = pluginModule.normalize(name, function (name) {
+ return normalize(name, parentName, applyMap);
+ });
+ } else {
+ normalizedName = normalize(name, parentName, applyMap);
+ }
+ } else {
+ //A regular module.
+ normalizedName = normalize(name, parentName, applyMap);
+
+ //Normalized name may be a plugin ID due to map config
+ //application in normalize. The map config values must
+ //already be normalized, so do not need to redo that part.
+ nameParts = splitPrefix(normalizedName);
+ prefix = nameParts[0];
+ normalizedName = nameParts[1];
+ isNormalized = true;
+
+ url = context.nameToUrl(normalizedName);
+ }
+ }
+
+ //If the id is a plugin id that cannot be determined if it needs
+ //normalization, stamp it with a unique ID so two matching relative
+ //ids that may conflict can be separate.
+ suffix = prefix && !pluginModule && !isNormalized ?
+ '_unnormalized' + (unnormalizedCounter += 1) :
+ '';
+
+ return {
+ prefix: prefix,
+ name: normalizedName,
+ parentMap: parentModuleMap,
+ unnormalized: !!suffix,
+ url: url,
+ originalName: originalName,
+ isDefine: isDefine,
+ id: (prefix ?
+ prefix + '!' + normalizedName :
+ normalizedName) + suffix
+ };
+ }
+
+ function getModule(depMap) {
+ var id = depMap.id,
+ mod = getOwn(registry, id);
+
+ if (!mod) {
+ mod = registry[id] = new context.Module(depMap);
+ }
+
+ return mod;
+ }
+
+ function on(depMap, name, fn) {
+ var id = depMap.id,
+ mod = getOwn(registry, id);
+
+ if (hasProp(defined, id) &&
+ (!mod || mod.defineEmitComplete)) {
+ if (name === 'defined') {
+ fn(defined[id]);
+ }
+ } else {
+ mod = getModule(depMap);
+ if (mod.error && name === 'error') {
+ fn(mod.error);
+ } else {
+ mod.on(name, fn);
+ }
+ }
+ }
+
+ function onError(err, errback) {
+ var ids = err.requireModules,
+ notified = false;
+
+ if (errback) {
+ errback(err);
+ } else {
+ each(ids, function (id) {
+ var mod = getOwn(registry, id);
+ if (mod) {
+ //Set error on module, so it skips timeout checks.
+ mod.error = err;
+ if (mod.events.error) {
+ notified = true;
+ mod.emit('error', err);
+ }
+ }
+ });
+
+ if (!notified) {
+ req.onError(err);
+ }
+ }
+ }
+
+ /**
+ * Internal method to transfer globalQueue items to this context's
+ * defQueue.
+ */
+ function takeGlobalQueue() {
+ //Push all the globalDefQueue items into the context's defQueue
+ if (globalDefQueue.length) {
+ //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(defQueue,
+ [defQueue.length - 1, 0].concat(globalDefQueue));
+ globalDefQueue = [];
+ }
+ }
+
+ handlers = {
+ 'require': function (mod) {
+ if (mod.require) {
+ return mod.require;
+ } else {
+ return (mod.require = context.makeRequire(mod.map));
+ }
+ },
+ 'exports': function (mod) {
+ mod.usingExports = true;
+ if (mod.map.isDefine) {
+ if (mod.exports) {
+ return mod.exports;
+ } else {
+ return (mod.exports = defined[mod.map.id] = {});
+ }
+ }
+ },
+ 'module': function (mod) {
+ if (mod.module) {
+ return mod.module;
+ } else {
+ return (mod.module = {
+ id: mod.map.id,
+ uri: mod.map.url,
+ config: function () {
+ var c,
+ pkg = getOwn(config.pkgs, mod.map.id);
+ // For packages, only support config targeted
+ // at the main module.
+ c = pkg ? getOwn(config.config, mod.map.id + '/' + pkg.main) :
+ getOwn(config.config, mod.map.id);
+ return c || {};
+ },
+ exports: defined[mod.map.id]
+ });
+ }
+ }
+ };
+
+ function cleanRegistry(id) {
+ //Clean up machinery used for waiting modules.
+ delete registry[id];
+ delete enabledRegistry[id];
+ }
+
+ function breakCycle(mod, traced, processed) {
+ var id = mod.map.id;
+
+ if (mod.error) {
+ mod.emit('error', mod.error);
+ } else {
+ traced[id] = true;
+ each(mod.depMaps, function (depMap, i) {
+ var depId = depMap.id,
+ dep = getOwn(registry, depId);
+
+ //Only force things that have not completed
+ //being defined, so still in the registry,
+ //and only if it has not been matched up
+ //in the module already.
+ if (dep && !mod.depMatched[i] && !processed[depId]) {
+ if (getOwn(traced, depId)) {
+ mod.defineDep(i, defined[depId]);
+ mod.check(); //pass false?
+ } else {
+ breakCycle(dep, traced, processed);
+ }
+ }
+ });
+ processed[id] = true;
+ }
+ }
+
+ function checkLoaded() {
+ var map, modId, err, usingPathFallback,
+ waitInterval = config.waitSeconds * 1000,
+ //It is possible to disable the wait interval by using waitSeconds of 0.
+ expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
+ noLoads = [],
+ reqCalls = [],
+ stillLoading = false,
+ needCycleCheck = true;
+
+ //Do not bother if this call was a result of a cycle break.
+ if (inCheckLoaded) {
+ return;
+ }
+
+ inCheckLoaded = true;
+
+ //Figure out the state of all the modules.
+ eachProp(enabledRegistry, function (mod) {
+ map = mod.map;
+ modId = map.id;
+
+ //Skip things that are not enabled or in error state.
+ if (!mod.enabled) {
+ return;
+ }
+
+ if (!map.isDefine) {
+ reqCalls.push(mod);
+ }
+
+ if (!mod.error) {
+ //If the module should be executed, and it has not
+ //been inited and time is up, remember it.
+ if (!mod.inited && expired) {
+ if (hasPathFallback(modId)) {
+ usingPathFallback = true;
+ stillLoading = true;
+ } else {
+ noLoads.push(modId);
+ removeScript(modId);
+ }
+ } else if (!mod.inited && mod.fetched && map.isDefine) {
+ stillLoading = true;
+ if (!map.prefix) {
+ //No reason to keep looking for unfinished
+ //loading. If the only stillLoading is a
+ //plugin resource though, keep going,
+ //because it may be that a plugin resource
+ //is waiting on a non-plugin cycle.
+ return (needCycleCheck = false);
+ }
+ }
+ }
+ });
+
+ if (expired && noLoads.length) {
+ //If wait time expired, throw error of unloaded modules.
+ err = makeError('timeout', 'Load timeout for modules: ' + noLoads, null, noLoads);
+ err.contextName = context.contextName;
+ return onError(err);
+ }
+
+ //Not expired, check for a cycle.
+ if (needCycleCheck) {
+ each(reqCalls, function (mod) {
+ breakCycle(mod, {}, {});
+ });
+ }
+
+ //If still waiting on loads, and the waiting load is something
+ //other than a plugin resource, or there are still outstanding
+ //scripts, then just try back later.
+ if ((!expired || usingPathFallback) && stillLoading) {
+ //Something is still waiting to load. Wait for it, but only
+ //if a timeout is not already in effect.
+ if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {
+ checkLoadedTimeoutId = setTimeout(function () {
+ checkLoadedTimeoutId = 0;
+ checkLoaded();
+ }, 50);
+ }
+ }
+
+ inCheckLoaded = false;
+ }
+
+ Module = function (map) {
+ this.events = getOwn(undefEvents, map.id) || {};
+ this.map = map;
+ this.shim = getOwn(config.shim, map.id);
+ this.depExports = [];
+ this.depMaps = [];
+ this.depMatched = [];
+ this.pluginMaps = {};
+ this.depCount = 0;
+
+ /* this.exports this.factory
+ this.depMaps = [],
+ this.enabled, this.fetched
+ */
+ };
+
+ Module.prototype = {
+ init: function (depMaps, factory, errback, options) {
+ options = options || {};
+
+ //Do not do more inits if already done. Can happen if there
+ //are multiple define calls for the same module. That is not
+ //a normal, common case, but it is also not unexpected.
+ if (this.inited) {
+ return;
+ }
+
+ this.factory = factory;
+
+ if (errback) {
+ //Register for errors on this module.
+ this.on('error', errback);
+ } else if (this.events.error) {
+ //If no errback already, but there are error listeners
+ //on this module, set up an errback to pass to the deps.
+ errback = bind(this, function (err) {
+ this.emit('error', err);
+ });
+ }
+
+ //Do a copy of the dependency array, so that
+ //source inputs are not modified. For example
+ //"shim" deps are passed in here directly, and
+ //doing a direct modification of the depMaps array
+ //would affect that config.
+ this.depMaps = depMaps && depMaps.slice(0);
+
+ this.errback = errback;
+
+ //Indicate this module has be initialized
+ this.inited = true;
+
+ this.ignore = options.ignore;
+
+ //Could have option to init this module in enabled mode,
+ //or could have been previously marked as enabled. However,
+ //the dependencies are not known until init is called. So
+ //if enabled previously, now trigger dependencies as enabled.
+ if (options.enabled || this.enabled) {
+ //Enable this module and dependencies.
+ //Will call this.check()
+ this.enable();
+ } else {
+ this.check();
+ }
+ },
+
+ defineDep: function (i, depExports) {
+ //Because of cycles, defined callback for a given
+ //export can be called more than once.
+ if (!this.depMatched[i]) {
+ this.depMatched[i] = true;
+ this.depCount -= 1;
+ this.depExports[i] = depExports;
+ }
+ },
+
+ fetch: function () {
+ if (this.fetched) {
+ return;
+ }
+ this.fetched = true;
+
+ context.startTime = (new Date()).getTime();
+
+ var map = this.map;
+
+ //If the manager is for a plugin managed resource,
+ //ask the plugin to load it now.
+ if (this.shim) {
+ context.makeRequire(this.map, {
+ enableBuildCallback: true
+ })(this.shim.deps || [], bind(this, function () {
+ return map.prefix ? this.callPlugin() : this.load();
+ }));
+ } else {
+ //Regular dependency.
+ return map.prefix ? this.callPlugin() : this.load();
+ }
+ },
+
+ load: function () {
+ var url = this.map.url;
+
+ //Regular dependency.
+ if (!urlFetched[url]) {
+ urlFetched[url] = true;
+ context.load(this.map.id, url);
+ }
+ },
+
+ /**
+ * Checks if the module is ready to define itself, and if so,
+ * define it.
+ */
+ check: function () {
+ if (!this.enabled || this.enabling) {
+ return;
+ }
+
+ var err, cjsModule,
+ id = this.map.id,
+ depExports = this.depExports,
+ exports = this.exports,
+ factory = this.factory;
+
+ if (!this.inited) {
+ this.fetch();
+ } else if (this.error) {
+ this.emit('error', this.error);
+ } else if (!this.defining) {
+ //The factory could trigger another require call
+ //that would result in checking this module to
+ //define itself again. If already in the process
+ //of doing that, skip this work.
+ this.defining = true;
+
+ if (this.depCount < 1 && !this.defined) {
+ if (isFunction(factory)) {
+ //If there is an error listener, favor passing
+ //to that instead of throwing an error. However,
+ //only do it for define()'d modules. require
+ //errbacks should not be called for failures in
+ //their callbacks (#699). However if a global
+ //onError is set, use that.
+ if ((this.events.error && this.map.isDefine) ||
+ req.onError !== defaultOnError) {
+ try {
+ exports = context.execCb(id, factory, depExports, exports);
+ } catch (e) {
+ err = e;
+ }
+ } else {
+ exports = context.execCb(id, factory, depExports, exports);
+ }
+
+ if (this.map.isDefine) {
+ //If setting exports via 'module' is in play,
+ //favor that over return value and exports. After that,
+ //favor a non-undefined return value over exports use.
+ cjsModule = this.module;
+ if (cjsModule &&
+ cjsModule.exports !== undefined &&
+ //Make sure it is not already the exports value
+ cjsModule.exports !== this.exports) {
+ exports = cjsModule.exports;
+ } else if (exports === undefined && this.usingExports) {
+ //exports already set the defined value.
+ exports = this.exports;
+ }
+ }
+
+ if (err) {
+ err.requireMap = this.map;
+ err.requireModules = this.map.isDefine ? [this.map.id] : null;
+ err.requireType = this.map.isDefine ? 'define' : 'require';
+ return onError((this.error = err));
+ }
+
+ } else {
+ //Just a literal value
+ exports = factory;
+ }
+
+ this.exports = exports;
+
+ if (this.map.isDefine && !this.ignore) {
+ defined[id] = exports;
+
+ if (req.onResourceLoad) {
+ req.onResourceLoad(context, this.map, this.depMaps);
+ }
+ }
+
+ //Clean up
+ cleanRegistry(id);
+
+ this.defined = true;
+ }
+
+ //Finished the define stage. Allow calling check again
+ //to allow define notifications below in the case of a
+ //cycle.
+ this.defining = false;
+
+ if (this.defined && !this.defineEmitted) {
+ this.defineEmitted = true;
+ this.emit('defined', this.exports);
+ this.defineEmitComplete = true;
+ }
+
+ }
+ },
+
+ callPlugin: function () {
+ var map = this.map,
+ id = map.id,
+ //Map already normalized the prefix.
+ pluginMap = makeModuleMap(map.prefix);
+
+ //Mark this as a dependency for this plugin, so it
+ //can be traced for cycles.
+ this.depMaps.push(pluginMap);
+
+ on(pluginMap, 'defined', bind(this, function (plugin) {
+ var load, normalizedMap, normalizedMod,
+ name = this.map.name,
+ parentName = this.map.parentMap ? this.map.parentMap.name : null,
+ localRequire = context.makeRequire(map.parentMap, {
+ enableBuildCallback: true
+ });
+
+ //If current map is not normalized, wait for that
+ //normalized name to load instead of continuing.
+ if (this.map.unnormalized) {
+ //Normalize the ID if the plugin allows it.
+ if (plugin.normalize) {
+ name = plugin.normalize(name, function (name) {
+ return normalize(name, parentName, true);
+ }) || '';
+ }
+
+ //prefix and name should already be normalized, no need
+ //for applying map config again either.
+ normalizedMap = makeModuleMap(map.prefix + '!' + name,
+ this.map.parentMap);
+ on(normalizedMap,
+ 'defined', bind(this, function (value) {
+ this.init([], function () { return value; }, null, {
+ enabled: true,
+ ignore: true
+ });
+ }));
+
+ normalizedMod = getOwn(registry, normalizedMap.id);
+ if (normalizedMod) {
+ //Mark this as a dependency for this plugin, so it
+ //can be traced for cycles.
+ this.depMaps.push(normalizedMap);
+
+ if (this.events.error) {
+ normalizedMod.on('error', bind(this, function (err) {
+ this.emit('error', err);
+ }));
+ }
+ normalizedMod.enable();
+ }
+
+ return;
+ }
+
+ load = bind(this, function (value) {
+ this.init([], function () { return value; }, null, {
+ enabled: true
+ });
+ });
+
+ load.error = bind(this, function (err) {
+ this.inited = true;
+ this.error = err;
+ err.requireModules = [id];
+
+ //Remove temp unnormalized modules for this module,
+ //since they will never be resolved otherwise now.
+ eachProp(registry, function (mod) {
+ if (mod.map.id.indexOf(id + '_unnormalized') === 0) {
+ cleanRegistry(mod.map.id);
+ }
+ });
+
+ onError(err);
+ });
+
+ //Allow plugins to load other code without having to know the
+ //context or how to 'complete' the load.
+ load.fromText = bind(this, function (text, textAlt) {
+ /*jslint evil: true */
+ var moduleName = map.name,
+ moduleMap = makeModuleMap(moduleName),
+ hasInteractive = useInteractive;
+
+ //As of 2.1.0, support just passing the text, to reinforce
+ //fromText only being called once per resource. Still
+ //support old style of passing moduleName but discard
+ //that moduleName in favor of the internal ref.
+ if (textAlt) {
+ text = textAlt;
+ }
+
+ //Turn off interactive script matching for IE for any define
+ //calls in the text, then turn it back on at the end.
+ if (hasInteractive) {
+ useInteractive = false;
+ }
+
+ //Prime the system by creating a module instance for
+ //it.
+ getModule(moduleMap);
+
+ //Transfer any config to this other module.
+ if (hasProp(config.config, id)) {
+ config.config[moduleName] = config.config[id];
+ }
+
+ try {
+ req.exec(text);
+ } catch (e) {
+ return onError(makeError('fromtexteval',
+ 'fromText eval for ' + id +
+ ' failed: ' + e,
+ e,
+ [id]));
+ }
+
+ if (hasInteractive) {
+ useInteractive = true;
+ }
+
+ //Mark this as a dependency for the plugin
+ //resource
+ this.depMaps.push(moduleMap);
+
+ //Support anonymous modules.
+ context.completeLoad(moduleName);
+
+ //Bind the value of that module to the value for this
+ //resource ID.
+ localRequire([moduleName], load);
+ });
+
+ //Use parentName here since the plugin's name is not reliable,
+ //could be some weird string with no path that actually wants to
+ //reference the parentName's path.
+ plugin.load(map.name, localRequire, load, config);
+ }));
+
+ context.enable(pluginMap, this);
+ this.pluginMaps[pluginMap.id] = pluginMap;
+ },
+
+ enable: function () {
+ enabledRegistry[this.map.id] = this;
+ this.enabled = true;
+
+ //Set flag mentioning that the module is enabling,
+ //so that immediate calls to the defined callbacks
+ //for dependencies do not trigger inadvertent load
+ //with the depCount still being zero.
+ this.enabling = true;
+
+ //Enable each dependency
+ each(this.depMaps, bind(this, function (depMap, i) {
+ var id, mod, handler;
+
+ if (typeof depMap === 'string') {
+ //Dependency needs to be converted to a depMap
+ //and wired up to this module.
+ depMap = makeModuleMap(depMap,
+ (this.map.isDefine ? this.map : this.map.parentMap),
+ false,
+ !this.skipMap);
+ this.depMaps[i] = depMap;
+
+ handler = getOwn(handlers, depMap.id);
+
+ if (handler) {
+ this.depExports[i] = handler(this);
+ return;
+ }
+
+ this.depCount += 1;
+
+ on(depMap, 'defined', bind(this, function (depExports) {
+ this.defineDep(i, depExports);
+ this.check();
+ }));
+
+ if (this.errback) {
+ on(depMap, 'error', bind(this, this.errback));
+ }
+ }
+
+ id = depMap.id;
+ mod = registry[id];
+
+ //Skip special modules like 'require', 'exports', 'module'
+ //Also, don't call enable if it is already enabled,
+ //important in circular dependency cases.
+ if (!hasProp(handlers, id) && mod && !mod.enabled) {
+ context.enable(depMap, this);
+ }
+ }));
+
+ //Enable each plugin that is used in
+ //a dependency
+ eachProp(this.pluginMaps, bind(this, function (pluginMap) {
+ var mod = getOwn(registry, pluginMap.id);
+ if (mod && !mod.enabled) {
+ context.enable(pluginMap, this);
+ }
+ }));
+
+ this.enabling = false;
+
+ this.check();
+ },
+
+ on: function (name, cb) {
+ var cbs = this.events[name];
+ if (!cbs) {
+ cbs = this.events[name] = [];
+ }
+ cbs.push(cb);
+ },
+
+ emit: function (name, evt) {
+ each(this.events[name], function (cb) {
+ cb(evt);
+ });
+ if (name === 'error') {
+ //Now that the error handler was triggered, remove
+ //the listeners, since this broken Module instance
+ //can stay around for a while in the registry.
+ delete this.events[name];
+ }
+ }
+ };
+
+ function callGetModule(args) {
+ //Skip modules already defined.
+ if (!hasProp(defined, args[0])) {
+ getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2]);
+ }
+ }
+
+ function removeListener(node, func, name, ieName) {
+ //Favor detachEvent because of IE9
+ //issue, see attachEvent/addEventListener comment elsewhere
+ //in this file.
+ if (node.detachEvent && !isOpera) {
+ //Probably IE. If not it will throw an error, which will be
+ //useful to know.
+ if (ieName) {
+ node.detachEvent(ieName, func);
+ }
+ } else {
+ node.removeEventListener(name, func, false);
+ }
+ }
+
+ /**
+ * Given an event from a script node, get the requirejs info from it,
+ * and then removes the event listeners on the node.
+ * @param {Event} evt
+ * @returns {Object}
+ */
+ function getScriptData(evt) {
+ //Using currentTarget instead of target for Firefox 2.0's sake. Not
+ //all old browsers will be supported, but this one was easy enough
+ //to support and still makes sense.
+ var node = evt.currentTarget || evt.srcElement;
+
+ //Remove the listeners once here.
+ removeListener(node, context.onScriptLoad, 'load', 'onreadystatechange');
+ removeListener(node, context.onScriptError, 'error');
+
+ return {
+ node: node,
+ id: node && node.getAttribute('data-requiremodule')
+ };
+ }
+
+ function intakeDefines() {
+ var args;
+
+ //Any defined modules in the global queue, intake them now.
+ takeGlobalQueue();
+
+ //Make sure any remaining defQueue items get properly processed.
+ while (defQueue.length) {
+ args = defQueue.shift();
+ if (args[0] === null) {
+ return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' + args[args.length - 1]));
+ } else {
+ //args are id, deps, factory. Should be normalized by the
+ //define() function.
+ callGetModule(args);
+ }
+ }
+ }
+
+ context = {
+ config: config,
+ contextName: contextName,
+ registry: registry,
+ defined: defined,
+ urlFetched: urlFetched,
+ defQueue: defQueue,
+ Module: Module,
+ makeModuleMap: makeModuleMap,
+ nextTick: req.nextTick,
+ onError: onError,
+
+ /**
+ * Set a configuration for the context.
+ * @param {Object} cfg config object to integrate.
+ */
+ configure: function (cfg) {
+ //Make sure the baseUrl ends in a slash.
+ if (cfg.baseUrl) {
+ if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {
+ cfg.baseUrl += '/';
+ }
+ }
+
+ //Save off the paths and packages since they require special processing,
+ //they are additive.
+ var pkgs = config.pkgs,
+ shim = config.shim,
+ objs = {
+ paths: true,
+ config: true,
+ map: true
+ };
+
+ eachProp(cfg, function (value, prop) {
+ if (objs[prop]) {
+ if (prop === 'map') {
+ if (!config.map) {
+ config.map = {};
+ }
+ mixin(config[prop], value, true, true);
+ } else {
+ mixin(config[prop], value, true);
+ }
+ } else {
+ config[prop] = value;
+ }
+ });
+
+ //Merge shim
+ if (cfg.shim) {
+ eachProp(cfg.shim, function (value, id) {
+ //Normalize the structure
+ if (isArray(value)) {
+ value = {
+ deps: value
+ };
+ }
+ if ((value.exports || value.init) && !value.exportsFn) {
+ value.exportsFn = context.makeShimExports(value);
+ }
+ shim[id] = value;
+ });
+ config.shim = shim;
+ }
+
+ //Adjust packages if necessary.
+ if (cfg.packages) {
+ each(cfg.packages, function (pkgObj) {
+ var location;
+
+ pkgObj = typeof pkgObj === 'string' ? { name: pkgObj } : pkgObj;
+ location = pkgObj.location;
+
+ //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.
+ main: (pkgObj.main || 'main')
+ .replace(currDirRegExp, '')
+ .replace(jsSuffixRegExp, '')
+ };
+ });
+
+ //Done with modifications, assing packages back to context config
+ config.pkgs = pkgs;
+ }
+
+ //If there are any "waiting to execute" modules in the registry,
+ //update the maps for them, since their info, like URLs to load,
+ //may have changed.
+ eachProp(registry, function (mod, id) {
+ //If module already has init called, since it is too
+ //late to modify them, and ignore unnormalized ones
+ //since they are transient.
+ if (!mod.inited && !mod.map.unnormalized) {
+ mod.map = makeModuleMap(id);
+ }
+ });
+
+ //If a deps array or a config callback is specified, then call
+ //require with those args. This is useful when require is defined as a
+ //config object before require.js is loaded.
+ if (cfg.deps || cfg.callback) {
+ context.require(cfg.deps || [], cfg.callback);
+ }
+ },
+
+ makeShimExports: function (value) {
+ function fn() {
+ var ret;
+ if (value.init) {
+ ret = value.init.apply(global, arguments);
+ }
+ return ret || (value.exports && getGlobal(value.exports));
+ }
+ return fn;
+ },
+
+ makeRequire: function (relMap, options) {
+ options = options || {};
+
+ function localRequire(deps, callback, errback) {
+ var id, map, requireMod;
+
+ if (options.enableBuildCallback && callback && isFunction(callback)) {
+ callback.__requireJsBuild = true;
+ }
+
+ if (typeof deps === 'string') {
+ if (isFunction(callback)) {
+ //Invalid call
+ return onError(makeError('requireargs', 'Invalid require call'), errback);
+ }
+
+ //If require|exports|module are requested, get the
+ //value for them from the special handlers. Caveat:
+ //this only works while module is being defined.
+ if (relMap && hasProp(handlers, deps)) {
+ return handlers[deps](registry[relMap.id]);
+ }
+
+ //Synchronous access to one module. If require.get is
+ //available (as in the Node adapter), prefer that.
+ if (req.get) {
+ return req.get(context, deps, relMap, localRequire);
+ }
+
+ //Normalize module name, if it contains . or ..
+ map = makeModuleMap(deps, relMap, false, true);
+ id = map.id;
+
+ if (!hasProp(defined, id)) {
+ return onError(makeError('notloaded', 'Module name "' +
+ id +
+ '" has not been loaded yet for context: ' +
+ contextName +
+ (relMap ? '' : '. Use require([])')));
+ }
+ return defined[id];
+ }
+
+ //Grab defines waiting in the global queue.
+ intakeDefines();
+
+ //Mark all the dependencies as needing to be loaded.
+ context.nextTick(function () {
+ //Some defines could have been added since the
+ //require call, collect them.
+ intakeDefines();
+
+ requireMod = getModule(makeModuleMap(null, relMap));
+
+ //Store if map config should be applied to this require
+ //call for dependencies.
+ requireMod.skipMap = options.skipMap;
+
+ requireMod.init(deps, callback, errback, {
+ enabled: true
+ });
+
+ checkLoaded();
+ });
+
+ return localRequire;
+ }
+
+ mixin(localRequire, {
+ isBrowser: isBrowser,
+
+ /**
+ * Converts a module name + .extension into an URL path.
+ * *Requires* the use of a module name. It does not support using
+ * plain URLs like nameToUrl.
+ */
+ toUrl: function (moduleNamePlusExt) {
+ var ext,
+ index = moduleNamePlusExt.lastIndexOf('.'),
+ segment = moduleNamePlusExt.split('/')[0],
+ isRelative = segment === '.' || segment === '..';
+
+ //Have a file extension alias, and it is not the
+ //dots from a relative path.
+ if (index !== -1 && (!isRelative || index > 1)) {
+ ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
+ moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
+ }
+
+ return context.nameToUrl(normalize(moduleNamePlusExt,
+ relMap && relMap.id, true), ext, true);
+ },
+
+ defined: function (id) {
+ return hasProp(defined, makeModuleMap(id, relMap, false, true).id);
+ },
+
+ specified: function (id) {
+ id = makeModuleMap(id, relMap, false, true).id;
+ return hasProp(defined, id) || hasProp(registry, id);
+ }
+ });
+
+ //Only allow undef on top level require calls
+ if (!relMap) {
+ localRequire.undef = function (id) {
+ //Bind any waiting define() calls to this context,
+ //fix for #408
+ takeGlobalQueue();
+
+ var map = makeModuleMap(id, relMap, true),
+ mod = getOwn(registry, id);
+
+ delete defined[id];
+ delete urlFetched[map.url];
+ delete undefEvents[id];
+
+ if (mod) {
+ //Hold on to listeners in case the
+ //module will be attempted to be reloaded
+ //using a different config.
+ if (mod.events.defined) {
+ undefEvents[id] = mod.events;
+ }
+
+ cleanRegistry(id);
+ }
+ };
+ }
+
+ return localRequire;
+ },
+
+ /**
+ * Called to enable a module if it is still in the registry
+ * awaiting enablement. A second arg, parent, the parent module,
+ * is passed in for context, when this method is overriden by
+ * the optimizer. Not shown here to keep code compact.
+ */
+ enable: function (depMap) {
+ var mod = getOwn(registry, depMap.id);
+ if (mod) {
+ getModule(depMap).enable();
+ }
+ },
+
+ /**
+ * Internal method used by environment adapters to complete a load event.
+ * A load event could be a script load or just a load pass from a synchronous
+ * load call.
+ * @param {String} moduleName the name of the module to potentially complete.
+ */
+ completeLoad: function (moduleName) {
+ var found, args, mod,
+ shim = getOwn(config.shim, moduleName) || {},
+ shExports = shim.exports;
+
+ takeGlobalQueue();
+
+ while (defQueue.length) {
+ args = defQueue.shift();
+ if (args[0] === null) {
+ args[0] = moduleName;
+ //If already found an anonymous module and bound it
+ //to this name, then this is some other anon module
+ //waiting for its completeLoad to fire.
+ if (found) {
+ break;
+ }
+ found = true;
+ } else if (args[0] === moduleName) {
+ //Found matching define call for this script!
+ found = true;
+ }
+
+ callGetModule(args);
+ }
+
+ //Do this after the cycle of callGetModule in case the result
+ //of those calls/init calls changes the registry.
+ mod = getOwn(registry, moduleName);
+
+ if (!found && !hasProp(defined, moduleName) && mod && !mod.inited) {
+ if (config.enforceDefine && (!shExports || !getGlobal(shExports))) {
+ if (hasPathFallback(moduleName)) {
+ return;
+ } else {
+ return onError(makeError('nodefine',
+ 'No define call for ' + moduleName,
+ null,
+ [moduleName]));
+ }
+ } else {
+ //A script that does not call define(), so just simulate
+ //the call for it.
+ callGetModule([moduleName, (shim.deps || []), shim.exportsFn]);
+ }
+ }
+
+ checkLoaded();
+ },
+
+ /**
+ * Converts a module name to a file path. Supports cases where
+ * moduleName may actually be just an URL.
+ * Note that it **does not** call normalize on the moduleName,
+ * it is assumed to have already been normalized. This is an
+ * internal API, not a public one. Use toUrl for the public API.
+ */
+ nameToUrl: function (moduleName, ext, skipExt) {
+ var paths, pkgs, pkg, pkgPath, syms, i, parentModule, url,
+ parentPath;
+
+ //If a colon is in the URL, it indicates a protocol is used and it is just
+ //an URL to a file, or if it starts with a slash, contains a query arg (i.e. ?)
+ //or ends with .js, then assume the user meant to use an url and not a module id.
+ //The slash is important for protocol-less URLs as well as full paths.
+ if (req.jsExtRegExp.test(moduleName)) {
+ //Just a plain path, not module name lookup, so just return it.
+ //Add extension if it is included. This is a bit wonky, only non-.js things pass
+ //an extension, this method probably needs to be reworked.
+ url = moduleName + (ext || '');
+ } else {
+ //A module that needs to be converted to a path.
+ paths = config.paths;
+ 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 -= 1) {
+ parentModule = syms.slice(0, i).join('/');
+ pkg = getOwn(pkgs, parentModule);
+ parentPath = getOwn(paths, parentModule);
+ if (parentPath) {
+ //If an array, it means there are a few choices,
+ //Choose the one that is desired
+ if (isArray(parentPath)) {
+ parentPath = parentPath[0];
+ }
+ syms.splice(0, i, parentPath);
+ break;
+ } else if (pkg) {
+ //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 = syms.join('/');
+ url += (ext || (/\?/.test(url) || skipExt ? '' : '.js'));
+ url = (url.charAt(0) === '/' || url.match(/^[\w\+\.\-]+:/) ? '' : config.baseUrl) + url;
+ }
+
+ return config.urlArgs ? url +
+ ((url.indexOf('?') === -1 ? '?' : '&') +
+ config.urlArgs) : url;
+ },
+
+ //Delegates to req.load. Broken out as a separate function to
+ //allow overriding in the optimizer.
+ load: function (id, url) {
+ req.load(context, id, url);
+ },
+
+ /**
+ * Executes a module callback function. Broken out as a separate function
+ * solely to allow the build system to sequence the files in the built
+ * layer in the right sequence.
+ *
+ * @private
+ */
+ execCb: function (name, callback, args, exports) {
+ return callback.apply(exports, args);
+ },
+
+ /**
+ * callback for script loads, used to check status of loading.
+ *
+ * @param {Event} evt the event from the browser for the script
+ * that was loaded.
+ */
+ onScriptLoad: function (evt) {
+ //Using currentTarget instead of target for Firefox 2.0's sake. Not
+ //all old browsers will be supported, but this one was easy enough
+ //to support and still makes sense.
+ if (evt.type === 'load' ||
+ (readyRegExp.test((evt.currentTarget || evt.srcElement).readyState))) {
+ //Reset interactive script so a script node is not held onto for
+ //to long.
+ interactiveScript = null;
+
+ //Pull out the name of the module and the context.
+ var data = getScriptData(evt);
+ context.completeLoad(data.id);
+ }
+ },
+
+ /**
+ * Callback for script errors.
+ */
+ onScriptError: function (evt) {
+ var data = getScriptData(evt);
+ if (!hasPathFallback(data.id)) {
+ return onError(makeError('scripterror', 'Script error for: ' + data.id, evt, [data.id]));
+ }
+ }
+ };
+
+ context.require = context.makeRequire();
+ return context;
+ }
+
+ /**
+ * Main entry point.
+ *
+ * If the only argument to require is a string, then the module that
+ * is represented by that string is fetched for the appropriate context.
+ *
+ * If the first argument is an array, then it will be treated as an array
+ * of dependency string names to fetch. An optional function callback can
+ * be specified to execute when all of those dependencies are available.
+ *
+ * Make a local req variable to help Caja compliance (it assumes things
+ * on a require that are not standardized), and to give a short
+ * name for minification/local scope use.
+ */
+ req = requirejs = function (deps, callback, errback, optional) {
+
+ //Find the right context, use default
+ var context, config,
+ contextName = defContextName;
+
+ // Determine if have config object in the call.
+ if (!isArray(deps) && typeof deps !== 'string') {
+ // deps is a config object
+ config = deps;
+ if (isArray(callback)) {
+ // Adjust args if there are dependencies
+ deps = callback;
+ callback = errback;
+ errback = optional;
+ } else {
+ deps = [];
+ }
+ }
+
+ if (config && config.context) {
+ contextName = config.context;
+ }
+
+ context = getOwn(contexts, contextName);
+ if (!context) {
+ context = contexts[contextName] = req.s.newContext(contextName);
+ }
+
+ if (config) {
+ context.configure(config);
+ }
+
+ return context.require(deps, callback, errback);
+ };
+
+ /**
+ * Support require.config() to make it easier to cooperate with other
+ * AMD loaders on globally agreed names.
+ */
+ req.config = function (config) {
+ return req(config);
+ };
+
+ /**
+ * Execute something after the current tick
+ * of the event loop. Override for other envs
+ * that have a better solution than setTimeout.
+ * @param {Function} fn function to execute later.
+ */
+ req.nextTick = typeof setTimeout !== 'undefined' ? function (fn) {
+ setTimeout(fn, 4);
+ } : function (fn) { fn(); };
+
+ /**
+ * Export require as a global, but only if it does not already exist.
+ */
+ if (!require) {
+ require = req;
+ }
+
+ req.version = version;
+
+ //Used to filter out dependencies that are already paths.
+ req.jsExtRegExp = /^\/|:|\?|\.js$/;
+ req.isBrowser = isBrowser;
+ s = req.s = {
+ contexts: contexts,
+ newContext: newContext
+ };
+
+ //Create default context.
+ req({});
+
+ //Exports some context-sensitive methods on global require.
+ each([
+ 'toUrl',
+ 'undef',
+ 'defined',
+ 'specified'
+ ], function (prop) {
+ //Reference from contexts instead of early binding to default context,
+ //so that during builds, the latest instance of the default context
+ //with its config gets used.
+ req[prop] = function () {
+ var ctx = contexts[defContextName];
+ return ctx.require[prop].apply(ctx, arguments);
+ };
+ });
+
+ if (isBrowser) {
+ head = s.head = document.getElementsByTagName('head')[0];
+ //If BASE tag is in play, using appendChild is a problem for IE6.
+ //When that browser dies, this can be removed. Details in this jQuery bug:
+ //http://dev.jquery.com/ticket/2709
+ baseElement = document.getElementsByTagName('base')[0];
+ if (baseElement) {
+ head = s.head = baseElement.parentNode;
+ }
+ }
+
+ /**
+ * Any errors that require explicitly generates will be passed to this
+ * function. Intercept/override it if you want custom error handling.
+ * @param {Error} err the error object.
+ */
+ req.onError = defaultOnError;
+
+ /**
+ * Creates the node for the load command. Only used in browser envs.
+ */
+ req.createNode = function (config, moduleName, url) {
+ var node = config.xhtml ?
+ document.createElementNS('http://www.w3.org/1999/xhtml', 'html:script') :
+ document.createElement('script');
+ node.type = config.scriptType || 'text/javascript';
+ node.charset = 'utf-8';
+ node.async = true;
+ return node;
+ };
+
+ /**
+ * Does the request to load a module for the browser case.
+ * Make this a separate function to allow other environments
+ * to override it.
+ *
+ * @param {Object} context the require context to find state.
+ * @param {String} moduleName the name of the module.
+ * @param {Object} url the URL to the module.
+ */
+ req.load = function (context, moduleName, url) {
+ var config = (context && context.config) || {},
+ node;
+ if (isBrowser) {
+ //In the browser so use a script tag
+ node = req.createNode(config, moduleName, url);
+
+ node.setAttribute('data-requirecontext', context.contextName);
+ node.setAttribute('data-requiremodule', moduleName);
+
+ //Set up load listener. Test attachEvent first because IE9 has
+ //a subtle issue in its addEventListener and script onload firings
+ //that do not match the behavior of all other browsers with
+ //addEventListener support, which fire the onload event for a
+ //script right after the script execution. See:
+ //https://connect.microsoft.com/IE/feedback/details/648057/script-onload-event-is-not-fired-immediately-after-script-execution
+ //UNFORTUNATELY Opera implements attachEvent but does not follow the script
+ //script execution mode.
+ if (node.attachEvent &&
+ //Check if node.attachEvent is artificially added by custom script or
+ //natively supported by browser
+ //read https://github.com/jrburke/requirejs/issues/187
+ //if we can NOT find [native code] then it must NOT natively supported.
+ //in IE8, node.attachEvent does not have toString()
+ //Note the test for "[native code" with no closing brace, see:
+ //https://github.com/jrburke/requirejs/issues/273
+ !(node.attachEvent.toString && node.attachEvent.toString().indexOf('[native code') < 0) &&
+ !isOpera) {
+ //Probably IE. IE (at least 6-8) do not fire
+ //script onload right after executing the script, so
+ //we cannot tie the anonymous define call to a name.
+ //However, IE reports the script as being in 'interactive'
+ //readyState at the time of the define call.
+ useInteractive = true;
+
+ node.attachEvent('onreadystatechange', context.onScriptLoad);
+ //It would be great to add an error handler here to catch
+ //404s in IE9+. However, onreadystatechange will fire before
+ //the error handler, so that does not help. If addEventListener
+ //is used, then IE will fire error before load, but we cannot
+ //use that pathway given the connect.microsoft.com issue
+ //mentioned above about not doing the 'script execute,
+ //then fire the script load event listener before execute
+ //next script' that other browsers do.
+ //Best hope: IE10 fixes the issues,
+ //and then destroys all installs of IE 6-9.
+ //node.attachEvent('onerror', context.onScriptError);
+ } else {
+ node.addEventListener('load', context.onScriptLoad, false);
+ node.addEventListener('error', context.onScriptError, false);
+ }
+ node.src = url;
+
+ //For some cache cases in IE 6-8, the script executes before the end
+ //of the appendChild execution, so to tie an anonymous define
+ //call to the module name (which is stored on the node), hold on
+ //to a reference to this node, but clear after the DOM insertion.
+ currentlyAddingScript = node;
+ if (baseElement) {
+ head.insertBefore(node, baseElement);
+ } else {
+ head.appendChild(node);
+ }
+ currentlyAddingScript = null;
+
+ return node;
+ } else if (isWebWorker) {
+ try {
+ //In a web worker, use importScripts. This is not a very
+ //efficient use of importScripts, importScripts will block until
+ //its script is downloaded and evaluated. However, if web workers
+ //are in play, the expectation 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.
+ importScripts(url);
+
+ //Account for anonymous modules
+ context.completeLoad(moduleName);
+ } catch (e) {
+ context.onError(makeError('importscripts',
+ 'importScripts failed for ' +
+ moduleName + ' at ' + url,
+ e,
+ [moduleName]));
+ }
+ }
+ };
+
+ function getInteractiveScript() {
+ if (interactiveScript && interactiveScript.readyState === 'interactive') {
+ return interactiveScript;
+ }
+
+ eachReverse(scripts(), function (script) {
+ if (script.readyState === 'interactive') {
+ return (interactiveScript = script);
+ }
+ });
+ return interactiveScript;
+ }
+
+ //Look for a data-main script attribute, which could also adjust the baseUrl.
+ if (isBrowser) {
+ //Figure out baseUrl. Get it from the script tag with require.js in it.
+ eachReverse(scripts(), function (script) {
+ //Set the 'head' where we can append children by
+ //using the script's parent.
+ if (!head) {
+ head = script.parentNode;
+ }
+
+ //Look for a data-main attribute to set main script for the page
+ //to load. If it is there, the path to data main becomes the
+ //baseUrl, if it is not already set.
+ dataMain = script.getAttribute('data-main');
+ if (dataMain) {
+ //Preserve dataMain in case it is a path (i.e. contains '?')
+ mainScript = dataMain;
+
+ //Set final baseUrl if there is not already an explicit one.
+ if (!cfg.baseUrl) {
+ //Pull off the directory of data-main for use as the
+ //baseUrl.
+ src = mainScript.split('/');
+ mainScript = src.pop();
+ subPath = src.length ? src.join('/') + '/' : './';
+
+ cfg.baseUrl = subPath;
+ }
+
+ //Strip off any trailing .js since mainScript is now
+ //like a module name.
+ mainScript = mainScript.replace(jsSuffixRegExp, '');
+
+ //If mainScript is still a path, fall back to dataMain
+ if (req.jsExtRegExp.test(mainScript)) {
+ mainScript = dataMain;
+ }
+
+ //Put the data-main script in the files to load.
+ cfg.deps = cfg.deps ? cfg.deps.concat(mainScript) : [mainScript];
+
+ return true;
+ }
+ });
+ }
+
+ /**
+ * The function that handles definitions of modules. Differs from
+ * require() in that a string for the module should be the first argument,
+ * and the function to execute after dependencies are loaded should
+ * return a value to define the module corresponding to the first argument's
+ * name.
+ */
+ define = function (name, deps, callback) {
+ var node, context;
+
+ //Allow for anonymous modules
+ if (typeof name !== 'string') {
+ //Adjust args appropriately
+ callback = deps;
+ deps = name;
+ name = null;
+ }
+
+ //This module may not have dependencies
+ if (!isArray(deps)) {
+ callback = deps;
+ deps = null;
+ }
+
+ //If no name, and callback is a function, then figure out if it a
+ //CommonJS thing with dependencies.
+ if (!deps && isFunction(callback)) {
+ deps = [];
+ //Remove comments from the callback string,
+ //look for require calls, and pull them into the dependencies,
+ //but only if there are function args.
+ if (callback.length) {
+ callback
+ .toString()
+ .replace(commentRegExp, '')
+ .replace(cjsRequireRegExp, function (match, dep) {
+ deps.push(dep);
+ });
+
+ //May be a CommonJS thing even without require calls, but still
+ //could use exports, and module. Avoid doing exports and module
+ //work though if it just needs require.
+ //REQUIRES the function to expect the CommonJS variables in the
+ //order listed below.
+ deps = (callback.length === 1 ? ['require'] : ['require', 'exports', 'module']).concat(deps);
+ }
+ }
+
+ //If in IE 6-8 and hit an anonymous define() call, do the interactive
+ //work.
+ if (useInteractive) {
+ node = currentlyAddingScript || getInteractiveScript();
+ if (node) {
+ if (!name) {
+ name = node.getAttribute('data-requiremodule');
+ }
+ context = contexts[node.getAttribute('data-requirecontext')];
+ }
+ }
+
+ //Always save off evaluating the def call until the script onload handler.
+ //This allows multiple modules to be in a file without prematurely
+ //tracing dependencies, and allows for anonymous module support,
+ //where the module name is not known until the script onload event
+ //occurs. If no context, use the global queue, and get it processed
+ //in the onscript load callback.
+ (context ? context.defQueue : globalDefQueue).push([name, deps, callback]);
+ };
+
+ define.amd = {
+ jQuery: true
+ };
+
+
+ /**
+ * Executes the text. Normally just uses eval, but can be modified
+ * to use a better, environment-specific call. Only used for transpiling
+ * loader plugins, not for plain JS modules.
+ * @param {String} text the text to execute/evaluate.
+ */
+ req.exec = function (text) {
+ /*jslint evil: true */
+ return eval(text);
+ };
+
+ //Set up with config info.
+ req(cfg);
+}(this));
+
+
+
+ this.requirejsVars = {
+ require: require,
+ requirejs: require,
+ define: define
+ };
+
+ if (env === 'browser') {
+ /**
+ * @license RequireJS rhino Copyright (c) 2012, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+
+//sloppy since eval enclosed with use strict causes problems if the source
+//text is not strict-compliant.
+/*jslint sloppy: true, evil: true */
+/*global require, XMLHttpRequest */
+
+(function () {
+ require.load = function (context, moduleName, url) {
+ var xhr = new XMLHttpRequest();
+
+ xhr.open('GET', url, true);
+ xhr.send();
+
+ xhr.onreadystatechange = function () {
+ if (xhr.readyState === 4) {
+ eval(xhr.responseText);
+
+ //Support anonymous modules.
+ context.completeLoad(moduleName);
+ }
+ };
+ };
+}());
+ } else 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 */
+/*global require: false, java: false, load: false */
+
+(function () {
+ 'use strict';
+ require.load = function (context, moduleName, url) {
+
+ load(url);
+
+ //Support anonymous modules.
+ context.completeLoad(moduleName);
+ };
+
+}());
+ } else if (env === 'node') {
+ this.requirejsVars.nodeRequire = nodeRequire;
+ require.nodeRequire = nodeRequire;
+
+ /**
+ * @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 */
+/*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 () {
+ 'use strict';
+
+ var nodeReq = requirejsVars.nodeRequire,
+ req = requirejsVars.require,
+ def = requirejsVars.define,
+ fs = nodeReq('fs'),
+ path = nodeReq('path'),
+ vm = nodeReq('vm'),
+ //In Node 0.7+ existsSync is on fs.
+ exists = fs.existsSync || path.existsSync,
+ hasOwn = Object.prototype.hasOwnProperty;
+
+ function hasProp(obj, prop) {
+ return hasOwn.call(obj, prop);
+ }
+
+ function syncTick(fn) {
+ fn();
+ }
+
+ //Supply an implementation that allows synchronous get of a module.
+ req.get = function (context, moduleName, relModuleMap, localRequire) {
+ if (moduleName === "require" || moduleName === "exports" || moduleName === "module") {
+ req.onError(new Error("Explicit require of " + moduleName + " is not allowed."));
+ }
+
+ var ret, oldTick,
+ moduleMap = context.makeModuleMap(moduleName, relModuleMap, false, true);
+
+ //Normalize module name, if it contains . or ..
+ moduleName = moduleMap.id;
+
+ if (hasProp(context.defined, moduleName)) {
+ ret = context.defined[moduleName];
+ } else {
+ if (ret === undefined) {
+ //Make sure nextTick for this type of call is sync-based.
+ oldTick = context.nextTick;
+ context.nextTick = syncTick;
+ try {
+ if (moduleMap.prefix) {
+ //A plugin, call requirejs to handle it. Now that
+ //nextTick is syncTick, the require will complete
+ //synchronously.
+ localRequire([moduleMap.originalName]);
+
+ //Now that plugin is loaded, can regenerate the moduleMap
+ //to get the final, normalized ID.
+ moduleMap = context.makeModuleMap(moduleMap.originalName, relModuleMap, false, true);
+ moduleName = moduleMap.id;
+ } else {
+ //Try to dynamically fetch it.
+ req.load(context, moduleName, moduleMap.url);
+
+ //Enable the module
+ context.enable(moduleMap, relModuleMap);
+ }
+
+ //Break any cycles by requiring it normally, but this will
+ //finish synchronously
+ require([moduleName]);
+
+ //The above calls are sync, so can do the next thing safely.
+ ret = context.defined[moduleName];
+ } finally {
+ context.nextTick = oldTick;
+ }
+ }
+ }
+
+ return ret;
+ };
+
+ req.nextTick = function (fn) {
+ process.nextTick(fn);
+ };
+
+ //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.
+ req.makeNodeWrapper = function (contents) {
+ return '(function (require, requirejs, define) { ' +
+ contents +
+ '\n}(requirejsVars.require, requirejsVars.requirejs, requirejsVars.define));';
+ };
+
+ req.load = function (context, moduleName, url) {
+ var contents, err,
+ config = context.config;
+
+ if (config.shim[moduleName] && (!config.suppress || !config.suppress.nodeShim)) {
+ console.warn('Shim config not supported in Node, may or may not work. Detected ' +
+ 'for module: ' + moduleName);
+ }
+
+ if (exists(url)) {
+ contents = fs.readFileSync(url, 'utf8');
+
+ contents = req.makeNodeWrapper(contents);
+ try {
+ vm.runInThisContext(contents, fs.realpathSync(url));
+ } catch (e) {
+ err = new Error('Evaluating ' + url + ' as module "' +
+ moduleName + '" failed with error: ' + e);
+ err.originalError = e;
+ err.moduleName = moduleName;
+ err.fileName = url;
+ return req.onError(err);
+ }
+ } else {
+ def(moduleName, function () {
+ //Get the original name, since relative requires may be
+ //resolved differently in node (issue #202). Also, if relative,
+ //make it relative to the URL of the item requesting it
+ //(issue #393)
+ var dirName,
+ map = hasProp(context.registry, moduleName) &&
+ context.registry[moduleName].map,
+ parentMap = map && map.parentMap,
+ originalName = map && map.originalName;
+
+ if (originalName.charAt(0) === '.' && parentMap) {
+ dirName = parentMap.url.split('/');
+ dirName.pop();
+ originalName = dirName.join('/') + '/' + originalName;
+ }
+
+ try {
+ return (context.config.nodeRequire || req.nodeRequire)(originalName);
+ } catch (e) {
+ err = new Error('Tried loading "' + moduleName + '" at ' +
+ url + ' then tried node\'s require("' +
+ originalName + '") and it failed ' +
+ 'with error: ' + e);
+ err.originalError = e;
+ err.moduleName = originalName;
+ return req.onError(err);
+ }
+ });
+ }
+
+ //Support anonymous modules.
+ context.completeLoad(moduleName);
+ };
+
+ //Override to provide the function wrapper for define/require.
+ req.exec = function (text) {
+ /*jslint evil: true */
+ text = req.makeNodeWrapper(text);
+ return eval(text);
+ };
+}());
+
+ } else if (env === 'xpconnect') {
+ /**
+ * @license RequireJS xpconnect Copyright (c) 2013, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+
+/*jslint */
+/*global require, load */
+
+(function () {
+ 'use strict';
+ require.load = function (context, moduleName, url) {
+
+ load(url);
+
+ //Support anonymous modules.
+ context.completeLoad(moduleName);
+ };
+
+}());
+
+ }
+
+ //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.
+ if (commandOption !== 'o' && (!fileName || !jsSuffixRegExp.test(fileName))) {
+ fileName = 'main.js';
+ }
+
+ /**
+ * 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 () {
+ var pathRegExp = /(\/|^)env\/|\{env\}/,
+ env = 'unknown';
+
+ if (typeof Packages !== 'undefined') {
+ env = 'rhino';
+ } else if (typeof process !== 'undefined' && process.versions && !!process.versions.node) {
+ env = 'node';
+ } else if ((typeof navigator !== 'undefined' && typeof document !== 'undefined') ||
+ (typeof importScripts !== 'undefined' && typeof self !== 'undefined')) {
+ env = 'browser';
+ } else if (typeof Components !== 'undefined' && Components.classes && Components.interfaces) {
+ env = 'xpconnect';
+ }
+
+ define('env', {
+ get: function () {
+ return env;
+ },
+
+ load: function (name, req, load, config) {
+ //Allow override in the config.
+ if (config.env) {
+ env = config.env;
+ }
+
+ name = name.replace(pathRegExp, function (match, prefix) {
+ if (match.indexOf('{') === -1) {
+ return prefix + env + '/';
+ } else {
+ return env;
+ }
+ });
+
+ req([name], function (mod) {
+ load(mod);
+ });
+ }
+ });
+}());/**
+ * @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,
+ hasOwn = Object.prototype.hasOwnProperty;
+
+ function hasProp(obj, prop) {
+ return hasOwn.call(obj, prop);
+ }
+
+ lang = {
+ backSlashRegExp: /\\/g,
+ ostring: Object.prototype.toString,
+
+ isArray: Array.isArray || function (it) {
+ return lang.ostring.call(it) === "[object Array]";
+ },
+
+ isFunction: function(it) {
+ return lang.ostring.call(it) === "[object Function]";
+ },
+
+ isRegExp: function(it) {
+ return it && it instanceof RegExp;
+ },
+
+ hasProp: hasProp,
+
+ //returns true if the object does not have an own property prop,
+ //or if it does, it is a falsy value.
+ falseProp: function (obj, prop) {
+ return !hasProp(obj, prop) || !obj[prop];
+ },
+
+ //gets own property value for given prop on object
+ getOwn: function (obj, prop) {
+ return hasProp(obj, prop) && obj[prop];
+ },
+
+ _mixin: function(dest, source, override){
+ var name;
+ for (name in source) {
+ if(source.hasOwnProperty(name)
+ && (override || !dest.hasOwnProperty(name))) {
+ dest[name] = source[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.
+ */
+ mixin: function(dest){
+ var parameters = Array.prototype.slice.call(arguments),
+ override, i, l;
+
+ if (!dest) { dest = {}; }
+
+ if (parameters.length > 2 && typeof arguments[parameters.length-1] === 'boolean') {
+ override = parameters.pop();
+ }
+
+ for (i = 1, l = parameters.length; i < l; i++) {
+ lang._mixin(dest, parameters[i], override);
+ }
+ return dest; // Object
+ },
+
+ delegate: (function () {
+ // boodman/crockford delegation w/ cornford optimization
+ function TMP() {}
+ return function (obj, props) {
+ TMP.prototype = obj;
+ var tmp = new TMP();
+ TMP.prototype = null;
+ if (props) {
+ lang.mixin(tmp, props);
+ }
+ return tmp; // Object
+ };
+ }()),
+
+ /**
+ * Helper function for iterating over an array. If the func returns
+ * a true value, it will break out of the loop.
+ */
+ each: function each(ary, func) {
+ if (ary) {
+ var i;
+ for (i = 0; i < ary.length; i += 1) {
+ if (func(ary[i], i, ary)) {
+ break;
+ }
+ }
+ }
+ },
+
+ /**
+ * Cycles over properties in an object and calls a function for each
+ * property value. If the function returns a truthy value, then the
+ * iteration is stopped.
+ */
+ eachProp: function eachProp(obj, func) {
+ var prop;
+ for (prop in obj) {
+ if (hasProp(obj, prop)) {
+ if (func(obj[prop], prop)) {
+ break;
+ }
+ }
+ }
+ },
+
+ //Similar to Function.prototype.bind, but the "this" object is specified
+ //first, since it is easier to read/figure out what "this" will be.
+ bind: function bind(obj, fn) {
+ return function () {
+ return fn.apply(obj, arguments);
+ };
+ },
+
+ //Escapes a content string to be be a string that has characters escaped
+ //for inclusion as part of a JS string.
+ jsEscape: function (content) {
+ return content.replace(/(["'\\])/g, '\\$1')
+ .replace(/[\f]/g, "\\f")
+ .replace(/[\b]/g, "\\b")
+ .replace(/[\n]/g, "\\n")
+ .replace(/[\t]/g, "\\t")
+ .replace(/[\r]/g, "\\r");
+ }
+ };
+ return lang;
+});
+/**
+ * prim 0.0.1 Copyright (c) 2012-2013, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/requirejs/prim for details
+ */
+
+/*global setImmediate, process, setTimeout, define, module */
+
+//Set prime.hideResolutionConflict = true to allow "resolution-races"
+//in promise-tests to pass.
+//Since the goal of prim is to be a small impl for trusted code, it is
+//more important to normally throw in this case so that we can find
+//logic errors quicker.
+
+var prim;
+(function () {
+ 'use strict';
+ var op = Object.prototype,
+ hasOwn = op.hasOwnProperty;
+
+ function hasProp(obj, prop) {
+ return hasOwn.call(obj, prop);
+ }
+
+ /**
+ * Helper function for iterating over an array. If the func returns
+ * a true value, it will break out of the loop.
+ */
+ function each(ary, func) {
+ if (ary) {
+ var i;
+ for (i = 0; i < ary.length; i += 1) {
+ if (ary[i]) {
+ func(ary[i], i, ary);
+ }
+ }
+ }
+ }
+
+ function check(p) {
+ if (hasProp(p, 'e') || hasProp(p, 'v')) {
+ if (!prim.hideResolutionConflict) {
+ throw new Error('nope');
+ }
+ return false;
+ }
+ return true;
+ }
+
+ function notify(ary, value) {
+ prim.nextTick(function () {
+ each(ary, function (item) {
+ item(value);
+ });
+ });
+ }
+
+ prim = function prim() {
+ var p,
+ ok = [],
+ fail = [];
+
+ return (p = {
+ callback: function (yes, no) {
+ if (no) {
+ p.errback(no);
+ }
+
+ if (hasProp(p, 'v')) {
+ prim.nextTick(function () {
+ yes(p.v);
+ });
+ } else {
+ ok.push(yes);
+ }
+ },
+
+ errback: function (no) {
+ if (hasProp(p, 'e')) {
+ prim.nextTick(function () {
+ no(p.e);
+ });
+ } else {
+ fail.push(no);
+ }
+ },
+
+ finished: function () {
+ return hasProp(p, 'e') || hasProp(p, 'v');
+ },
+
+ rejected: function () {
+ return hasProp(p, 'e');
+ },
+
+ resolve: function (v) {
+ if (check(p)) {
+ p.v = v;
+ notify(ok, v);
+ }
+ return p;
+ },
+ reject: function (e) {
+ if (check(p)) {
+ p.e = e;
+ notify(fail, e);
+ }
+ return p;
+ },
+
+ start: function (fn) {
+ p.resolve();
+ return p.promise.then(fn);
+ },
+
+ promise: {
+ then: function (yes, no) {
+ var next = prim();
+
+ p.callback(function (v) {
+ try {
+ if (yes && typeof yes === 'function') {
+ v = yes(v);
+ }
+
+ if (v && v.then) {
+ v.then(next.resolve, next.reject);
+ } else {
+ next.resolve(v);
+ }
+ } catch (e) {
+ next.reject(e);
+ }
+ }, function (e) {
+ var err;
+
+ try {
+ if (!no || typeof no !== 'function') {
+ next.reject(e);
+ } else {
+ err = no(e);
+
+ if (err && err.then) {
+ err.then(next.resolve, next.reject);
+ } else {
+ next.resolve(err);
+ }
+ }
+ } catch (e2) {
+ next.reject(e2);
+ }
+ });
+
+ return next.promise;
+ },
+
+ fail: function (no) {
+ return p.promise.then(null, no);
+ },
+
+ end: function () {
+ p.errback(function (e) {
+ throw e;
+ });
+ }
+ }
+ });
+ };
+
+ prim.serial = function (ary) {
+ var result = prim().resolve().promise;
+ each(ary, function (item) {
+ result = result.then(function () {
+ return item();
+ });
+ });
+ return result;
+ };
+
+ prim.nextTick = typeof setImmediate === 'function' ? setImmediate :
+ (typeof process !== 'undefined' && process.nextTick ?
+ process.nextTick : (typeof setTimeout !== 'undefined' ?
+ function (fn) {
+ setTimeout(fn, 0);
+ } : function (fn) {
+ fn();
+ }));
+
+ if (typeof define === 'function' && define.amd) {
+ define('prim', function () { return prim; });
+ } else if (typeof module !== 'undefined' && module.exports) {
+ module.exports = prim;
+ }
+}());
+if(env === 'browser') {
+/**
+ * @license RequireJS Copyright (c) 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 */
+/*global define: false, load: false */
+
+//Just a stub for use with uglify's consolidator.js
+define('browser/assert', function () {
+ return {};
+});
+
+}
+
+if(env === 'node') {
+/**
+ * @license RequireJS Copyright (c) 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 */
+/*global define: false, load: false */
+
+//Needed so that rhino/assert can return a stub for uglify's consolidator.js
+define('node/assert', ['assert'], function (assert) {
+ return assert;
+});
+
+}
+
+if(env === 'rhino') {
+/**
+ * @license RequireJS Copyright (c) 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 */
+/*global define: false, load: false */
+
+//Just a stub for use with uglify's consolidator.js
+define('rhino/assert', function () {
+ return {};
+});
+
+}
+
+if(env === 'xpconnect') {
+/**
+ * @license RequireJS Copyright (c) 2013, 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 */
+
+//Just a stub for use with uglify's consolidator.js
+define('xpconnect/assert', function () {
+ return {};
+});
+
+}
+
+if(env === 'browser') {
+/**
+ * @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 */
+
+define('browser/args', function () {
+ //Always expect config via an API call
+ return [];
+});
+
+}
+
+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 */
+
+define('node/args', function () {
+ //Do not return the "node" or "r.js" arguments
+ var args = process.argv.slice(2);
+
+ //Ignore any command option used for main x.js branching
+ if (args[0] && args[0].indexOf('-') === 0) {
+ args = args.slice(1);
+ }
+
+ 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));
+
+define('rhino/args', function () {
+ var args = jsLibRhinoArgs;
+
+ //Ignore any command option used for main x.js branching
+ if (args[0] && args[0].indexOf('-') === 0) {
+ args = args.slice(1);
+ }
+
+ return args;
+});
+
+}
+
+if(env === 'xpconnect') {
+/**
+ * @license Copyright (c) 2013, 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, xpconnectArgs */
+
+var jsLibXpConnectArgs = (typeof xpconnectArgs !== 'undefined' && xpconnectArgs) || [].concat(Array.prototype.slice.call(arguments, 0));
+
+define('xpconnect/args', function () {
+ var args = jsLibXpConnectArgs;
+
+ //Ignore any command option used for main x.js branching
+ if (args[0] && args[0].indexOf('-') === 0) {
+ args = args.slice(1);
+ }
+
+ return args;
+});
+
+}
+
+if(env === 'browser') {
+/**
+ * @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 */
+
+define('browser/load', ['./file'], function (file) {
+ function load(fileName) {
+ eval(file.readFile(fileName));
+ }
+
+ return load;
+});
+
+}
+
+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 */
+
+define('node/load', ['fs'], function (fs) {
+ function load(fileName) {
+ var contents = fs.readFileSync(fileName, 'utf8');
+ process.compile(contents, fileName);
+ }
+
+ 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 */
+
+define('rhino/load', function () {
+ return load;
+});
+
+}
+
+if(env === 'xpconnect') {
+/**
+ * @license RequireJS Copyright (c) 2013, 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 */
+
+define('xpconnect/load', function () {
+ return load;
+});
+
+}
+
+if(env === 'browser') {
+/**
+ * @license Copyright (c) 2012, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+
+/*jslint sloppy: true, nomen: true */
+/*global require, define, console, XMLHttpRequest, requirejs, location */
+
+define('browser/file', ['prim'], function (prim) {
+
+ var file,
+ currDirRegExp = /^\.(\/|$)/;
+
+ function frontSlash(path) {
+ return path.replace(/\\/g, '/');
+ }
+
+ function exists(path) {
+ var status, xhr = new XMLHttpRequest();
+
+ //Oh yeah, that is right SYNC IO. Behold its glory
+ //and horrible blocking behavior.
+ xhr.open('HEAD', path, false);
+ xhr.send();
+ status = xhr.status;
+
+ return status === 200 || status === 304;
+ }
+
+ function mkDir(dir) {
+ console.log('mkDir is no-op in browser');
+ }
+
+ function mkFullDir(dir) {
+ console.log('mkFullDir is no-op in browser');
+ }
+
+ file = {
+ backSlashRegExp: /\\/g,
+ exclusionRegExp: /^\./,
+ getLineSeparator: function () {
+ return '/';
+ },
+
+ exists: function (fileName) {
+ return exists(fileName);
+ },
+
+ parent: function (fileName) {
+ var parts = fileName.split('/');
+ parts.pop();
+ return parts.join('/');
+ },
+
+ /**
+ * Gets the absolute file path as a string, normalized
+ * to using front slashes for path separators.
+ * @param {String} fileName
+ */
+ absPath: function (fileName) {
+ var dir;
+ if (currDirRegExp.test(fileName)) {
+ dir = frontSlash(location.href);
+ if (dir.indexOf('/') !== -1) {
+ dir = dir.split('/');
+
+ //Pull off protocol and host, just want
+ //to allow paths (other build parts, like
+ //require._isSupportedBuildUrl do not support
+ //full URLs), but a full path from
+ //the root.
+ dir.splice(0, 3);
+
+ dir.pop();
+ dir = '/' + dir.join('/');
+ }
+
+ fileName = dir + fileName.substring(1);
+ }
+
+ return fileName;
+ },
+
+ normalize: function (fileName) {
+ return fileName;
+ },
+
+ isFile: function (path) {
+ return true;
+ },
+
+ isDirectory: function (path) {
+ return false;
+ },
+
+ getFilteredFileList: function (startDir, regExpFilters, makeUnixPaths) {
+ console.log('file.getFilteredFileList is no-op in browser');
+ },
+
+ copyDir: function (srcDir, destDir, regExpFilter, onlyCopyNew) {
+ console.log('file.copyDir is no-op in browser');
+
+ },
+
+ copyFile: function (srcFileName, destFileName, onlyCopyNew) {
+ console.log('file.copyFile is no-op in browser');
+ },
+
+ /**
+ * Renames a file. May fail if "to" already exists or is on another drive.
+ */
+ renameFile: function (from, to) {
+ console.log('file.renameFile is no-op in browser');
+ },
+
+ /**
+ * Reads a *text* file.
+ */
+ readFile: function (path, encoding) {
+ var xhr = new XMLHttpRequest();
+
+ //Oh yeah, that is right SYNC IO. Behold its glory
+ //and horrible blocking behavior.
+ xhr.open('GET', path, false);
+ xhr.send();
+
+ return xhr.responseText;
+ },
+
+ readFileAsync: function (path, encoding) {
+ var xhr = new XMLHttpRequest(),
+ d = prim();
+
+ xhr.open('GET', path, true);
+ xhr.send();
+
+ xhr.onreadystatechange = function () {
+ if (xhr.readyState === 4) {
+ if (xhr.status > 400) {
+ d.reject(new Error('Status: ' + xhr.status + ': ' + xhr.statusText));
+ } else {
+ d.resolve(xhr.responseText);
+ }
+ }
+ };
+
+ return d.promise;
+ },
+
+ saveUtf8File: function (fileName, fileContents) {
+ //summary: saves a *text* file using UTF-8 encoding.
+ file.saveFile(fileName, fileContents, "utf8");
+ },
+
+ saveFile: function (fileName, fileContents, encoding) {
+ requirejs.browser.saveFile(fileName, fileContents, encoding);
+ },
+
+ deleteFile: function (fileName) {
+ console.log('file.deleteFile is no-op in browser');
+ },
+
+ /**
+ * Deletes any empty directories under the given directory.
+ */
+ deleteEmptyDirs: function (startDir) {
+ console.log('file.deleteEmptyDirs is no-op in browser');
+ }
+ };
+
+ return file;
+
+});
+
+}
+
+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 */
+
+define('node/file', ['fs', 'path', 'prim'], function (fs, path, prim) {
+
+ var isWindows = process.platform === 'win32',
+ windowsDriveRegExp = /^[a-zA-Z]\:\/$/,
+ file;
+
+ function frontSlash(path) {
+ return path.replace(/\\/g, '/');
+ }
+
+ function exists(path) {
+ if (isWindows && path.charAt(path.length - 1) === '/' &&
+ path.charAt(path.length - 2) !== ':') {
+ path = path.substring(0, path.length - 1);
+ }
+
+ try {
+ fs.statSync(path);
+ return true;
+ } catch (e) {
+ return false;
+ }
+ }
+
+ function mkDir(dir) {
+ if (!exists(dir) && (!isWindows || !windowsDriveRegExp.test(dir))) {
+ fs.mkdirSync(dir, 511);
+ }
+ }
+
+ function mkFullDir(dir) {
+ var parts = dir.split('/'),
+ currDir = '',
+ first = true;
+
+ parts.forEach(function (part) {
+ //First part may be empty string if path starts with a slash.
+ currDir += part + '/';
+ first = false;
+
+ if (part) {
+ mkDir(currDir);
+ }
+ });
+ }
+
+ file = {
+ backSlashRegExp: /\\/g,
+ exclusionRegExp: /^\./,
+ getLineSeparator: function () {
+ return '/';
+ },
+
+ exists: function (fileName) {
+ return exists(fileName);
+ },
+
+ parent: function (fileName) {
+ var parts = fileName.split('/');
+ parts.pop();
+ return parts.join('/');
+ },
+
+ /**
+ * Gets the absolute file path as a string, normalized
+ * to using front slashes for path separators.
+ * @param {String} fileName
+ */
+ absPath: function (fileName) {
+ return frontSlash(path.normalize(frontSlash(fs.realpathSync(fileName))));
+ },
+
+ normalize: function (fileName) {
+ return frontSlash(path.normalize(fileName));
+ },
+
+ isFile: function (path) {
+ return fs.statSync(path).isFile();
+ },
+
+ isDirectory: function (path) {
+ return fs.statSync(path).isDirectory();
+ },
+
+ 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.
+ var files = [], topDir, regExpInclude, regExpExclude, dirFileArray,
+ i, stat, filePath, ok, dirFiles, fileName;
+
+ topDir = startDir;
+
+ regExpInclude = regExpFilters.include || regExpFilters;
+ regExpExclude = regExpFilters.exclude || null;
+
+ if (file.exists(topDir)) {
+ dirFileArray = fs.readdirSync(topDir);
+ for (i = 0; i < dirFileArray.length; i++) {
+ fileName = dirFileArray[i];
+ filePath = path.join(topDir, fileName);
+ stat = fs.statSync(filePath);
+ if (stat.isFile()) {
+ if (makeUnixPaths) {
+ //Make sure we have a JS string.
+ if (filePath.indexOf("/") === -1) {
+ filePath = frontSlash(filePath);
+ }
+ }
+
+ ok = true;
+ if (regExpInclude) {
+ ok = filePath.match(regExpInclude);
+ }
+ if (ok && regExpExclude) {
+ ok = !filePath.match(regExpExclude);
+ }
+
+ if (ok && (!file.exclusionRegExp ||
+ !file.exclusionRegExp.test(fileName))) {
+ files.push(filePath);
+ }
+ } else if (stat.isDirectory() &&
+ (!file.exclusionRegExp || !file.exclusionRegExp.test(fileName))) {
+ dirFiles = this.getFilteredFileList(filePath, regExpFilters, makeUnixPaths);
+ files.push.apply(files, dirFiles);
+ }
+ }
+ }
+
+ 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.
+ srcDir = frontSlash(path.normalize(srcDir));
+ destDir = frontSlash(path.normalize(destDir));
+
+ var fileNames = file.getFilteredFileList(srcDir, regExpFilter, true),
+ copiedFiles = [], i, srcFileName, destFileName;
+
+ for (i = 0; i < fileNames.length; i++) {
+ srcFileName = fileNames[i];
+ destFileName = srcFileName.replace(srcDir, destDir);
+
+ if (file.copyFile(srcFileName, destFileName, onlyCopyNew)) {
+ copiedFiles.push(destFileName);
+ }
+ }
+
+ return copiedFiles.length ? copiedFiles : null; //Array or null
+ },
+
+ copyFile: function (/*String*/srcFileName, /*String*/destFileName, /*boolean?*/onlyCopyNew) {
+ //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.
+ parentDir = path.dirname(destFileName);
+ if (!file.exists(parentDir)) {
+ mkFullDir(parentDir);
+ }
+
+ fs.writeFileSync(destFileName, fs.readFileSync(srcFileName, 'binary'), 'binary');
+
+ return true; //Boolean
+ },
+
+ /**
+ * Renames a file. May fail if "to" already exists or is on another drive.
+ */
+ renameFile: function (from, to) {
+ return fs.renameSync(from, to);
+ },
+
+ /**
+ * Reads a *text* file.
+ */
+ readFile: function (/*String*/path, /*String?*/encoding) {
+ if (encoding === 'utf-8') {
+ encoding = 'utf8';
+ }
+ if (!encoding) {
+ encoding = 'utf8';
+ }
+
+ var text = fs.readFileSync(path, encoding);
+
+ //Hmm, would not expect to get A BOM, but it seems to happen,
+ //remove it just in case.
+ if (text.indexOf('\uFEFF') === 0) {
+ text = text.substring(1, text.length);
+ }
+
+ return text;
+ },
+
+ readFileAsync: function (path, encoding) {
+ var d = prim();
+ try {
+ d.resolve(file.readFile(path, encoding));
+ } catch (e) {
+ d.reject(e);
+ }
+ return d.promise;
+ },
+
+ saveUtf8File: function (/*String*/fileName, /*String*/fileContents) {
+ //summary: saves a *text* file using UTF-8 encoding.
+ file.saveFile(fileName, fileContents, "utf8");
+ },
+
+ saveFile: function (/*String*/fileName, /*String*/fileContents, /*String?*/encoding) {
+ //summary: saves a *text* file.
+ var parentDir;
+
+ if (encoding === 'utf-8') {
+ encoding = 'utf8';
+ }
+ if (!encoding) {
+ encoding = 'utf8';
+ }
+
+ //Make sure destination directories exist.
+ parentDir = path.dirname(fileName);
+ if (!file.exists(parentDir)) {
+ mkFullDir(parentDir);
+ }
+
+ fs.writeFileSync(fileName, fileContents, encoding);
+ },
+
+ deleteFile: function (/*String*/fileName) {
+ //summary: deletes a file or directory if it exists.
+ var files, i, stat;
+ if (file.exists(fileName)) {
+ stat = fs.statSync(fileName);
+ if (stat.isDirectory()) {
+ files = fs.readdirSync(fileName);
+ for (i = 0; i < files.length; i++) {
+ this.deleteFile(path.join(fileName, files[i]));
+ }
+ fs.rmdirSync(fileName);
+ } else {
+ fs.unlinkSync(fileName);
+ }
+ }
+ },
+
+
+ /**
+ * Deletes any empty directories under the given directory.
+ */
+ deleteEmptyDirs: function (startDir) {
+ var dirFileArray, i, fileName, filePath, stat;
+
+ if (file.exists(startDir)) {
+ dirFileArray = fs.readdirSync(startDir);
+ for (i = 0; i < dirFileArray.length; i++) {
+ fileName = dirFileArray[i];
+ filePath = path.join(startDir, fileName);
+ stat = fs.statSync(filePath);
+ if (stat.isDirectory()) {
+ file.deleteEmptyDirs(filePath);
+ }
+ }
+
+ //If directory is now empty, remove it.
+ if (fs.readdirSync(startDir).length === 0) {
+ file.deleteFile(startDir);
+ }
+ }
+ }
+ };
+
+ 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 */
+/*global java: false, define: false */
+
+define('rhino/file', ['prim'], function (prim) {
+ var file = {
+ backSlashRegExp: /\\/g,
+
+ exclusionRegExp: /^\./,
+
+ getLineSeparator: function () {
+ return file.lineSeparator;
+ },
+
+ lineSeparator: java.lang.System.getProperty("line.separator"), //Java String
+
+ exists: function (fileName) {
+ return (new java.io.File(fileName)).exists();
+ },
+
+ parent: function (fileName) {
+ return file.absPath((new java.io.File(fileName)).getParentFile());
+ },
+
+ normalize: function (fileName) {
+ return file.absPath(fileName);
+ },
+
+ isFile: function (path) {
+ return (new java.io.File(path)).isFile();
+ },
+
+ isDirectory: function (path) {
+ return (new java.io.File(path)).isDirectory();
+ },
+
+ /**
+ * Gets the absolute file path as a string, normalized
+ * to using front slashes for path separators.
+ * @param {java.io.File||String} file
+ */
+ absPath: function (fileObj) {
+ if (typeof fileObj === "string") {
+ fileObj = new java.io.File(fileObj);
+ }
+ return (fileObj.getCanonicalPath() + "").replace(file.backSlashRegExp, "/");
+ },
+
+ 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.
+ var files = [], topDir, regExpInclude, regExpExclude, dirFileArray,
+ i, fileObj, filePath, ok, dirFiles;
+
+ topDir = startDir;
+ if (!startDirIsJavaObject) {
+ topDir = new java.io.File(startDir);
+ }
+
+ regExpInclude = regExpFilters.include || regExpFilters;
+ regExpExclude = regExpFilters.exclude || null;
+
+ if (topDir.exists()) {
+ dirFileArray = topDir.listFiles();
+ for (i = 0; i < dirFileArray.length; i++) {
+ fileObj = dirFileArray[i];
+ if (fileObj.isFile()) {
+ filePath = fileObj.getPath();
+ if (makeUnixPaths) {
+ //Make sure we have a JS string.
+ filePath = String(filePath);
+ if (filePath.indexOf("/") === -1) {
+ filePath = filePath.replace(/\\/g, "/");
+ }
+ }
+
+ ok = true;
+ if (regExpInclude) {
+ ok = filePath.match(regExpInclude);
+ }
+ if (ok && regExpExclude) {
+ ok = !filePath.match(regExpExclude);
+ }
+
+ if (ok && (!file.exclusionRegExp ||
+ !file.exclusionRegExp.test(fileObj.getName()))) {
+ files.push(filePath);
+ }
+ } else if (fileObj.isDirectory() &&
+ (!file.exclusionRegExp || !file.exclusionRegExp.test(fileObj.getName()))) {
+ dirFiles = this.getFilteredFileList(fileObj, regExpFilters, makeUnixPaths, true);
+ files.push.apply(files, dirFiles);
+ }
+ }
+ }
+
+ 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/;
+
+ var fileNames = file.getFilteredFileList(srcDir, regExpFilter, true),
+ copiedFiles = [], i, srcFileName, destFileName;
+
+ for (i = 0; i < fileNames.length; i++) {
+ srcFileName = fileNames[i];
+ destFileName = srcFileName.replace(srcDir, destDir);
+
+ if (file.copyFile(srcFileName, destFileName, onlyCopyNew)) {
+ copiedFiles.push(destFileName);
+ }
+ }
+
+ return copiedFiles.length ? copiedFiles : null; //Array or null
+ },
+
+ copyFile: function (/*String*/srcFileName, /*String*/destFileName, /*boolean?*/onlyCopyNew) {
+ //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 destFile = new java.io.File(destFileName), srcFile, parentDir,
+ srcChannel, destChannel;
+
+ //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) {
+ srcFile = new java.io.File(srcFileName);
+ if (destFile.exists() && destFile.lastModified() >= srcFile.lastModified()) {
+ return false; //Boolean
+ }
+ }
+
+ //Make sure destination dir exists.
+ parentDir = destFile.getParentFile();
+ if (!parentDir.exists()) {
+ if (!parentDir.mkdirs()) {
+ throw "Could not create directory: " + parentDir.getCanonicalPath();
+ }
+ }
+
+ //Java's version of copy file.
+ srcChannel = new java.io.FileInputStream(srcFileName).getChannel();
+ destChannel = new java.io.FileOutputStream(destFileName).getChannel();
+ destChannel.transferFrom(srcChannel, 0, srcChannel.size());
+ srcChannel.close();
+ destChannel.close();
+
+ return true; //Boolean
+ },
+
+ /**
+ * Renames a file. May fail if "to" already exists or is on another drive.
+ */
+ renameFile: function (from, to) {
+ return (new java.io.File(from)).renameTo((new java.io.File(to)));
+ },
+
+ readFile: function (/*String*/path, /*String?*/encoding) {
+ //A file read function that can deal with BOMs
+ encoding = encoding || "utf-8";
+ var fileObj = new java.io.File(path),
+ input = new java.io.BufferedReader(new java.io.InputStreamReader(new java.io.FileInputStream(fileObj), encoding)),
+ stringBuffer, line;
+ try {
+ stringBuffer = new java.lang.StringBuffer();
+ line = input.readLine();
+
+ // Byte Order Mark (BOM) - The Unicode Standard, version 3.0, page 324
+ // http://www.unicode.org/faq/utf_bom.html
+
+ // 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:
+ // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4508058
+ if (line && line.length() && line.charAt(0) === 0xfeff) {
+ // 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.
+ line = line.substring(1);
+ }
+ while (line !== null) {
+ stringBuffer.append(line);
+ stringBuffer.append(file.lineSeparator);
+ line = input.readLine();
+ }
+ //Make sure we return a JavaScript string and not a Java string.
+ return String(stringBuffer.toString()); //String
+ } finally {
+ input.close();
+ }
+ },
+
+ readFileAsync: function (path, encoding) {
+ var d = prim();
+ try {
+ d.resolve(file.readFile(path, encoding));
+ } catch (e) {
+ d.reject(e);
+ }
+ return d.promise;
+ },
+
+ saveUtf8File: function (/*String*/fileName, /*String*/fileContents) {
+ //summary: saves a file using UTF-8 encoding.
+ file.saveFile(fileName, fileContents, "utf-8");
+ },
+
+ saveFile: function (/*String*/fileName, /*String*/fileContents, /*String?*/encoding) {
+ //summary: saves a file.
+ var outFile = new java.io.File(fileName), outWriter, parentDir, os;
+
+ parentDir = outFile.getAbsoluteFile().getParentFile();
+ if (!parentDir.exists()) {
+ if (!parentDir.mkdirs()) {
+ throw "Could not create directory: " + parentDir.getAbsolutePath();
+ }
+ }
+
+ if (encoding) {
+ outWriter = new java.io.OutputStreamWriter(new java.io.FileOutputStream(outFile), encoding);
+ } else {
+ outWriter = new java.io.OutputStreamWriter(new java.io.FileOutputStream(outFile));
+ }
+
+ os = new java.io.BufferedWriter(outWriter);
+ try {
+ os.write(fileContents);
+ } finally {
+ os.close();
+ }
+ },
+
+ deleteFile: function (/*String*/fileName) {
+ //summary: deletes a file or directory if it exists.
+ var fileObj = new java.io.File(fileName), files, i;
+ if (fileObj.exists()) {
+ if (fileObj.isDirectory()) {
+ files = fileObj.listFiles();
+ for (i = 0; i < files.length; i++) {
+ this.deleteFile(files[i]);
+ }
+ }
+ fileObj["delete"]();
+ }
+ },
+
+ /**
+ * Deletes any empty directories under the given directory.
+ * The startDirIsJavaObject is private to this implementation's
+ * recursion needs.
+ */
+ deleteEmptyDirs: function (startDir, startDirIsJavaObject) {
+ var topDir = startDir,
+ dirFileArray, i, fileObj;
+
+ if (!startDirIsJavaObject) {
+ topDir = new java.io.File(startDir);
+ }
+
+ if (topDir.exists()) {
+ dirFileArray = topDir.listFiles();
+ for (i = 0; i < dirFileArray.length; i++) {
+ fileObj = dirFileArray[i];
+ if (fileObj.isDirectory()) {
+ file.deleteEmptyDirs(fileObj, true);
+ }
+ }
+
+ //If the directory is empty now, delete it.
+ if (topDir.listFiles().length === 0) {
+ file.deleteFile(String(topDir.getPath()));
+ }
+ }
+ }
+ };
+
+ return file;
+});
+
+}
+
+if(env === 'xpconnect') {
+/**
+ * @license RequireJS Copyright (c) 2013, 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 */
+/*global define, Components, xpcUtil */
+
+define('xpconnect/file', ['prim'], function (prim) {
+ var file,
+ Cc = Components.classes,
+ Ci = Components.interfaces,
+ //Depends on xpcUtil which is set up in x.js
+ xpfile = xpcUtil.xpfile;
+
+ function mkFullDir(dirObj) {
+ //1 is DIRECTORY_TYPE, 511 is 0777 permissions
+ if (!dirObj.exists()) {
+ dirObj.create(1, 511);
+ }
+ }
+
+ file = {
+ backSlashRegExp: /\\/g,
+
+ exclusionRegExp: /^\./,
+
+ getLineSeparator: function () {
+ return file.lineSeparator;
+ },
+
+ lineSeparator: ('@mozilla.org/windows-registry-key;1' in Cc) ?
+ '\r\n' : '\n',
+
+ exists: function (fileName) {
+ return xpfile(fileName).exists();
+ },
+
+ parent: function (fileName) {
+ return xpfile(fileName).parent;
+ },
+
+ normalize: function (fileName) {
+ return file.absPath(fileName);
+ },
+
+ isFile: function (path) {
+ return xpfile(path).isFile();
+ },
+
+ isDirectory: function (path) {
+ return xpfile(path).isDirectory();
+ },
+
+ /**
+ * Gets the absolute file path as a string, normalized
+ * to using front slashes for path separators.
+ * @param {java.io.File||String} file
+ */
+ absPath: function (fileObj) {
+ if (typeof fileObj === "string") {
+ fileObj = xpfile(fileObj);
+ }
+ return fileObj.path;
+ },
+
+ getFilteredFileList: function (/*String*/startDir, /*RegExp*/regExpFilters, /*boolean?*/makeUnixPaths, /*boolean?*/startDirIsObject) {
+ //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.
+ var files = [], topDir, regExpInclude, regExpExclude, dirFileArray,
+ fileObj, filePath, ok, dirFiles;
+
+ topDir = startDir;
+ if (!startDirIsObject) {
+ topDir = xpfile(startDir);
+ }
+
+ regExpInclude = regExpFilters.include || regExpFilters;
+ regExpExclude = regExpFilters.exclude || null;
+
+ if (topDir.exists()) {
+ dirFileArray = topDir.directoryEntries;
+ while (dirFileArray.hasMoreElements()) {
+ fileObj = dirFileArray.getNext().QueryInterface(Ci.nsILocalFile);
+ if (fileObj.isFile()) {
+ filePath = fileObj.path;
+ if (makeUnixPaths) {
+ if (filePath.indexOf("/") === -1) {
+ filePath = filePath.replace(/\\/g, "/");
+ }
+ }
+
+ ok = true;
+ if (regExpInclude) {
+ ok = filePath.match(regExpInclude);
+ }
+ if (ok && regExpExclude) {
+ ok = !filePath.match(regExpExclude);
+ }
+
+ if (ok && (!file.exclusionRegExp ||
+ !file.exclusionRegExp.test(fileObj.leafName))) {
+ files.push(filePath);
+ }
+ } else if (fileObj.isDirectory() &&
+ (!file.exclusionRegExp || !file.exclusionRegExp.test(fileObj.leafName))) {
+ dirFiles = this.getFilteredFileList(fileObj, regExpFilters, makeUnixPaths, true);
+ files.push.apply(files, dirFiles);
+ }
+ }
+ }
+
+ 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/;
+
+ var fileNames = file.getFilteredFileList(srcDir, regExpFilter, true),
+ copiedFiles = [], i, srcFileName, destFileName;
+
+ for (i = 0; i < fileNames.length; i += 1) {
+ srcFileName = fileNames[i];
+ destFileName = srcFileName.replace(srcDir, destDir);
+
+ if (file.copyFile(srcFileName, destFileName, onlyCopyNew)) {
+ copiedFiles.push(destFileName);
+ }
+ }
+
+ return copiedFiles.length ? copiedFiles : null; //Array or null
+ },
+
+ copyFile: function (/*String*/srcFileName, /*String*/destFileName, /*boolean?*/onlyCopyNew) {
+ //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 destFile = xpfile(destFileName),
+ srcFile = xpfile(srcFileName);
+
+ //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 (destFile.exists() && destFile.lastModifiedTime >= srcFile.lastModifiedTime) {
+ return false; //Boolean
+ }
+ }
+
+ srcFile.copyTo(destFile.parent, destFile.leafName);
+
+ return true; //Boolean
+ },
+
+ /**
+ * Renames a file. May fail if "to" already exists or is on another drive.
+ */
+ renameFile: function (from, to) {
+ var toFile = xpfile(to);
+ return xpfile(from).moveTo(toFile.parent, toFile.leafName);
+ },
+
+ readFile: xpcUtil.readFile,
+
+ readFileAsync: function (path, encoding) {
+ var d = prim();
+ try {
+ d.resolve(file.readFile(path, encoding));
+ } catch (e) {
+ d.reject(e);
+ }
+ return d.promise;
+ },
+
+ saveUtf8File: function (/*String*/fileName, /*String*/fileContents) {
+ //summary: saves a file using UTF-8 encoding.
+ file.saveFile(fileName, fileContents, "utf-8");
+ },
+
+ saveFile: function (/*String*/fileName, /*String*/fileContents, /*String?*/encoding) {
+ var outStream, convertStream,
+ fileObj = xpfile(fileName);
+
+ mkFullDir(fileObj.parent);
+
+ try {
+ outStream = Cc['@mozilla.org/network/file-output-stream;1']
+ .createInstance(Ci.nsIFileOutputStream);
+ //438 is decimal for 0777
+ outStream.init(fileObj, 0x02 | 0x08 | 0x20, 511, 0);
+
+ convertStream = Cc['@mozilla.org/intl/converter-output-stream;1']
+ .createInstance(Ci.nsIConverterOutputStream);
+
+ convertStream.init(outStream, encoding, 0, 0);
+ convertStream.writeString(fileContents);
+ } catch (e) {
+ throw new Error((fileObj && fileObj.path || '') + ': ' + e);
+ } finally {
+ if (convertStream) {
+ convertStream.close();
+ }
+ if (outStream) {
+ outStream.close();
+ }
+ }
+ },
+
+ deleteFile: function (/*String*/fileName) {
+ //summary: deletes a file or directory if it exists.
+ var fileObj = xpfile(fileName);
+ if (fileObj.exists()) {
+ fileObj.remove(true);
+ }
+ },
+
+ /**
+ * Deletes any empty directories under the given directory.
+ * The startDirIsJavaObject is private to this implementation's
+ * recursion needs.
+ */
+ deleteEmptyDirs: function (startDir, startDirIsObject) {
+ var topDir = startDir,
+ dirFileArray, fileObj;
+
+ if (!startDirIsObject) {
+ topDir = xpfile(startDir);
+ }
+
+ if (topDir.exists()) {
+ dirFileArray = topDir.directoryEntries;
+ while (dirFileArray.hasMoreElements()) {
+ fileObj = dirFileArray.getNext().QueryInterface(Ci.nsILocalFile);
+
+ if (fileObj.isDirectory()) {
+ file.deleteEmptyDirs(fileObj, true);
+ }
+ }
+
+ //If the directory is empty now, delete it.
+ dirFileArray = topDir.directoryEntries;
+ if (!dirFileArray.hasMoreElements()) {
+ file.deleteFile(topDir.path);
+ }
+ }
+ }
+ };
+
+ return file;
+});
+
+}
+
+if(env === 'browser') {
+/*global process */
+define('browser/quit', function () {
+ 'use strict';
+ return function (code) {
+ };
+});
+}
+
+if(env === 'node') {
+/*global process */
+define('node/quit', function () {
+ 'use strict';
+ return function (code) {
+ var draining = 0;
+ var exit = function () {
+ if (draining === 0) {
+ process.exit(code);
+ } else {
+ draining -= 1;
+ }
+ };
+ if (process.stdout.bufferSize) {
+ draining += 1;
+ process.stdout.once('drain', exit);
+ }
+ if (process.stderr.bufferSize) {
+ draining += 1;
+ process.stderr.once('drain', exit);
+ }
+ exit();
+ };
+});
+
+}
+
+if(env === 'rhino') {
+/*global quit */
+define('rhino/quit', function () {
+ 'use strict';
+ return function (code) {
+ return quit(code);
+ };
+});
+
+}
+
+if(env === 'xpconnect') {
+/*global quit */
+define('xpconnect/quit', function () {
+ 'use strict';
+ return function (code) {
+ return quit(code);
+ };
+});
+
+}
+
+if(env === 'browser') {
+/**
+ * @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 */
+
+define('browser/print', function () {
+ function print(msg) {
+ console.log(msg);
+ }
+
+ return print;
+});
+
+}
+
+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 */
+
+define('node/print', function () {
+ function print(msg) {
+ console.log(msg);
+ }
+
+ 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 */
+
+define('rhino/print', function () {
+ return print;
+});
+
+}
+
+if(env === 'xpconnect') {
+/**
+ * @license RequireJS Copyright (c) 2013, 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 */
+
+define('xpconnect/print', function () {
+ 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 */
+
+define('logger', ['env!env/print'], function (print) {
+ var logger = {
+ TRACE: 0,
+ INFO: 1,
+ WARN: 2,
+ ERROR: 3,
+ SILENT: 4,
+ level: 0,
+ logPrefix: "",
+
+ logLevel: function( level ) {
+ this.level = level;
+ },
+
+ trace: function (message) {
+ if (this.level <= this.TRACE) {
+ this._print(message);
+ }
+ },
+
+ info: function (message) {
+ if (this.level <= this.INFO) {
+ this._print(message);
+ }
+ },
+
+ warn: function (message) {
+ if (this.level <= this.WARN) {
+ this._print(message);
+ }
+ },
+
+ error: function (message) {
+ if (this.level <= this.ERROR) {
+ this._print(message);
+ }
+ },
+
+ _print: function (message) {
+ this._sysPrint((this.logPrefix ? (this.logPrefix + " ") : "") + message);
+ },
+
+ _sysPrint: function (message) {
+ print(message);
+ }
+ };
+
+ 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.
+
+/*
+ Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>
+ Copyright (C) 2012 Mathias Bynens <mathias@qiwi.be>
+ Copyright (C) 2012 Joost-Wim Boekesteijn <joost-wim@boekesteijn.nl>
+ Copyright (C) 2012 Kris Kowal <kris.kowal@cixar.com>
+ Copyright (C) 2012 Yusuke Suzuki <utatane.tea@gmail.com>
+ Copyright (C) 2012 Arpad Borsos <arpad.borsos@googlemail.com>
+ Copyright (C) 2011 Ariya Hidayat <ariya.hidayat@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 disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 <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.
+*/
+
+/*jslint bitwise:true plusplus:true */
+/*global esprima:true, define:true, exports:true, window: true,
+throwError: true, createLiteral: true, generateStatement: true,
+parseAssignmentExpression: true, parseBlock: true, parseExpression: true,
+parseFunctionDeclaration: true, parseFunctionExpression: true,
+parseFunctionSourceElements: true, parseVariableIdentifier: true,
+parseLeftHandSideExpression: true,
+parseStatement: true, parseSourceElement: true */
+
+(function (root, factory) {
+ 'use strict';
+
+ // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js,
+ // Rhino, and plain browser loading.
+ if (typeof define === 'function' && define.amd) {
+ define('esprima', ['exports'], factory);
+ } else if (typeof exports !== 'undefined') {
+ factory(exports);
+ } else {
+ factory((root.esprima = {}));
+ }
+}(this, function (exports) {
+ 'use strict';
+
+ var Token,
+ TokenName,
+ Syntax,
+ PropertyKind,
+ Messages,
+ Regex,
+ source,
+ strict,
+ index,
+ lineNumber,
+ lineStart,
+ length,
+ buffer,
+ state,
+ extra;
+
+ Token = {
+ BooleanLiteral: 1,
+ EOF: 2,
+ Identifier: 3,
+ Keyword: 4,
+ NullLiteral: 5,
+ NumericLiteral: 6,
+ Punctuator: 7,
+ StringLiteral: 8
+ };
+
+ TokenName = {};
+ TokenName[Token.BooleanLiteral] = 'Boolean';
+ TokenName[Token.EOF] = '<end>';
+ TokenName[Token.Identifier] = 'Identifier';
+ TokenName[Token.Keyword] = 'Keyword';
+ TokenName[Token.NullLiteral] = 'Null';
+ TokenName[Token.NumericLiteral] = 'Numeric';
+ TokenName[Token.Punctuator] = 'Punctuator';
+ TokenName[Token.StringLiteral] = 'String';
+
+ Syntax = {
+ AssignmentExpression: 'AssignmentExpression',
+ ArrayExpression: 'ArrayExpression',
+ BlockStatement: 'BlockStatement',
+ BinaryExpression: 'BinaryExpression',
+ BreakStatement: 'BreakStatement',
+ CallExpression: 'CallExpression',
+ CatchClause: 'CatchClause',
+ ConditionalExpression: 'ConditionalExpression',
+ ContinueStatement: 'ContinueStatement',
+ DoWhileStatement: 'DoWhileStatement',
+ DebuggerStatement: 'DebuggerStatement',
+ EmptyStatement: 'EmptyStatement',
+ ExpressionStatement: 'ExpressionStatement',
+ ForStatement: 'ForStatement',
+ ForInStatement: 'ForInStatement',
+ FunctionDeclaration: 'FunctionDeclaration',
+ FunctionExpression: 'FunctionExpression',
+ Identifier: 'Identifier',
+ IfStatement: 'IfStatement',
+ Literal: 'Literal',
+ LabeledStatement: 'LabeledStatement',
+ LogicalExpression: 'LogicalExpression',
+ MemberExpression: 'MemberExpression',
+ NewExpression: 'NewExpression',
+ ObjectExpression: 'ObjectExpression',
+ Program: 'Program',
+ Property: 'Property',
+ ReturnStatement: 'ReturnStatement',
+ SequenceExpression: 'SequenceExpression',
+ SwitchStatement: 'SwitchStatement',
+ SwitchCase: 'SwitchCase',
+ ThisExpression: 'ThisExpression',
+ ThrowStatement: 'ThrowStatement',
+ TryStatement: 'TryStatement',
+ UnaryExpression: 'UnaryExpression',
+ UpdateExpression: 'UpdateExpression',
+ VariableDeclaration: 'VariableDeclaration',
+ VariableDeclarator: 'VariableDeclarator',
+ WhileStatement: 'WhileStatement',
+ WithStatement: 'WithStatement'
+ };
+
+ PropertyKind = {
+ Data: 1,
+ Get: 2,
+ Set: 4
+ };
+
+ // Error messages should be identical to V8.
+ Messages = {
+ UnexpectedToken: 'Unexpected token %0',
+ UnexpectedNumber: 'Unexpected number',
+ UnexpectedString: 'Unexpected string',
+ UnexpectedIdentifier: 'Unexpected identifier',
+ UnexpectedReserved: 'Unexpected reserved word',
+ UnexpectedEOS: 'Unexpected end of input',
+ NewlineAfterThrow: 'Illegal newline after throw',
+ InvalidRegExp: 'Invalid regular expression',
+ UnterminatedRegExp: 'Invalid regular expression: missing /',
+ InvalidLHSInAssignment: 'Invalid left-hand side in assignment',
+ InvalidLHSInForIn: 'Invalid left-hand side in for-in',
+ MultipleDefaultsInSwitch: 'More than one default clause in switch statement',
+ NoCatchOrFinally: 'Missing catch or finally after try',
+ UnknownLabel: 'Undefined label \'%0\'',
+ Redeclaration: '%0 \'%1\' has already been declared',
+ IllegalContinue: 'Illegal continue statement',
+ IllegalBreak: 'Illegal break statement',
+ IllegalReturn: 'Illegal return statement',
+ StrictModeWith: 'Strict mode code may not include a with statement',
+ StrictCatchVariable: 'Catch variable may not be eval or arguments in strict mode',
+ StrictVarName: 'Variable name may not be eval or arguments in strict mode',
+ StrictParamName: 'Parameter name eval or arguments is not allowed in strict mode',
+ StrictParamDupe: 'Strict mode function may not have duplicate parameter names',
+ StrictFunctionName: 'Function name may not be eval or arguments in strict mode',
+ StrictOctalLiteral: 'Octal literals are not allowed in strict mode.',
+ StrictDelete: 'Delete of an unqualified identifier in strict mode.',
+ StrictDuplicateProperty: 'Duplicate data property in object literal not allowed in strict mode',
+ AccessorDataProperty: 'Object literal may not have data and accessor property with the same name',
+ AccessorGetSet: 'Object literal may not have multiple get/set accessors with the same name',
+ StrictLHSAssignment: 'Assignment to eval or arguments is not allowed in strict mode',
+ StrictLHSPostfix: 'Postfix increment/decrement may not have eval or arguments operand in strict mode',
+ StrictLHSPrefix: 'Prefix increment/decrement may not have eval or arguments operand in strict mode',
+ StrictReservedWord: 'Use of future reserved word in strict mode'
+ };
+
+ // See also tools/generate-unicode-regex.py.
+ Regex = {
+ NonAsciiIdentifierStart: new RegExp('[\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\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\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\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-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\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-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\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-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\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]'),
+ NonAsciiIdentifierPart: new RegExp('[\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0300-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u0483-\u0487\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u05d0-\u05ea\u05f0-\u05f2\u0610-\u061a\u0620-\u0669\u066e-\u06d3\u06d5-\u06dc\u06df-\u06e8\u06ea-\u06fc\u06ff\u0710-\u074a\u074d-\u07b1\u07c0-\u07f5\u07fa\u0800-\u082d\u0840-\u085b\u08a0\u08a2-\u08ac\u08e4-\u08fe\u0900-\u0963\u0966-\u096f\u0971-\u0977\u0979-\u097f\u0981-\u0983\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7\u09c8\u09cb-\u09ce\u09d7\u09dc\u09dd\u09df-\u09e3\u09e6-\u09f1\u0a01-\u0a03\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a75\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5c\u0b5d\u0b5f-\u0b63\u0b66-\u0b6f\u0b71\u0b82\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd0\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c58\u0c59\u0c60-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1\u0cf2\u0d02\u0d03\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d-\u0d44\u0d46-\u0d48\u0d4a-\u0d4e\u0d57\u0d60-\u0d63\u0d66-\u0d6f\u0d7a-\u0d7f\u0d82\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e01-\u0e3a\u0e40-\u0e4e\u0e50-\u0e59\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb9\u0ebb-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ecd\u0ed0-\u0ed9\u0edc-\u0edf\u0f00\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e-\u0f47\u0f49-\u0f6c\u0f71-\u0f84\u0f86-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1049\u1050-\u109d\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\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\u135d-\u135f\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772\u1773\u1780-\u17d3\u17d7\u17dc\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1820-\u1877\u1880-\u18aa\u18b0-\u18f5\u1900-\u191c\u1920-\u192b\u1930-\u193b\u1946-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19d9\u1a00-\u1a1b\u1a20-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1aa7\u1b00-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1bf3\u1c00-\u1c37\u1c40-\u1c49\u1c4d-\u1c7d\u1cd0-\u1cd2\u1cd4-\u1cf6\u1d00-\u1de6\u1dfc-\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\u200c\u200d\u203f\u2040\u2054\u2071\u207f\u2090-\u209c\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d7f-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2dff\u2e2f\u3005-\u3007\u3021-\u302f\u3031-\u3035\u3038-\u303c\u3041-\u3096\u3099\u309a\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua62b\ua640-\ua66f\ua674-\ua67d\ua67f-\ua697\ua69f-\ua6f1\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua827\ua840-\ua873\ua880-\ua8c4\ua8d0-\ua8d9\ua8e0-\ua8f7\ua8fb\ua900-\ua92d\ua930-\ua953\ua960-\ua97c\ua980-\ua9c0\ua9cf-\ua9d9\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa60-\uaa76\uaa7a\uaa7b\uaa80-\uaac2\uaadb-\uaadd\uaae0-\uaaef\uaaf2-\uaaf6\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabea\uabec\uabed\uabf0-\uabf9\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\ufe70-\ufe74\ufe76-\ufefc\uff10-\uff19\uff21-\uff3a\uff3f\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc]')
+ };
+
+ // Ensure the condition is true, otherwise throw an error.
+ // This is only to have a better contract semantic, i.e. another safety net
+ // to catch a logic error. The condition shall be fulfilled in normal case.
+ // Do NOT use this to enforce a certain condition on any user input.
+
+ function assert(condition, message) {
+ if (!condition) {
+ throw new Error('ASSERT: ' + message);
+ }
+ }
+
+ function sliceSource(from, to) {
+ return source.slice(from, to);
+ }
+
+ if (typeof 'esprima'[0] === 'undefined') {
+ sliceSource = function sliceArraySource(from, to) {
+ return source.slice(from, to).join('');
+ };
+ }
+
+ function isDecimalDigit(ch) {
+ return '0123456789'.indexOf(ch) >= 0;
+ }
+
+ function isHexDigit(ch) {
+ return '0123456789abcdefABCDEF'.indexOf(ch) >= 0;
+ }
+
+ function isOctalDigit(ch) {
+ return '01234567'.indexOf(ch) >= 0;
+ }
+
+
+ // 7.2 White Space
+
+ function isWhiteSpace(ch) {
+ return (ch === ' ') || (ch === '\u0009') || (ch === '\u000B') ||
+ (ch === '\u000C') || (ch === '\u00A0') ||
+ (ch.charCodeAt(0) >= 0x1680 &&
+ '\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\uFEFF'.indexOf(ch) >= 0);
+ }
+
+ // 7.3 Line Terminators
+
+ function isLineTerminator(ch) {
+ return (ch === '\n' || ch === '\r' || ch === '\u2028' || ch === '\u2029');
+ }
+
+ // 7.6 Identifier Names and Identifiers
+
+ function isIdentifierStart(ch) {
+ return (ch === '$') || (ch === '_') || (ch === '\\') ||
+ (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||
+ ((ch.charCodeAt(0) >= 0x80) && Regex.NonAsciiIdentifierStart.test(ch));
+ }
+
+ function isIdentifierPart(ch) {
+ return (ch === '$') || (ch === '_') || (ch === '\\') ||
+ (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||
+ ((ch >= '0') && (ch <= '9')) ||
+ ((ch.charCodeAt(0) >= 0x80) && Regex.NonAsciiIdentifierPart.test(ch));
+ }
+
+ // 7.6.1.2 Future Reserved Words
+
+ function isFutureReservedWord(id) {
+ switch (id) {
+
+ // Future reserved words.
+ case 'class':
+ case 'enum':
+ case 'export':
+ case 'extends':
+ case 'import':
+ case 'super':
+ return true;
+ }
+
+ return false;
+ }
+
+ function isStrictModeReservedWord(id) {
+ switch (id) {
+
+ // Strict Mode reserved words.
+ case 'implements':
+ case 'interface':
+ case 'package':
+ case 'private':
+ case 'protected':
+ case 'public':
+ case 'static':
+ case 'yield':
+ case 'let':
+ return true;
+ }
+
+ return false;
+ }
+
+ function isRestrictedWord(id) {
+ return id === 'eval' || id === 'arguments';
+ }
+
+ // 7.6.1.1 Keywords
+
+ function isKeyword(id) {
+ var keyword = false;
+ switch (id.length) {
+ case 2:
+ keyword = (id === 'if') || (id === 'in') || (id === 'do');
+ break;
+ case 3:
+ keyword = (id === 'var') || (id === 'for') || (id === 'new') || (id === 'try');
+ break;
+ case 4:
+ keyword = (id === 'this') || (id === 'else') || (id === 'case') || (id === 'void') || (id === 'with');
+ break;
+ case 5:
+ keyword = (id === 'while') || (id === 'break') || (id === 'catch') || (id === 'throw');
+ break;
+ case 6:
+ keyword = (id === 'return') || (id === 'typeof') || (id === 'delete') || (id === 'switch');
+ break;
+ case 7:
+ keyword = (id === 'default') || (id === 'finally');
+ break;
+ case 8:
+ keyword = (id === 'function') || (id === 'continue') || (id === 'debugger');
+ break;
+ case 10:
+ keyword = (id === 'instanceof');
+ break;
+ }
+
+ if (keyword) {
+ return true;
+ }
+
+ switch (id) {
+ // Future reserved words.
+ // 'const' is specialized as Keyword in V8.
+ case 'const':
+ return true;
+
+ // For compatiblity to SpiderMonkey and ES.next
+ case 'yield':
+ case 'let':
+ return true;
+ }
+
+ if (strict && isStrictModeReservedWord(id)) {
+ return true;
+ }
+
+ return isFutureReservedWord(id);
+ }
+
+ // 7.4 Comments
+
+ function skipComment() {
+ var ch, blockComment, lineComment;
+
+ blockComment = false;
+ lineComment = false;
+
+ while (index < length) {
+ ch = source[index];
+
+ if (lineComment) {
+ ch = source[index++];
+ if (isLineTerminator(ch)) {
+ lineComment = false;
+ if (ch === '\r' && source[index] === '\n') {
+ ++index;
+ }
+ ++lineNumber;
+ lineStart = index;
+ }
+ } else if (blockComment) {
+ if (isLineTerminator(ch)) {
+ if (ch === '\r' && source[index + 1] === '\n') {
+ ++index;
+ }
+ ++lineNumber;
+ ++index;
+ lineStart = index;
+ if (index >= length) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ } else {
+ ch = source[index++];
+ if (index >= length) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ if (ch === '*') {
+ ch = source[index];
+ if (ch === '/') {
+ ++index;
+ blockComment = false;
+ }
+ }
+ }
+ } else if (ch === '/') {
+ ch = source[index + 1];
+ if (ch === '/') {
+ index += 2;
+ lineComment = true;
+ } else if (ch === '*') {
+ index += 2;
+ blockComment = true;
+ if (index >= length) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ } else {
+ break;
+ }
+ } else if (isWhiteSpace(ch)) {
+ ++index;
+ } else if (isLineTerminator(ch)) {
+ ++index;
+ if (ch === '\r' && source[index] === '\n') {
+ ++index;
+ }
+ ++lineNumber;
+ lineStart = index;
+ } else {
+ break;
+ }
+ }
+ }
+
+ function scanHexEscape(prefix) {
+ var i, len, ch, code = 0;
+
+ len = (prefix === 'u') ? 4 : 2;
+ for (i = 0; i < len; ++i) {
+ if (index < length && isHexDigit(source[index])) {
+ ch = source[index++];
+ code = code * 16 + '0123456789abcdef'.indexOf(ch.toLowerCase());
+ } else {
+ return '';
+ }
+ }
+ return String.fromCharCode(code);
+ }
+
+ function scanIdentifier() {
+ var ch, start, id, restore;
+
+ ch = source[index];
+ if (!isIdentifierStart(ch)) {
+ return;
+ }
+
+ start = index;
+ if (ch === '\\') {
+ ++index;
+ if (source[index] !== 'u') {
+ return;
+ }
+ ++index;
+ restore = index;
+ ch = scanHexEscape('u');
+ if (ch) {
+ if (ch === '\\' || !isIdentifierStart(ch)) {
+ return;
+ }
+ id = ch;
+ } else {
+ index = restore;
+ id = 'u';
+ }
+ } else {
+ id = source[index++];
+ }
+
+ while (index < length) {
+ ch = source[index];
+ if (!isIdentifierPart(ch)) {
+ break;
+ }
+ if (ch === '\\') {
+ ++index;
+ if (source[index] !== 'u') {
+ return;
+ }
+ ++index;
+ restore = index;
+ ch = scanHexEscape('u');
+ if (ch) {
+ if (ch === '\\' || !isIdentifierPart(ch)) {
+ return;
+ }
+ id += ch;
+ } else {
+ index = restore;
+ id += 'u';
+ }
+ } else {
+ id += source[index++];
+ }
+ }
+
+ // There is no keyword or literal with only one character.
+ // Thus, it must be an identifier.
+ if (id.length === 1) {
+ return {
+ type: Token.Identifier,
+ value: id,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ if (isKeyword(id)) {
+ return {
+ type: Token.Keyword,
+ value: id,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ // 7.8.1 Null Literals
+
+ if (id === 'null') {
+ return {
+ type: Token.NullLiteral,
+ value: id,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ // 7.8.2 Boolean Literals
+
+ if (id === 'true' || id === 'false') {
+ return {
+ type: Token.BooleanLiteral,
+ value: id,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ return {
+ type: Token.Identifier,
+ value: id,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ // 7.7 Punctuators
+
+ function scanPunctuator() {
+ var start = index,
+ ch1 = source[index],
+ ch2,
+ ch3,
+ ch4;
+
+ // Check for most common single-character punctuators.
+
+ if (ch1 === ';' || ch1 === '{' || ch1 === '}') {
+ ++index;
+ return {
+ type: Token.Punctuator,
+ value: ch1,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ if (ch1 === ',' || ch1 === '(' || ch1 === ')') {
+ ++index;
+ return {
+ type: Token.Punctuator,
+ value: ch1,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ // Dot (.) can also start a floating-point number, hence the need
+ // to check the next character.
+
+ ch2 = source[index + 1];
+ if (ch1 === '.' && !isDecimalDigit(ch2)) {
+ return {
+ type: Token.Punctuator,
+ value: source[index++],
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ // Peek more characters.
+
+ ch3 = source[index + 2];
+ ch4 = source[index + 3];
+
+ // 4-character punctuator: >>>=
+
+ if (ch1 === '>' && ch2 === '>' && ch3 === '>') {
+ if (ch4 === '=') {
+ index += 4;
+ return {
+ type: Token.Punctuator,
+ value: '>>>=',
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+ }
+
+ // 3-character punctuators: === !== >>> <<= >>=
+
+ if (ch1 === '=' && ch2 === '=' && ch3 === '=') {
+ index += 3;
+ return {
+ type: Token.Punctuator,
+ value: '===',
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ if (ch1 === '!' && ch2 === '=' && ch3 === '=') {
+ index += 3;
+ return {
+ type: Token.Punctuator,
+ value: '!==',
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ if (ch1 === '>' && ch2 === '>' && ch3 === '>') {
+ index += 3;
+ return {
+ type: Token.Punctuator,
+ value: '>>>',
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ if (ch1 === '<' && ch2 === '<' && ch3 === '=') {
+ index += 3;
+ return {
+ type: Token.Punctuator,
+ value: '<<=',
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ if (ch1 === '>' && ch2 === '>' && ch3 === '=') {
+ index += 3;
+ return {
+ type: Token.Punctuator,
+ value: '>>=',
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ // 2-character punctuators: <= >= == != ++ -- << >> && ||
+ // += -= *= %= &= |= ^= /=
+
+ if (ch2 === '=') {
+ if ('<>=!+-*%&|^/'.indexOf(ch1) >= 0) {
+ index += 2;
+ return {
+ type: Token.Punctuator,
+ value: ch1 + ch2,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+ }
+
+ if (ch1 === ch2 && ('+-<>&|'.indexOf(ch1) >= 0)) {
+ if ('+-<>&|'.indexOf(ch2) >= 0) {
+ index += 2;
+ return {
+ type: Token.Punctuator,
+ value: ch1 + ch2,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+ }
+
+ // The remaining 1-character punctuators.
+
+ if ('[]<>+-*%&|^!~?:=/'.indexOf(ch1) >= 0) {
+ return {
+ type: Token.Punctuator,
+ value: source[index++],
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+ }
+
+ // 7.8.3 Numeric Literals
+
+ function scanNumericLiteral() {
+ var number, start, ch;
+
+ ch = source[index];
+ assert(isDecimalDigit(ch) || (ch === '.'),
+ 'Numeric literal must start with a decimal digit or a decimal point');
+
+ start = index;
+ number = '';
+ if (ch !== '.') {
+ number = source[index++];
+ ch = source[index];
+
+ // Hex number starts with '0x'.
+ // Octal number starts with '0'.
+ if (number === '0') {
+ if (ch === 'x' || ch === 'X') {
+ number += source[index++];
+ while (index < length) {
+ ch = source[index];
+ if (!isHexDigit(ch)) {
+ break;
+ }
+ number += source[index++];
+ }
+
+ if (number.length <= 2) {
+ // only 0x
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+
+ if (index < length) {
+ ch = source[index];
+ if (isIdentifierStart(ch)) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ }
+ return {
+ type: Token.NumericLiteral,
+ value: parseInt(number, 16),
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ } else if (isOctalDigit(ch)) {
+ number += source[index++];
+ while (index < length) {
+ ch = source[index];
+ if (!isOctalDigit(ch)) {
+ break;
+ }
+ number += source[index++];
+ }
+
+ if (index < length) {
+ ch = source[index];
+ if (isIdentifierStart(ch) || isDecimalDigit(ch)) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ }
+ return {
+ type: Token.NumericLiteral,
+ value: parseInt(number, 8),
+ octal: true,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ // decimal number starts with '0' such as '09' is illegal.
+ if (isDecimalDigit(ch)) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ }
+
+ while (index < length) {
+ ch = source[index];
+ if (!isDecimalDigit(ch)) {
+ break;
+ }
+ number += source[index++];
+ }
+ }
+
+ if (ch === '.') {
+ number += source[index++];
+ while (index < length) {
+ ch = source[index];
+ if (!isDecimalDigit(ch)) {
+ break;
+ }
+ number += source[index++];
+ }
+ }
+
+ if (ch === 'e' || ch === 'E') {
+ number += source[index++];
+
+ ch = source[index];
+ if (ch === '+' || ch === '-') {
+ number += source[index++];
+ }
+
+ ch = source[index];
+ if (isDecimalDigit(ch)) {
+ number += source[index++];
+ while (index < length) {
+ ch = source[index];
+ if (!isDecimalDigit(ch)) {
+ break;
+ }
+ number += source[index++];
+ }
+ } else {
+ ch = 'character ' + ch;
+ if (index >= length) {
+ ch = '<end>';
+ }
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ }
+
+ if (index < length) {
+ ch = source[index];
+ if (isIdentifierStart(ch)) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ }
+
+ return {
+ type: Token.NumericLiteral,
+ value: parseFloat(number),
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ // 7.8.4 String Literals
+
+ function scanStringLiteral() {
+ var str = '', quote, start, ch, code, unescaped, restore, octal = false;
+
+ quote = source[index];
+ assert((quote === '\'' || quote === '"'),
+ 'String literal must starts with a quote');
+
+ start = index;
+ ++index;
+
+ while (index < length) {
+ ch = source[index++];
+
+ if (ch === quote) {
+ quote = '';
+ break;
+ } else if (ch === '\\') {
+ ch = source[index++];
+ if (!isLineTerminator(ch)) {
+ switch (ch) {
+ case 'n':
+ str += '\n';
+ break;
+ case 'r':
+ str += '\r';
+ break;
+ case 't':
+ str += '\t';
+ break;
+ case 'u':
+ case 'x':
+ restore = index;
+ unescaped = scanHexEscape(ch);
+ if (unescaped) {
+ str += unescaped;
+ } else {
+ index = restore;
+ str += ch;
+ }
+ break;
+ case 'b':
+ str += '\b';
+ break;
+ case 'f':
+ str += '\f';
+ break;
+ case 'v':
+ str += '\x0B';
+ break;
+
+ default:
+ if (isOctalDigit(ch)) {
+ code = '01234567'.indexOf(ch);
+
+ // \0 is not octal escape sequence
+ if (code !== 0) {
+ octal = true;
+ }
+
+ if (index < length && isOctalDigit(source[index])) {
+ octal = true;
+ code = code * 8 + '01234567'.indexOf(source[index++]);
+
+ // 3 digits are only allowed when string starts
+ // with 0, 1, 2, 3
+ if ('0123'.indexOf(ch) >= 0 &&
+ index < length &&
+ isOctalDigit(source[index])) {
+ code = code * 8 + '01234567'.indexOf(source[index++]);
+ }
+ }
+ str += String.fromCharCode(code);
+ } else {
+ str += ch;
+ }
+ break;
+ }
+ } else {
+ ++lineNumber;
+ if (ch === '\r' && source[index] === '\n') {
+ ++index;
+ }
+ }
+ } else if (isLineTerminator(ch)) {
+ break;
+ } else {
+ str += ch;
+ }
+ }
+
+ if (quote !== '') {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+
+ return {
+ type: Token.StringLiteral,
+ value: str,
+ octal: octal,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ function scanRegExp() {
+ var str, ch, start, pattern, flags, value, classMarker = false, restore, terminated = false;
+
+ buffer = null;
+ skipComment();
+
+ start = index;
+ ch = source[index];
+ assert(ch === '/', 'Regular expression literal must start with a slash');
+ str = source[index++];
+
+ while (index < length) {
+ ch = source[index++];
+ str += ch;
+ if (classMarker) {
+ if (ch === ']') {
+ classMarker = false;
+ }
+ } else {
+ if (ch === '\\') {
+ ch = source[index++];
+ // ECMA-262 7.8.5
+ if (isLineTerminator(ch)) {
+ throwError({}, Messages.UnterminatedRegExp);
+ }
+ str += ch;
+ } else if (ch === '/') {
+ terminated = true;
+ break;
+ } else if (ch === '[') {
+ classMarker = true;
+ } else if (isLineTerminator(ch)) {
+ throwError({}, Messages.UnterminatedRegExp);
+ }
+ }
+ }
+
+ if (!terminated) {
+ throwError({}, Messages.UnterminatedRegExp);
+ }
+
+ // Exclude leading and trailing slash.
+ pattern = str.substr(1, str.length - 2);
+
+ flags = '';
+ while (index < length) {
+ ch = source[index];
+ if (!isIdentifierPart(ch)) {
+ break;
+ }
+
+ ++index;
+ if (ch === '\\' && index < length) {
+ ch = source[index];
+ if (ch === 'u') {
+ ++index;
+ restore = index;
+ ch = scanHexEscape('u');
+ if (ch) {
+ flags += ch;
+ str += '\\u';
+ for (; restore < index; ++restore) {
+ str += source[restore];
+ }
+ } else {
+ index = restore;
+ flags += 'u';
+ str += '\\u';
+ }
+ } else {
+ str += '\\';
+ }
+ } else {
+ flags += ch;
+ str += ch;
+ }
+ }
+
+ try {
+ value = new RegExp(pattern, flags);
+ } catch (e) {
+ throwError({}, Messages.InvalidRegExp);
+ }
+
+ return {
+ literal: str,
+ value: value,
+ range: [start, index]
+ };
+ }
+
+ function isIdentifierName(token) {
+ return token.type === Token.Identifier ||
+ token.type === Token.Keyword ||
+ token.type === Token.BooleanLiteral ||
+ token.type === Token.NullLiteral;
+ }
+
+ function advance() {
+ var ch, token;
+
+ skipComment();
+
+ if (index >= length) {
+ return {
+ type: Token.EOF,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [index, index]
+ };
+ }
+
+ token = scanPunctuator();
+ if (typeof token !== 'undefined') {
+ return token;
+ }
+
+ ch = source[index];
+
+ if (ch === '\'' || ch === '"') {
+ return scanStringLiteral();
+ }
+
+ if (ch === '.' || isDecimalDigit(ch)) {
+ return scanNumericLiteral();
+ }
+
+ token = scanIdentifier();
+ if (typeof token !== 'undefined') {
+ return token;
+ }
+
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+
+ function lex() {
+ var token;
+
+ if (buffer) {
+ index = buffer.range[1];
+ lineNumber = buffer.lineNumber;
+ lineStart = buffer.lineStart;
+ token = buffer;
+ buffer = null;
+ return token;
+ }
+
+ buffer = null;
+ return advance();
+ }
+
+ function lookahead() {
+ var pos, line, start;
+
+ if (buffer !== null) {
+ return buffer;
+ }
+
+ pos = index;
+ line = lineNumber;
+ start = lineStart;
+ buffer = advance();
+ index = pos;
+ lineNumber = line;
+ lineStart = start;
+
+ return buffer;
+ }
+
+ // Return true if there is a line terminator before the next token.
+
+ function peekLineTerminator() {
+ var pos, line, start, found;
+
+ pos = index;
+ line = lineNumber;
+ start = lineStart;
+ skipComment();
+ found = lineNumber !== line;
+ index = pos;
+ lineNumber = line;
+ lineStart = start;
+
+ return found;
+ }
+
+ // Throw an exception
+
+ function throwError(token, messageFormat) {
+ var error,
+ args = Array.prototype.slice.call(arguments, 2),
+ msg = messageFormat.replace(
+ /%(\d)/g,
+ function (whole, index) {
+ return args[index] || '';
+ }
+ );
+
+ if (typeof token.lineNumber === 'number') {
+ error = new Error('Line ' + token.lineNumber + ': ' + msg);
+ error.index = token.range[0];
+ error.lineNumber = token.lineNumber;
+ error.column = token.range[0] - lineStart + 1;
+ } else {
+ error = new Error('Line ' + lineNumber + ': ' + msg);
+ error.index = index;
+ error.lineNumber = lineNumber;
+ error.column = index - lineStart + 1;
+ }
+
+ throw error;
+ }
+
+ function throwErrorTolerant() {
+ try {
+ throwError.apply(null, arguments);
+ } catch (e) {
+ if (extra.errors) {
+ extra.errors.push(e);
+ } else {
+ throw e;
+ }
+ }
+ }
+
+
+ // Throw an exception because of the token.
+
+ function throwUnexpected(token) {
+ if (token.type === Token.EOF) {
+ throwError(token, Messages.UnexpectedEOS);
+ }
+
+ if (token.type === Token.NumericLiteral) {
+ throwError(token, Messages.UnexpectedNumber);
+ }
+
+ if (token.type === Token.StringLiteral) {
+ throwError(token, Messages.UnexpectedString);
+ }
+
+ if (token.type === Token.Identifier) {
+ throwError(token, Messages.UnexpectedIdentifier);
+ }
+
+ if (token.type === Token.Keyword) {
+ if (isFutureReservedWord(token.value)) {
+ throwError(token, Messages.UnexpectedReserved);
+ } else if (strict && isStrictModeReservedWord(token.value)) {
+ throwErrorTolerant(token, Messages.StrictReservedWord);
+ return;
+ }
+ throwError(token, Messages.UnexpectedToken, token.value);
+ }
+
+ // BooleanLiteral, NullLiteral, or Punctuator.
+ throwError(token, Messages.UnexpectedToken, token.value);
+ }
+
+ // Expect the next token to match the specified punctuator.
+ // If not, an exception will be thrown.
+
+ function expect(value) {
+ var token = lex();
+ if (token.type !== Token.Punctuator || token.value !== value) {
+ throwUnexpected(token);
+ }
+ }
+
+ // Expect the next token to match the specified keyword.
+ // If not, an exception will be thrown.
+
+ function expectKeyword(keyword) {
+ var token = lex();
+ if (token.type !== Token.Keyword || token.value !== keyword) {
+ throwUnexpected(token);
+ }
+ }
+
+ // Return true if the next token matches the specified punctuator.
+
+ function match(value) {
+ var token = lookahead();
+ return token.type === Token.Punctuator && token.value === value;
+ }
+
+ // Return true if the next token matches the specified keyword
+
+ function matchKeyword(keyword) {
+ var token = lookahead();
+ return token.type === Token.Keyword && token.value === keyword;
+ }
+
+ // Return true if the next token is an assignment operator
+
+ function matchAssign() {
+ var token = lookahead(),
+ op = token.value;
+
+ if (token.type !== Token.Punctuator) {
+ return false;
+ }
+ return op === '=' ||
+ op === '*=' ||
+ op === '/=' ||
+ op === '%=' ||
+ op === '+=' ||
+ op === '-=' ||
+ op === '<<=' ||
+ op === '>>=' ||
+ op === '>>>=' ||
+ op === '&=' ||
+ op === '^=' ||
+ op === '|=';
+ }
+
+ function consumeSemicolon() {
+ var token, line;
+
+ // Catch the very common case first.
+ if (source[index] === ';') {
+ lex();
+ return;
+ }
+
+ line = lineNumber;
+ skipComment();
+ if (lineNumber !== line) {
+ return;
+ }
+
+ if (match(';')) {
+ lex();
+ return;
+ }
+
+ token = lookahead();
+ if (token.type !== Token.EOF && !match('}')) {
+ throwUnexpected(token);
+ }
+ }
+
+ // Return true if provided expression is LeftHandSideExpression
+
+ function isLeftHandSide(expr) {
+ return expr.type === Syntax.Identifier || expr.type === Syntax.MemberExpression;
+ }
+
+ // 11.1.4 Array Initialiser
+
+ function parseArrayInitialiser() {
+ var elements = [];
+
+ expect('[');
+
+ while (!match(']')) {
+ if (match(',')) {
+ lex();
+ elements.push(null);
+ } else {
+ elements.push(parseAssignmentExpression());
+
+ if (!match(']')) {
+ expect(',');
+ }
+ }
+ }
+
+ expect(']');
+
+ return {
+ type: Syntax.ArrayExpression,
+ elements: elements
+ };
+ }
+
+ // 11.1.5 Object Initialiser
+
+ function parsePropertyFunction(param, first) {
+ var previousStrict, body;
+
+ previousStrict = strict;
+ body = parseFunctionSourceElements();
+ if (first && strict && isRestrictedWord(param[0].name)) {
+ throwErrorTolerant(first, Messages.StrictParamName);
+ }
+ strict = previousStrict;
+
+ return {
+ type: Syntax.FunctionExpression,
+ id: null,
+ params: param,
+ defaults: [],
+ body: body,
+ rest: null,
+ generator: false,
+ expression: false
+ };
+ }
+
+ function parseObjectPropertyKey() {
+ var token = lex();
+
+ // Note: This function is called only from parseObjectProperty(), where
+ // EOF and Punctuator tokens are already filtered out.
+
+ if (token.type === Token.StringLiteral || token.type === Token.NumericLiteral) {
+ if (strict && token.octal) {
+ throwErrorTolerant(token, Messages.StrictOctalLiteral);
+ }
+ return createLiteral(token);
+ }
+
+ return {
+ type: Syntax.Identifier,
+ name: token.value
+ };
+ }
+
+ function parseObjectProperty() {
+ var token, key, id, param;
+
+ token = lookahead();
+
+ if (token.type === Token.Identifier) {
+
+ id = parseObjectPropertyKey();
+
+ // Property Assignment: Getter and Setter.
+
+ if (token.value === 'get' && !match(':')) {
+ key = parseObjectPropertyKey();
+ expect('(');
+ expect(')');
+ return {
+ type: Syntax.Property,
+ key: key,
+ value: parsePropertyFunction([]),
+ kind: 'get'
+ };
+ } else if (token.value === 'set' && !match(':')) {
+ key = parseObjectPropertyKey();
+ expect('(');
+ token = lookahead();
+ if (token.type !== Token.Identifier) {
+ expect(')');
+ throwErrorTolerant(token, Messages.UnexpectedToken, token.value);
+ return {
+ type: Syntax.Property,
+ key: key,
+ value: parsePropertyFunction([]),
+ kind: 'set'
+ };
+ } else {
+ param = [ parseVariableIdentifier() ];
+ expect(')');
+ return {
+ type: Syntax.Property,
+ key: key,
+ value: parsePropertyFunction(param, token),
+ kind: 'set'
+ };
+ }
+ } else {
+ expect(':');
+ return {
+ type: Syntax.Property,
+ key: id,
+ value: parseAssignmentExpression(),
+ kind: 'init'
+ };
+ }
+ } else if (token.type === Token.EOF || token.type === Token.Punctuator) {
+ throwUnexpected(token);
+ } else {
+ key = parseObjectPropertyKey();
+ expect(':');
+ return {
+ type: Syntax.Property,
+ key: key,
+ value: parseAssignmentExpression(),
+ kind: 'init'
+ };
+ }
+ }
+
+ function parseObjectInitialiser() {
+ var properties = [], property, name, kind, map = {}, toString = String;
+
+ expect('{');
+
+ while (!match('}')) {
+ property = parseObjectProperty();
+
+ if (property.key.type === Syntax.Identifier) {
+ name = property.key.name;
+ } else {
+ name = toString(property.key.value);
+ }
+ kind = (property.kind === 'init') ? PropertyKind.Data : (property.kind === 'get') ? PropertyKind.Get : PropertyKind.Set;
+ if (Object.prototype.hasOwnProperty.call(map, name)) {
+ if (map[name] === PropertyKind.Data) {
+ if (strict && kind === PropertyKind.Data) {
+ throwErrorTolerant({}, Messages.StrictDuplicateProperty);
+ } else if (kind !== PropertyKind.Data) {
+ throwErrorTolerant({}, Messages.AccessorDataProperty);
+ }
+ } else {
+ if (kind === PropertyKind.Data) {
+ throwErrorTolerant({}, Messages.AccessorDataProperty);
+ } else if (map[name] & kind) {
+ throwErrorTolerant({}, Messages.AccessorGetSet);
+ }
+ }
+ map[name] |= kind;
+ } else {
+ map[name] = kind;
+ }
+
+ properties.push(property);
+
+ if (!match('}')) {
+ expect(',');
+ }
+ }
+
+ expect('}');
+
+ return {
+ type: Syntax.ObjectExpression,
+ properties: properties
+ };
+ }
+
+ // 11.1.6 The Grouping Operator
+
+ function parseGroupExpression() {
+ var expr;
+
+ expect('(');
+
+ expr = parseExpression();
+
+ expect(')');
+
+ return expr;
+ }
+
+
+ // 11.1 Primary Expressions
+
+ function parsePrimaryExpression() {
+ var token = lookahead(),
+ type = token.type;
+
+ if (type === Token.Identifier) {
+ return {
+ type: Syntax.Identifier,
+ name: lex().value
+ };
+ }
+
+ if (type === Token.StringLiteral || type === Token.NumericLiteral) {
+ if (strict && token.octal) {
+ throwErrorTolerant(token, Messages.StrictOctalLiteral);
+ }
+ return createLiteral(lex());
+ }
+
+ if (type === Token.Keyword) {
+ if (matchKeyword('this')) {
+ lex();
+ return {
+ type: Syntax.ThisExpression
+ };
+ }
+
+ if (matchKeyword('function')) {
+ return parseFunctionExpression();
+ }
+ }
+
+ if (type === Token.BooleanLiteral) {
+ lex();
+ token.value = (token.value === 'true');
+ return createLiteral(token);
+ }
+
+ if (type === Token.NullLiteral) {
+ lex();
+ token.value = null;
+ return createLiteral(token);
+ }
+
+ if (match('[')) {
+ return parseArrayInitialiser();
+ }
+
+ if (match('{')) {
+ return parseObjectInitialiser();
+ }
+
+ if (match('(')) {
+ return parseGroupExpression();
+ }
+
+ if (match('/') || match('/=')) {
+ return createLiteral(scanRegExp());
+ }
+
+ return throwUnexpected(lex());
+ }
+
+ // 11.2 Left-Hand-Side Expressions
+
+ function parseArguments() {
+ var args = [];
+
+ expect('(');
+
+ if (!match(')')) {
+ while (index < length) {
+ args.push(parseAssignmentExpression());
+ if (match(')')) {
+ break;
+ }
+ expect(',');
+ }
+ }
+
+ expect(')');
+
+ return args;
+ }
+
+ function parseNonComputedProperty() {
+ var token = lex();
+
+ if (!isIdentifierName(token)) {
+ throwUnexpected(token);
+ }
+
+ return {
+ type: Syntax.Identifier,
+ name: token.value
+ };
+ }
+
+ function parseNonComputedMember() {
+ expect('.');
+
+ return parseNonComputedProperty();
+ }
+
+ function parseComputedMember() {
+ var expr;
+
+ expect('[');
+
+ expr = parseExpression();
+
+ expect(']');
+
+ return expr;
+ }
+
+ function parseNewExpression() {
+ var expr;
+
+ expectKeyword('new');
+
+ expr = {
+ type: Syntax.NewExpression,
+ callee: parseLeftHandSideExpression(),
+ 'arguments': []
+ };
+
+ if (match('(')) {
+ expr['arguments'] = parseArguments();
+ }
+
+ return expr;
+ }
+
+ function parseLeftHandSideExpressionAllowCall() {
+ var expr;
+
+ expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();
+
+ while (match('.') || match('[') || match('(')) {
+ if (match('(')) {
+ expr = {
+ type: Syntax.CallExpression,
+ callee: expr,
+ 'arguments': parseArguments()
+ };
+ } else if (match('[')) {
+ expr = {
+ type: Syntax.MemberExpression,
+ computed: true,
+ object: expr,
+ property: parseComputedMember()
+ };
+ } else {
+ expr = {
+ type: Syntax.MemberExpression,
+ computed: false,
+ object: expr,
+ property: parseNonComputedMember()
+ };
+ }
+ }
+
+ return expr;
+ }
+
+
+ function parseLeftHandSideExpression() {
+ var expr;
+
+ expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();
+
+ while (match('.') || match('[')) {
+ if (match('[')) {
+ expr = {
+ type: Syntax.MemberExpression,
+ computed: true,
+ object: expr,
+ property: parseComputedMember()
+ };
+ } else {
+ expr = {
+ type: Syntax.MemberExpression,
+ computed: false,
+ object: expr,
+ property: parseNonComputedMember()
+ };
+ }
+ }
+
+ return expr;
+ }
+
+ // 11.3 Postfix Expressions
+
+ function parsePostfixExpression() {
+ var expr = parseLeftHandSideExpressionAllowCall(), token;
+
+ token = lookahead();
+ if (token.type !== Token.Punctuator) {
+ return expr;
+ }
+
+ if ((match('++') || match('--')) && !peekLineTerminator()) {
+ // 11.3.1, 11.3.2
+ if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {
+ throwErrorTolerant({}, Messages.StrictLHSPostfix);
+ }
+
+ if (!isLeftHandSide(expr)) {
+ throwError({}, Messages.InvalidLHSInAssignment);
+ }
+
+ expr = {
+ type: Syntax.UpdateExpression,
+ operator: lex().value,
+ argument: expr,
+ prefix: false
+ };
+ }
+
+ return expr;
+ }
+
+ // 11.4 Unary Operators
+
+ function parseUnaryExpression() {
+ var token, expr;
+
+ token = lookahead();
+ if (token.type !== Token.Punctuator && token.type !== Token.Keyword) {
+ return parsePostfixExpression();
+ }
+
+ if (match('++') || match('--')) {
+ token = lex();
+ expr = parseUnaryExpression();
+ // 11.4.4, 11.4.5
+ if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {
+ throwErrorTolerant({}, Messages.StrictLHSPrefix);
+ }
+
+ if (!isLeftHandSide(expr)) {
+ throwError({}, Messages.InvalidLHSInAssignment);
+ }
+
+ expr = {
+ type: Syntax.UpdateExpression,
+ operator: token.value,
+ argument: expr,
+ prefix: true
+ };
+ return expr;
+ }
+
+ if (match('+') || match('-') || match('~') || match('!')) {
+ expr = {
+ type: Syntax.UnaryExpression,
+ operator: lex().value,
+ argument: parseUnaryExpression(),
+ prefix: true
+ };
+ return expr;
+ }
+
+ if (matchKeyword('delete') || matchKeyword('void') || matchKeyword('typeof')) {
+ expr = {
+ type: Syntax.UnaryExpression,
+ operator: lex().value,
+ argument: parseUnaryExpression(),
+ prefix: true
+ };
+ if (strict && expr.operator === 'delete' && expr.argument.type === Syntax.Identifier) {
+ throwErrorTolerant({}, Messages.StrictDelete);
+ }
+ return expr;
+ }
+
+ return parsePostfixExpression();
+ }
+
+ // 11.5 Multiplicative Operators
+
+ function parseMultiplicativeExpression() {
+ var expr = parseUnaryExpression();
+
+ while (match('*') || match('/') || match('%')) {
+ expr = {
+ type: Syntax.BinaryExpression,
+ operator: lex().value,
+ left: expr,
+ right: parseUnaryExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ // 11.6 Additive Operators
+
+ function parseAdditiveExpression() {
+ var expr = parseMultiplicativeExpression();
+
+ while (match('+') || match('-')) {
+ expr = {
+ type: Syntax.BinaryExpression,
+ operator: lex().value,
+ left: expr,
+ right: parseMultiplicativeExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ // 11.7 Bitwise Shift Operators
+
+ function parseShiftExpression() {
+ var expr = parseAdditiveExpression();
+
+ while (match('<<') || match('>>') || match('>>>')) {
+ expr = {
+ type: Syntax.BinaryExpression,
+ operator: lex().value,
+ left: expr,
+ right: parseAdditiveExpression()
+ };
+ }
+
+ return expr;
+ }
+ // 11.8 Relational Operators
+
+ function parseRelationalExpression() {
+ var expr, previousAllowIn;
+
+ previousAllowIn = state.allowIn;
+ state.allowIn = true;
+
+ expr = parseShiftExpression();
+
+ while (match('<') || match('>') || match('<=') || match('>=') || (previousAllowIn && matchKeyword('in')) || matchKeyword('instanceof')) {
+ expr = {
+ type: Syntax.BinaryExpression,
+ operator: lex().value,
+ left: expr,
+ right: parseShiftExpression()
+ };
+ }
+
+ state.allowIn = previousAllowIn;
+ return expr;
+ }
+
+ // 11.9 Equality Operators
+
+ function parseEqualityExpression() {
+ var expr = parseRelationalExpression();
+
+ while (match('==') || match('!=') || match('===') || match('!==')) {
+ expr = {
+ type: Syntax.BinaryExpression,
+ operator: lex().value,
+ left: expr,
+ right: parseRelationalExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ // 11.10 Binary Bitwise Operators
+
+ function parseBitwiseANDExpression() {
+ var expr = parseEqualityExpression();
+
+ while (match('&')) {
+ lex();
+ expr = {
+ type: Syntax.BinaryExpression,
+ operator: '&',
+ left: expr,
+ right: parseEqualityExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ function parseBitwiseXORExpression() {
+ var expr = parseBitwiseANDExpression();
+
+ while (match('^')) {
+ lex();
+ expr = {
+ type: Syntax.BinaryExpression,
+ operator: '^',
+ left: expr,
+ right: parseBitwiseANDExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ function parseBitwiseORExpression() {
+ var expr = parseBitwiseXORExpression();
+
+ while (match('|')) {
+ lex();
+ expr = {
+ type: Syntax.BinaryExpression,
+ operator: '|',
+ left: expr,
+ right: parseBitwiseXORExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ // 11.11 Binary Logical Operators
+
+ function parseLogicalANDExpression() {
+ var expr = parseBitwiseORExpression();
+
+ while (match('&&')) {
+ lex();
+ expr = {
+ type: Syntax.LogicalExpression,
+ operator: '&&',
+ left: expr,
+ right: parseBitwiseORExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ function parseLogicalORExpression() {
+ var expr = parseLogicalANDExpression();
+
+ while (match('||')) {
+ lex();
+ expr = {
+ type: Syntax.LogicalExpression,
+ operator: '||',
+ left: expr,
+ right: parseLogicalANDExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ // 11.12 Conditional Operator
+
+ function parseConditionalExpression() {
+ var expr, previousAllowIn, consequent;
+
+ expr = parseLogicalORExpression();
+
+ if (match('?')) {
+ lex();
+ previousAllowIn = state.allowIn;
+ state.allowIn = true;
+ consequent = parseAssignmentExpression();
+ state.allowIn = previousAllowIn;
+ expect(':');
+
+ expr = {
+ type: Syntax.ConditionalExpression,
+ test: expr,
+ consequent: consequent,
+ alternate: parseAssignmentExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ // 11.13 Assignment Operators
+
+ function parseAssignmentExpression() {
+ var token, expr;
+
+ token = lookahead();
+ expr = parseConditionalExpression();
+
+ if (matchAssign()) {
+ // LeftHandSideExpression
+ if (!isLeftHandSide(expr)) {
+ throwError({}, Messages.InvalidLHSInAssignment);
+ }
+
+ // 11.13.1
+ if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {
+ throwErrorTolerant(token, Messages.StrictLHSAssignment);
+ }
+
+ expr = {
+ type: Syntax.AssignmentExpression,
+ operator: lex().value,
+ left: expr,
+ right: parseAssignmentExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ // 11.14 Comma Operator
+
+ function parseExpression() {
+ var expr = parseAssignmentExpression();
+
+ if (match(',')) {
+ expr = {
+ type: Syntax.SequenceExpression,
+ expressions: [ expr ]
+ };
+
+ while (index < length) {
+ if (!match(',')) {
+ break;
+ }
+ lex();
+ expr.expressions.push(parseAssignmentExpression());
+ }
+
+ }
+ return expr;
+ }
+
+ // 12.1 Block
+
+ function parseStatementList() {
+ var list = [],
+ statement;
+
+ while (index < length) {
+ if (match('}')) {
+ break;
+ }
+ statement = parseSourceElement();
+ if (typeof statement === 'undefined') {
+ break;
+ }
+ list.push(statement);
+ }
+
+ return list;
+ }
+
+ function parseBlock() {
+ var block;
+
+ expect('{');
+
+ block = parseStatementList();
+
+ expect('}');
+
+ return {
+ type: Syntax.BlockStatement,
+ body: block
+ };
+ }
+
+ // 12.2 Variable Statement
+
+ function parseVariableIdentifier() {
+ var token = lex();
+
+ if (token.type !== Token.Identifier) {
+ throwUnexpected(token);
+ }
+
+ return {
+ type: Syntax.Identifier,
+ name: token.value
+ };
+ }
+
+ function parseVariableDeclaration(kind) {
+ var id = parseVariableIdentifier(),
+ init = null;
+
+ // 12.2.1
+ if (strict && isRestrictedWord(id.name)) {
+ throwErrorTolerant({}, Messages.StrictVarName);
+ }
+
+ if (kind === 'const') {
+ expect('=');
+ init = parseAssignmentExpression();
+ } else if (match('=')) {
+ lex();
+ init = parseAssignmentExpression();
+ }
+
+ return {
+ type: Syntax.VariableDeclarator,
+ id: id,
+ init: init
+ };
+ }
+
+ function parseVariableDeclarationList(kind) {
+ var list = [];
+
+ do {
+ list.push(parseVariableDeclaration(kind));
+ if (!match(',')) {
+ break;
+ }
+ lex();
+ } while (index < length);
+
+ return list;
+ }
+
+ function parseVariableStatement() {
+ var declarations;
+
+ expectKeyword('var');
+
+ declarations = parseVariableDeclarationList();
+
+ consumeSemicolon();
+
+ return {
+ type: Syntax.VariableDeclaration,
+ declarations: declarations,
+ kind: 'var'
+ };
+ }
+
+ // kind may be `const` or `let`
+ // Both are experimental and not in the specification yet.
+ // see http://wiki.ecmascript.org/doku.php?id=harmony:const
+ // and http://wiki.ecmascript.org/doku.php?id=harmony:let
+ function parseConstLetDeclaration(kind) {
+ var declarations;
+
+ expectKeyword(kind);
+
+ declarations = parseVariableDeclarationList(kind);
+
+ consumeSemicolon();
+
+ return {
+ type: Syntax.VariableDeclaration,
+ declarations: declarations,
+ kind: kind
+ };
+ }
+
+ // 12.3 Empty Statement
+
+ function parseEmptyStatement() {
+ expect(';');
+
+ return {
+ type: Syntax.EmptyStatement
+ };
+ }
+
+ // 12.4 Expression Statement
+
+ function parseExpressionStatement() {
+ var expr = parseExpression();
+
+ consumeSemicolon();
+
+ return {
+ type: Syntax.ExpressionStatement,
+ expression: expr
+ };
+ }
+
+ // 12.5 If statement
+
+ function parseIfStatement() {
+ var test, consequent, alternate;
+
+ expectKeyword('if');
+
+ expect('(');
+
+ test = parseExpression();
+
+ expect(')');
+
+ consequent = parseStatement();
+
+ if (matchKeyword('else')) {
+ lex();
+ alternate = parseStatement();
+ } else {
+ alternate = null;
+ }
+
+ return {
+ type: Syntax.IfStatement,
+ test: test,
+ consequent: consequent,
+ alternate: alternate
+ };
+ }
+
+ // 12.6 Iteration Statements
+
+ function parseDoWhileStatement() {
+ var body, test, oldInIteration;
+
+ expectKeyword('do');
+
+ oldInIteration = state.inIteration;
+ state.inIteration = true;
+
+ body = parseStatement();
+
+ state.inIteration = oldInIteration;
+
+ expectKeyword('while');
+
+ expect('(');
+
+ test = parseExpression();
+
+ expect(')');
+
+ if (match(';')) {
+ lex();
+ }
+
+ return {
+ type: Syntax.DoWhileStatement,
+ body: body,
+ test: test
+ };
+ }
+
+ function parseWhileStatement() {
+ var test, body, oldInIteration;
+
+ expectKeyword('while');
+
+ expect('(');
+
+ test = parseExpression();
+
+ expect(')');
+
+ oldInIteration = state.inIteration;
+ state.inIteration = true;
+
+ body = parseStatement();
+
+ state.inIteration = oldInIteration;
+
+ return {
+ type: Syntax.WhileStatement,
+ test: test,
+ body: body
+ };
+ }
+
+ function parseForVariableDeclaration() {
+ var token = lex();
+
+ return {
+ type: Syntax.VariableDeclaration,
+ declarations: parseVariableDeclarationList(),
+ kind: token.value
+ };
+ }
+
+ function parseForStatement() {
+ var init, test, update, left, right, body, oldInIteration;
+
+ init = test = update = null;
+
+ expectKeyword('for');
+
+ expect('(');
+
+ if (match(';')) {
+ lex();
+ } else {
+ if (matchKeyword('var') || matchKeyword('let')) {
+ state.allowIn = false;
+ init = parseForVariableDeclaration();
+ state.allowIn = true;
+
+ if (init.declarations.length === 1 && matchKeyword('in')) {
+ lex();
+ left = init;
+ right = parseExpression();
+ init = null;
+ }
+ } else {
+ state.allowIn = false;
+ init = parseExpression();
+ state.allowIn = true;
+
+ if (matchKeyword('in')) {
+ // LeftHandSideExpression
+ if (!isLeftHandSide(init)) {
+ throwError({}, Messages.InvalidLHSInForIn);
+ }
+
+ lex();
+ left = init;
+ right = parseExpression();
+ init = null;
+ }
+ }
+
+ if (typeof left === 'undefined') {
+ expect(';');
+ }
+ }
+
+ if (typeof left === 'undefined') {
+
+ if (!match(';')) {
+ test = parseExpression();
+ }
+ expect(';');
+
+ if (!match(')')) {
+ update = parseExpression();
+ }
+ }
+
+ expect(')');
+
+ oldInIteration = state.inIteration;
+ state.inIteration = true;
+
+ body = parseStatement();
+
+ state.inIteration = oldInIteration;
+
+ if (typeof left === 'undefined') {
+ return {
+ type: Syntax.ForStatement,
+ init: init,
+ test: test,
+ update: update,
+ body: body
+ };
+ }
+
+ return {
+ type: Syntax.ForInStatement,
+ left: left,
+ right: right,
+ body: body,
+ each: false
+ };
+ }
+
+ // 12.7 The continue statement
+
+ function parseContinueStatement() {
+ var token, label = null;
+
+ expectKeyword('continue');
+
+ // Optimize the most common form: 'continue;'.
+ if (source[index] === ';') {
+ lex();
+
+ if (!state.inIteration) {
+ throwError({}, Messages.IllegalContinue);
+ }
+
+ return {
+ type: Syntax.ContinueStatement,
+ label: null
+ };
+ }
+
+ if (peekLineTerminator()) {
+ if (!state.inIteration) {
+ throwError({}, Messages.IllegalContinue);
+ }
+
+ return {
+ type: Syntax.ContinueStatement,
+ label: null
+ };
+ }
+
+ token = lookahead();
+ if (token.type === Token.Identifier) {
+ label = parseVariableIdentifier();
+
+ if (!Object.prototype.hasOwnProperty.call(state.labelSet, label.name)) {
+ throwError({}, Messages.UnknownLabel, label.name);
+ }
+ }
+
+ consumeSemicolon();
+
+ if (label === null && !state.inIteration) {
+ throwError({}, Messages.IllegalContinue);
+ }
+
+ return {
+ type: Syntax.ContinueStatement,
+ label: label
+ };
+ }
+
+ // 12.8 The break statement
+
+ function parseBreakStatement() {
+ var token, label = null;
+
+ expectKeyword('break');
+
+ // Optimize the most common form: 'break;'.
+ if (source[index] === ';') {
+ lex();
+
+ if (!(state.inIteration || state.inSwitch)) {
+ throwError({}, Messages.IllegalBreak);
+ }
+
+ return {
+ type: Syntax.BreakStatement,
+ label: null
+ };
+ }
+
+ if (peekLineTerminator()) {
+ if (!(state.inIteration || state.inSwitch)) {
+ throwError({}, Messages.IllegalBreak);
+ }
+
+ return {
+ type: Syntax.BreakStatement,
+ label: null
+ };
+ }
+
+ token = lookahead();
+ if (token.type === Token.Identifier) {
+ label = parseVariableIdentifier();
+
+ if (!Object.prototype.hasOwnProperty.call(state.labelSet, label.name)) {
+ throwError({}, Messages.UnknownLabel, label.name);
+ }
+ }
+
+ consumeSemicolon();
+
+ if (label === null && !(state.inIteration || state.inSwitch)) {
+ throwError({}, Messages.IllegalBreak);
+ }
+
+ return {
+ type: Syntax.BreakStatement,
+ label: label
+ };
+ }
+
+ // 12.9 The return statement
+
+ function parseReturnStatement() {
+ var token, argument = null;
+
+ expectKeyword('return');
+
+ if (!state.inFunctionBody) {
+ throwErrorTolerant({}, Messages.IllegalReturn);
+ }
+
+ // 'return' followed by a space and an identifier is very common.
+ if (source[index] === ' ') {
+ if (isIdentifierStart(source[index + 1])) {
+ argument = parseExpression();
+ consumeSemicolon();
+ return {
+ type: Syntax.ReturnStatement,
+ argument: argument
+ };
+ }
+ }
+
+ if (peekLineTerminator()) {
+ return {
+ type: Syntax.ReturnStatement,
+ argument: null
+ };
+ }
+
+ if (!match(';')) {
+ token = lookahead();
+ if (!match('}') && token.type !== Token.EOF) {
+ argument = parseExpression();
+ }
+ }
+
+ consumeSemicolon();
+
+ return {
+ type: Syntax.ReturnStatement,
+ argument: argument
+ };
+ }
+
+ // 12.10 The with statement
+
+ function parseWithStatement() {
+ var object, body;
+
+ if (strict) {
+ throwErrorTolerant({}, Messages.StrictModeWith);
+ }
+
+ expectKeyword('with');
+
+ expect('(');
+
+ object = parseExpression();
+
+ expect(')');
+
+ body = parseStatement();
+
+ return {
+ type: Syntax.WithStatement,
+ object: object,
+ body: body
+ };
+ }
+
+ // 12.10 The swith statement
+
+ function parseSwitchCase() {
+ var test,
+ consequent = [],
+ statement;
+
+ if (matchKeyword('default')) {
+ lex();
+ test = null;
+ } else {
+ expectKeyword('case');
+ test = parseExpression();
+ }
+ expect(':');
+
+ while (index < length) {
+ if (match('}') || matchKeyword('default') || matchKeyword('case')) {
+ break;
+ }
+ statement = parseStatement();
+ if (typeof statement === 'undefined') {
+ break;
+ }
+ consequent.push(statement);
+ }
+
+ return {
+ type: Syntax.SwitchCase,
+ test: test,
+ consequent: consequent
+ };
+ }
+
+ function parseSwitchStatement() {
+ var discriminant, cases, clause, oldInSwitch, defaultFound;
+
+ expectKeyword('switch');
+
+ expect('(');
+
+ discriminant = parseExpression();
+
+ expect(')');
+
+ expect('{');
+
+ if (match('}')) {
+ lex();
+ return {
+ type: Syntax.SwitchStatement,
+ discriminant: discriminant
+ };
+ }
+
+ cases = [];
+
+ oldInSwitch = state.inSwitch;
+ state.inSwitch = true;
+ defaultFound = false;
+
+ while (index < length) {
+ if (match('}')) {
+ break;
+ }
+ clause = parseSwitchCase();
+ if (clause.test === null) {
+ if (defaultFound) {
+ throwError({}, Messages.MultipleDefaultsInSwitch);
+ }
+ defaultFound = true;
+ }
+ cases.push(clause);
+ }
+
+ state.inSwitch = oldInSwitch;
+
+ expect('}');
+
+ return {
+ type: Syntax.SwitchStatement,
+ discriminant: discriminant,
+ cases: cases
+ };
+ }
+
+ // 12.13 The throw statement
+
+ function parseThrowStatement() {
+ var argument;
+
+ expectKeyword('throw');
+
+ if (peekLineTerminator()) {
+ throwError({}, Messages.NewlineAfterThrow);
+ }
+
+ argument = parseExpression();
+
+ consumeSemicolon();
+
+ return {
+ type: Syntax.ThrowStatement,
+ argument: argument
+ };
+ }
+
+ // 12.14 The try statement
+
+ function parseCatchClause() {
+ var param;
+
+ expectKeyword('catch');
+
+ expect('(');
+ if (match(')')) {
+ throwUnexpected(lookahead());
+ }
+
+ param = parseVariableIdentifier();
+ // 12.14.1
+ if (strict && isRestrictedWord(param.name)) {
+ throwErrorTolerant({}, Messages.StrictCatchVariable);
+ }
+
+ expect(')');
+
+ return {
+ type: Syntax.CatchClause,
+ param: param,
+ body: parseBlock()
+ };
+ }
+
+ function parseTryStatement() {
+ var block, handlers = [], finalizer = null;
+
+ expectKeyword('try');
+
+ block = parseBlock();
+
+ if (matchKeyword('catch')) {
+ handlers.push(parseCatchClause());
+ }
+
+ if (matchKeyword('finally')) {
+ lex();
+ finalizer = parseBlock();
+ }
+
+ if (handlers.length === 0 && !finalizer) {
+ throwError({}, Messages.NoCatchOrFinally);
+ }
+
+ return {
+ type: Syntax.TryStatement,
+ block: block,
+ guardedHandlers: [],
+ handlers: handlers,
+ finalizer: finalizer
+ };
+ }
+
+ // 12.15 The debugger statement
+
+ function parseDebuggerStatement() {
+ expectKeyword('debugger');
+
+ consumeSemicolon();
+
+ return {
+ type: Syntax.DebuggerStatement
+ };
+ }
+
+ // 12 Statements
+
+ function parseStatement() {
+ var token = lookahead(),
+ expr,
+ labeledBody;
+
+ if (token.type === Token.EOF) {
+ throwUnexpected(token);
+ }
+
+ if (token.type === Token.Punctuator) {
+ switch (token.value) {
+ case ';':
+ return parseEmptyStatement();
+ case '{':
+ return parseBlock();
+ case '(':
+ return parseExpressionStatement();
+ default:
+ break;
+ }
+ }
+
+ if (token.type === Token.Keyword) {
+ switch (token.value) {
+ case 'break':
+ return parseBreakStatement();
+ case 'continue':
+ return parseContinueStatement();
+ case 'debugger':
+ return parseDebuggerStatement();
+ case 'do':
+ return parseDoWhileStatement();
+ case 'for':
+ return parseForStatement();
+ case 'function':
+ return parseFunctionDeclaration();
+ case 'if':
+ return parseIfStatement();
+ case 'return':
+ return parseReturnStatement();
+ case 'switch':
+ return parseSwitchStatement();
+ case 'throw':
+ return parseThrowStatement();
+ case 'try':
+ return parseTryStatement();
+ case 'var':
+ return parseVariableStatement();
+ case 'while':
+ return parseWhileStatement();
+ case 'with':
+ return parseWithStatement();
+ default:
+ break;
+ }
+ }
+
+ expr = parseExpression();
+
+ // 12.12 Labelled Statements
+ if ((expr.type === Syntax.Identifier) && match(':')) {
+ lex();
+
+ if (Object.prototype.hasOwnProperty.call(state.labelSet, expr.name)) {
+ throwError({}, Messages.Redeclaration, 'Label', expr.name);
+ }
+
+ state.labelSet[expr.name] = true;
+ labeledBody = parseStatement();
+ delete state.labelSet[expr.name];
+
+ return {
+ type: Syntax.LabeledStatement,
+ label: expr,
+ body: labeledBody
+ };
+ }
+
+ consumeSemicolon();
+
+ return {
+ type: Syntax.ExpressionStatement,
+ expression: expr
+ };
+ }
+
+ // 13 Function Definition
+
+ function parseFunctionSourceElements() {
+ var sourceElement, sourceElements = [], token, directive, firstRestricted,
+ oldLabelSet, oldInIteration, oldInSwitch, oldInFunctionBody;
+
+ expect('{');
+
+ while (index < length) {
+ token = lookahead();
+ if (token.type !== Token.StringLiteral) {
+ break;
+ }
+
+ sourceElement = parseSourceElement();
+ sourceElements.push(sourceElement);
+ if (sourceElement.expression.type !== Syntax.Literal) {
+ // this is not directive
+ break;
+ }
+ directive = sliceSource(token.range[0] + 1, token.range[1] - 1);
+ if (directive === 'use strict') {
+ strict = true;
+ if (firstRestricted) {
+ throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral);
+ }
+ } else {
+ if (!firstRestricted && token.octal) {
+ firstRestricted = token;
+ }
+ }
+ }
+
+ oldLabelSet = state.labelSet;
+ oldInIteration = state.inIteration;
+ oldInSwitch = state.inSwitch;
+ oldInFunctionBody = state.inFunctionBody;
+
+ state.labelSet = {};
+ state.inIteration = false;
+ state.inSwitch = false;
+ state.inFunctionBody = true;
+
+ while (index < length) {
+ if (match('}')) {
+ break;
+ }
+ sourceElement = parseSourceElement();
+ if (typeof sourceElement === 'undefined') {
+ break;
+ }
+ sourceElements.push(sourceElement);
+ }
+
+ expect('}');
+
+ state.labelSet = oldLabelSet;
+ state.inIteration = oldInIteration;
+ state.inSwitch = oldInSwitch;
+ state.inFunctionBody = oldInFunctionBody;
+
+ return {
+ type: Syntax.BlockStatement,
+ body: sourceElements
+ };
+ }
+
+ function parseFunctionDeclaration() {
+ var id, param, params = [], body, token, stricted, firstRestricted, message, previousStrict, paramSet;
+
+ expectKeyword('function');
+ token = lookahead();
+ id = parseVariableIdentifier();
+ if (strict) {
+ if (isRestrictedWord(token.value)) {
+ throwErrorTolerant(token, Messages.StrictFunctionName);
+ }
+ } else {
+ if (isRestrictedWord(token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictFunctionName;
+ } else if (isStrictModeReservedWord(token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictReservedWord;
+ }
+ }
+
+ expect('(');
+
+ if (!match(')')) {
+ paramSet = {};
+ while (index < length) {
+ token = lookahead();
+ param = parseVariableIdentifier();
+ if (strict) {
+ if (isRestrictedWord(token.value)) {
+ stricted = token;
+ message = Messages.StrictParamName;
+ }
+ if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {
+ stricted = token;
+ message = Messages.StrictParamDupe;
+ }
+ } else if (!firstRestricted) {
+ if (isRestrictedWord(token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictParamName;
+ } else if (isStrictModeReservedWord(token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictReservedWord;
+ } else if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictParamDupe;
+ }
+ }
+ params.push(param);
+ paramSet[param.name] = true;
+ if (match(')')) {
+ break;
+ }
+ expect(',');
+ }
+ }
+
+ expect(')');
+
+ previousStrict = strict;
+ body = parseFunctionSourceElements();
+ if (strict && firstRestricted) {
+ throwError(firstRestricted, message);
+ }
+ if (strict && stricted) {
+ throwErrorTolerant(stricted, message);
+ }
+ strict = previousStrict;
+
+ return {
+ type: Syntax.FunctionDeclaration,
+ id: id,
+ params: params,
+ defaults: [],
+ body: body,
+ rest: null,
+ generator: false,
+ expression: false
+ };
+ }
+
+ function parseFunctionExpression() {
+ var token, id = null, stricted, firstRestricted, message, param, params = [], body, previousStrict, paramSet;
+
+ expectKeyword('function');
+
+ if (!match('(')) {
+ token = lookahead();
+ id = parseVariableIdentifier();
+ if (strict) {
+ if (isRestrictedWord(token.value)) {
+ throwErrorTolerant(token, Messages.StrictFunctionName);
+ }
+ } else {
+ if (isRestrictedWord(token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictFunctionName;
+ } else if (isStrictModeReservedWord(token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictReservedWord;
+ }
+ }
+ }
+
+ expect('(');
+
+ if (!match(')')) {
+ paramSet = {};
+ while (index < length) {
+ token = lookahead();
+ param = parseVariableIdentifier();
+ if (strict) {
+ if (isRestrictedWord(token.value)) {
+ stricted = token;
+ message = Messages.StrictParamName;
+ }
+ if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {
+ stricted = token;
+ message = Messages.StrictParamDupe;
+ }
+ } else if (!firstRestricted) {
+ if (isRestrictedWord(token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictParamName;
+ } else if (isStrictModeReservedWord(token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictReservedWord;
+ } else if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictParamDupe;
+ }
+ }
+ params.push(param);
+ paramSet[param.name] = true;
+ if (match(')')) {
+ break;
+ }
+ expect(',');
+ }
+ }
+
+ expect(')');
+
+ previousStrict = strict;
+ body = parseFunctionSourceElements();
+ if (strict && firstRestricted) {
+ throwError(firstRestricted, message);
+ }
+ if (strict && stricted) {
+ throwErrorTolerant(stricted, message);
+ }
+ strict = previousStrict;
+
+ return {
+ type: Syntax.FunctionExpression,
+ id: id,
+ params: params,
+ defaults: [],
+ body: body,
+ rest: null,
+ generator: false,
+ expression: false
+ };
+ }
+
+ // 14 Program
+
+ function parseSourceElement() {
+ var token = lookahead();
+
+ if (token.type === Token.Keyword) {
+ switch (token.value) {
+ case 'const':
+ case 'let':
+ return parseConstLetDeclaration(token.value);
+ case 'function':
+ return parseFunctionDeclaration();
+ default:
+ return parseStatement();
+ }
+ }
+
+ if (token.type !== Token.EOF) {
+ return parseStatement();
+ }
+ }
+
+ function parseSourceElements() {
+ var sourceElement, sourceElements = [], token, directive, firstRestricted;
+
+ while (index < length) {
+ token = lookahead();
+ if (token.type !== Token.StringLiteral) {
+ break;
+ }
+
+ sourceElement = parseSourceElement();
+ sourceElements.push(sourceElement);
+ if (sourceElement.expression.type !== Syntax.Literal) {
+ // this is not directive
+ break;
+ }
+ directive = sliceSource(token.range[0] + 1, token.range[1] - 1);
+ if (directive === 'use strict') {
+ strict = true;
+ if (firstRestricted) {
+ throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral);
+ }
+ } else {
+ if (!firstRestricted && token.octal) {
+ firstRestricted = token;
+ }
+ }
+ }
+
+ while (index < length) {
+ sourceElement = parseSourceElement();
+ if (typeof sourceElement === 'undefined') {
+ break;
+ }
+ sourceElements.push(sourceElement);
+ }
+ return sourceElements;
+ }
+
+ function parseProgram() {
+ var program;
+ strict = false;
+ program = {
+ type: Syntax.Program,
+ body: parseSourceElements()
+ };
+ return program;
+ }
+
+ // The following functions are needed only when the option to preserve
+ // the comments is active.
+
+ function addComment(type, value, start, end, loc) {
+ assert(typeof start === 'number', 'Comment must have valid position');
+
+ // Because the way the actual token is scanned, often the comments
+ // (if any) are skipped twice during the lexical analysis.
+ // Thus, we need to skip adding a comment if the comment array already
+ // handled it.
+ if (extra.comments.length > 0) {
+ if (extra.comments[extra.comments.length - 1].range[1] > start) {
+ return;
+ }
+ }
+
+ extra.comments.push({
+ type: type,
+ value: value,
+ range: [start, end],
+ loc: loc
+ });
+ }
+
+ function scanComment() {
+ var comment, ch, loc, start, blockComment, lineComment;
+
+ comment = '';
+ blockComment = false;
+ lineComment = false;
+
+ while (index < length) {
+ ch = source[index];
+
+ if (lineComment) {
+ ch = source[index++];
+ if (isLineTerminator(ch)) {
+ loc.end = {
+ line: lineNumber,
+ column: index - lineStart - 1
+ };
+ lineComment = false;
+ addComment('Line', comment, start, index - 1, loc);
+ if (ch === '\r' && source[index] === '\n') {
+ ++index;
+ }
+ ++lineNumber;
+ lineStart = index;
+ comment = '';
+ } else if (index >= length) {
+ lineComment = false;
+ comment += ch;
+ loc.end = {
+ line: lineNumber,
+ column: length - lineStart
+ };
+ addComment('Line', comment, start, length, loc);
+ } else {
+ comment += ch;
+ }
+ } else if (blockComment) {
+ if (isLineTerminator(ch)) {
+ if (ch === '\r' && source[index + 1] === '\n') {
+ ++index;
+ comment += '\r\n';
+ } else {
+ comment += ch;
+ }
+ ++lineNumber;
+ ++index;
+ lineStart = index;
+ if (index >= length) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ } else {
+ ch = source[index++];
+ if (index >= length) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ comment += ch;
+ if (ch === '*') {
+ ch = source[index];
+ if (ch === '/') {
+ comment = comment.substr(0, comment.length - 1);
+ blockComment = false;
+ ++index;
+ loc.end = {
+ line: lineNumber,
+ column: index - lineStart
+ };
+ addComment('Block', comment, start, index, loc);
+ comment = '';
+ }
+ }
+ }
+ } else if (ch === '/') {
+ ch = source[index + 1];
+ if (ch === '/') {
+ loc = {
+ start: {
+ line: lineNumber,
+ column: index - lineStart
+ }
+ };
+ start = index;
+ index += 2;
+ lineComment = true;
+ if (index >= length) {
+ loc.end = {
+ line: lineNumber,
+ column: index - lineStart
+ };
+ lineComment = false;
+ addComment('Line', comment, start, index, loc);
+ }
+ } else if (ch === '*') {
+ start = index;
+ index += 2;
+ blockComment = true;
+ loc = {
+ start: {
+ line: lineNumber,
+ column: index - lineStart - 2
+ }
+ };
+ if (index >= length) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ } else {
+ break;
+ }
+ } else if (isWhiteSpace(ch)) {
+ ++index;
+ } else if (isLineTerminator(ch)) {
+ ++index;
+ if (ch === '\r' && source[index] === '\n') {
+ ++index;
+ }
+ ++lineNumber;
+ lineStart = index;
+ } else {
+ break;
+ }
+ }
+ }
+
+ function filterCommentLocation() {
+ var i, entry, comment, comments = [];
+
+ for (i = 0; i < extra.comments.length; ++i) {
+ entry = extra.comments[i];
+ comment = {
+ type: entry.type,
+ value: entry.value
+ };
+ if (extra.range) {
+ comment.range = entry.range;
+ }
+ if (extra.loc) {
+ comment.loc = entry.loc;
+ }
+ comments.push(comment);
+ }
+
+ extra.comments = comments;
+ }
+
+ function collectToken() {
+ var start, loc, token, range, value;
+
+ skipComment();
+ start = index;
+ loc = {
+ start: {
+ line: lineNumber,
+ column: index - lineStart
+ }
+ };
+
+ token = extra.advance();
+ loc.end = {
+ line: lineNumber,
+ column: index - lineStart
+ };
+
+ if (token.type !== Token.EOF) {
+ range = [token.range[0], token.range[1]];
+ value = sliceSource(token.range[0], token.range[1]);
+ extra.tokens.push({
+ type: TokenName[token.type],
+ value: value,
+ range: range,
+ loc: loc
+ });
+ }
+
+ return token;
+ }
+
+ function collectRegex() {
+ var pos, loc, regex, token;
+
+ skipComment();
+
+ pos = index;
+ loc = {
+ start: {
+ line: lineNumber,
+ column: index - lineStart
+ }
+ };
+
+ regex = extra.scanRegExp();
+ loc.end = {
+ line: lineNumber,
+ column: index - lineStart
+ };
+
+ // Pop the previous token, which is likely '/' or '/='
+ if (extra.tokens.length > 0) {
+ token = extra.tokens[extra.tokens.length - 1];
+ if (token.range[0] === pos && token.type === 'Punctuator') {
+ if (token.value === '/' || token.value === '/=') {
+ extra.tokens.pop();
+ }
+ }
+ }
+
+ extra.tokens.push({
+ type: 'RegularExpression',
+ value: regex.literal,
+ range: [pos, index],
+ loc: loc
+ });
+
+ return regex;
+ }
+
+ function filterTokenLocation() {
+ var i, entry, token, tokens = [];
+
+ for (i = 0; i < extra.tokens.length; ++i) {
+ entry = extra.tokens[i];
+ token = {
+ type: entry.type,
+ value: entry.value
+ };
+ if (extra.range) {
+ token.range = entry.range;
+ }
+ if (extra.loc) {
+ token.loc = entry.loc;
+ }
+ tokens.push(token);
+ }
+
+ extra.tokens = tokens;
+ }
+
+ function createLiteral(token) {
+ return {
+ type: Syntax.Literal,
+ value: token.value
+ };
+ }
+
+ function createRawLiteral(token) {
+ return {
+ type: Syntax.Literal,
+ value: token.value,
+ raw: sliceSource(token.range[0], token.range[1])
+ };
+ }
+
+ function createLocationMarker() {
+ var marker = {};
+
+ marker.range = [index, index];
+ marker.loc = {
+ start: {
+ line: lineNumber,
+ column: index - lineStart
+ },
+ end: {
+ line: lineNumber,
+ column: index - lineStart
+ }
+ };
+
+ marker.end = function () {
+ this.range[1] = index;
+ this.loc.end.line = lineNumber;
+ this.loc.end.column = index - lineStart;
+ };
+
+ marker.applyGroup = function (node) {
+ if (extra.range) {
+ node.groupRange = [this.range[0], this.range[1]];
+ }
+ if (extra.loc) {
+ node.groupLoc = {
+ start: {
+ line: this.loc.start.line,
+ column: this.loc.start.column
+ },
+ end: {
+ line: this.loc.end.line,
+ column: this.loc.end.column
+ }
+ };
+ }
+ };
+
+ marker.apply = function (node) {
+ if (extra.range) {
+ node.range = [this.range[0], this.range[1]];
+ }
+ if (extra.loc) {
+ node.loc = {
+ start: {
+ line: this.loc.start.line,
+ column: this.loc.start.column
+ },
+ end: {
+ line: this.loc.end.line,
+ column: this.loc.end.column
+ }
+ };
+ }
+ };
+
+ return marker;
+ }
+
+ function trackGroupExpression() {
+ var marker, expr;
+
+ skipComment();
+ marker = createLocationMarker();
+ expect('(');
+
+ expr = parseExpression();
+
+ expect(')');
+
+ marker.end();
+ marker.applyGroup(expr);
+
+ return expr;
+ }
+
+ function trackLeftHandSideExpression() {
+ var marker, expr;
+
+ skipComment();
+ marker = createLocationMarker();
+
+ expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();
+
+ while (match('.') || match('[')) {
+ if (match('[')) {
+ expr = {
+ type: Syntax.MemberExpression,
+ computed: true,
+ object: expr,
+ property: parseComputedMember()
+ };
+ marker.end();
+ marker.apply(expr);
+ } else {
+ expr = {
+ type: Syntax.MemberExpression,
+ computed: false,
+ object: expr,
+ property: parseNonComputedMember()
+ };
+ marker.end();
+ marker.apply(expr);
+ }
+ }
+
+ return expr;
+ }
+
+ function trackLeftHandSideExpressionAllowCall() {
+ var marker, expr;
+
+ skipComment();
+ marker = createLocationMarker();
+
+ expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();
+
+ while (match('.') || match('[') || match('(')) {
+ if (match('(')) {
+ expr = {
+ type: Syntax.CallExpression,
+ callee: expr,
+ 'arguments': parseArguments()
+ };
+ marker.end();
+ marker.apply(expr);
+ } else if (match('[')) {
+ expr = {
+ type: Syntax.MemberExpression,
+ computed: true,
+ object: expr,
+ property: parseComputedMember()
+ };
+ marker.end();
+ marker.apply(expr);
+ } else {
+ expr = {
+ type: Syntax.MemberExpression,
+ computed: false,
+ object: expr,
+ property: parseNonComputedMember()
+ };
+ marker.end();
+ marker.apply(expr);
+ }
+ }
+
+ return expr;
+ }
+
+ function filterGroup(node) {
+ var n, i, entry;
+
+ n = (Object.prototype.toString.apply(node) === '[object Array]') ? [] : {};
+ for (i in node) {
+ if (node.hasOwnProperty(i) && i !== 'groupRange' && i !== 'groupLoc') {
+ entry = node[i];
+ if (entry === null || typeof entry !== 'object' || entry instanceof RegExp) {
+ n[i] = entry;
+ } else {
+ n[i] = filterGroup(entry);
+ }
+ }
+ }
+ return n;
+ }
+
+ function wrapTrackingFunction(range, loc) {
+
+ return function (parseFunction) {
+
+ function isBinary(node) {
+ return node.type === Syntax.LogicalExpression ||
+ node.type === Syntax.BinaryExpression;
+ }
+
+ function visit(node) {
+ var start, end;
+
+ if (isBinary(node.left)) {
+ visit(node.left);
+ }
+ if (isBinary(node.right)) {
+ visit(node.right);
+ }
+
+ if (range) {
+ if (node.left.groupRange || node.right.groupRange) {
+ start = node.left.groupRange ? node.left.groupRange[0] : node.left.range[0];
+ end = node.right.groupRange ? node.right.groupRange[1] : node.right.range[1];
+ node.range = [start, end];
+ } else if (typeof node.range === 'undefined') {
+ start = node.left.range[0];
+ end = node.right.range[1];
+ node.range = [start, end];
+ }
+ }
+ if (loc) {
+ if (node.left.groupLoc || node.right.groupLoc) {
+ start = node.left.groupLoc ? node.left.groupLoc.start : node.left.loc.start;
+ end = node.right.groupLoc ? node.right.groupLoc.end : node.right.loc.end;
+ node.loc = {
+ start: start,
+ end: end
+ };
+ } else if (typeof node.loc === 'undefined') {
+ node.loc = {
+ start: node.left.loc.start,
+ end: node.right.loc.end
+ };
+ }
+ }
+ }
+
+ return function () {
+ var marker, node;
+
+ skipComment();
+
+ marker = createLocationMarker();
+ node = parseFunction.apply(null, arguments);
+ marker.end();
+
+ if (range && typeof node.range === 'undefined') {
+ marker.apply(node);
+ }
+
+ if (loc && typeof node.loc === 'undefined') {
+ marker.apply(node);
+ }
+
+ if (isBinary(node)) {
+ visit(node);
+ }
+
+ return node;
+ };
+ };
+ }
+
+ function patch() {
+
+ var wrapTracking;
+
+ if (extra.comments) {
+ extra.skipComment = skipComment;
+ skipComment = scanComment;
+ }
+
+ if (extra.raw) {
+ extra.createLiteral = createLiteral;
+ createLiteral = createRawLiteral;
+ }
+
+ if (extra.range || extra.loc) {
+
+ extra.parseGroupExpression = parseGroupExpression;
+ extra.parseLeftHandSideExpression = parseLeftHandSideExpression;
+ extra.parseLeftHandSideExpressionAllowCall = parseLeftHandSideExpressionAllowCall;
+ parseGroupExpression = trackGroupExpression;
+ parseLeftHandSideExpression = trackLeftHandSideExpression;
+ parseLeftHandSideExpressionAllowCall = trackLeftHandSideExpressionAllowCall;
+
+ wrapTracking = wrapTrackingFunction(extra.range, extra.loc);
+
+ extra.parseAdditiveExpression = parseAdditiveExpression;
+ extra.parseAssignmentExpression = parseAssignmentExpression;
+ extra.parseBitwiseANDExpression = parseBitwiseANDExpression;
+ extra.parseBitwiseORExpression = parseBitwiseORExpression;
+ extra.parseBitwiseXORExpression = parseBitwiseXORExpression;
+ extra.parseBlock = parseBlock;
+ extra.parseFunctionSourceElements = parseFunctionSourceElements;
+ extra.parseCatchClause = parseCatchClause;
+ extra.parseComputedMember = parseComputedMember;
+ extra.parseConditionalExpression = parseConditionalExpression;
+ extra.parseConstLetDeclaration = parseConstLetDeclaration;
+ extra.parseEqualityExpression = parseEqualityExpression;
+ extra.parseExpression = parseExpression;
+ extra.parseForVariableDeclaration = parseForVariableDeclaration;
+ extra.parseFunctionDeclaration = parseFunctionDeclaration;
+ extra.parseFunctionExpression = parseFunctionExpression;
+ extra.parseLogicalANDExpression = parseLogicalANDExpression;
+ extra.parseLogicalORExpression = parseLogicalORExpression;
+ extra.parseMultiplicativeExpression = parseMultiplicativeExpression;
+ extra.parseNewExpression = parseNewExpression;
+ extra.parseNonComputedProperty = parseNonComputedProperty;
+ extra.parseObjectProperty = parseObjectProperty;
+ extra.parseObjectPropertyKey = parseObjectPropertyKey;
+ extra.parsePostfixExpression = parsePostfixExpression;
+ extra.parsePrimaryExpression = parsePrimaryExpression;
+ extra.parseProgram = parseProgram;
+ extra.parsePropertyFunction = parsePropertyFunction;
+ extra.parseRelationalExpression = parseRelationalExpression;
+ extra.parseStatement = parseStatement;
+ extra.parseShiftExpression = parseShiftExpression;
+ extra.parseSwitchCase = parseSwitchCase;
+ extra.parseUnaryExpression = parseUnaryExpression;
+ extra.parseVariableDeclaration = parseVariableDeclaration;
+ extra.parseVariableIdentifier = parseVariableIdentifier;
+
+ parseAdditiveExpression = wrapTracking(extra.parseAdditiveExpression);
+ parseAssignmentExpression = wrapTracking(extra.parseAssignmentExpression);
+ parseBitwiseANDExpression = wrapTracking(extra.parseBitwiseANDExpression);
+ parseBitwiseORExpression = wrapTracking(extra.parseBitwiseORExpression);
+ parseBitwiseXORExpression = wrapTracking(extra.parseBitwiseXORExpression);
+ parseBlock = wrapTracking(extra.parseBlock);
+ parseFunctionSourceElements = wrapTracking(extra.parseFunctionSourceElements);
+ parseCatchClause = wrapTracking(extra.parseCatchClause);
+ parseComputedMember = wrapTracking(extra.parseComputedMember);
+ parseConditionalExpression = wrapTracking(extra.parseConditionalExpression);
+ parseConstLetDeclaration = wrapTracking(extra.parseConstLetDeclaration);
+ parseEqualityExpression = wrapTracking(extra.parseEqualityExpression);
+ parseExpression = wrapTracking(extra.parseExpression);
+ parseForVariableDeclaration = wrapTracking(extra.parseForVariableDeclaration);
+ parseFunctionDeclaration = wrapTracking(extra.parseFunctionDeclaration);
+ parseFunctionExpression = wrapTracking(extra.parseFunctionExpression);
+ parseLeftHandSideExpression = wrapTracking(parseLeftHandSideExpression);
+ parseLogicalANDExpression = wrapTracking(extra.parseLogicalANDExpression);
+ parseLogicalORExpression = wrapTracking(extra.parseLogicalORExpression);
+ parseMultiplicativeExpression = wrapTracking(extra.parseMultiplicativeExpression);
+ parseNewExpression = wrapTracking(extra.parseNewExpression);
+ parseNonComputedProperty = wrapTracking(extra.parseNonComputedProperty);
+ parseObjectProperty = wrapTracking(extra.parseObjectProperty);
+ parseObjectPropertyKey = wrapTracking(extra.parseObjectPropertyKey);
+ parsePostfixExpression = wrapTracking(extra.parsePostfixExpression);
+ parsePrimaryExpression = wrapTracking(extra.parsePrimaryExpression);
+ parseProgram = wrapTracking(extra.parseProgram);
+ parsePropertyFunction = wrapTracking(extra.parsePropertyFunction);
+ parseRelationalExpression = wrapTracking(extra.parseRelationalExpression);
+ parseStatement = wrapTracking(extra.parseStatement);
+ parseShiftExpression = wrapTracking(extra.parseShiftExpression);
+ parseSwitchCase = wrapTracking(extra.parseSwitchCase);
+ parseUnaryExpression = wrapTracking(extra.parseUnaryExpression);
+ parseVariableDeclaration = wrapTracking(extra.parseVariableDeclaration);
+ parseVariableIdentifier = wrapTracking(extra.parseVariableIdentifier);
+ }
+
+ if (typeof extra.tokens !== 'undefined') {
+ extra.advance = advance;
+ extra.scanRegExp = scanRegExp;
+
+ advance = collectToken;
+ scanRegExp = collectRegex;
+ }
+ }
+
+ function unpatch() {
+ if (typeof extra.skipComment === 'function') {
+ skipComment = extra.skipComment;
+ }
+
+ if (extra.raw) {
+ createLiteral = extra.createLiteral;
+ }
+
+ if (extra.range || extra.loc) {
+ parseAdditiveExpression = extra.parseAdditiveExpression;
+ parseAssignmentExpression = extra.parseAssignmentExpression;
+ parseBitwiseANDExpression = extra.parseBitwiseANDExpression;
+ parseBitwiseORExpression = extra.parseBitwiseORExpression;
+ parseBitwiseXORExpression = extra.parseBitwiseXORExpression;
+ parseBlock = extra.parseBlock;
+ parseFunctionSourceElements = extra.parseFunctionSourceElements;
+ parseCatchClause = extra.parseCatchClause;
+ parseComputedMember = extra.parseComputedMember;
+ parseConditionalExpression = extra.parseConditionalExpression;
+ parseConstLetDeclaration = extra.parseConstLetDeclaration;
+ parseEqualityExpression = extra.parseEqualityExpression;
+ parseExpression = extra.parseExpression;
+ parseForVariableDeclaration = extra.parseForVariableDeclaration;
+ parseFunctionDeclaration = extra.parseFunctionDeclaration;
+ parseFunctionExpression = extra.parseFunctionExpression;
+ parseGroupExpression = extra.parseGroupExpression;
+ parseLeftHandSideExpression = extra.parseLeftHandSideExpression;
+ parseLeftHandSideExpressionAllowCall = extra.parseLeftHandSideExpressionAllowCall;
+ parseLogicalANDExpression = extra.parseLogicalANDExpression;
+ parseLogicalORExpression = extra.parseLogicalORExpression;
+ parseMultiplicativeExpression = extra.parseMultiplicativeExpression;
+ parseNewExpression = extra.parseNewExpression;
+ parseNonComputedProperty = extra.parseNonComputedProperty;
+ parseObjectProperty = extra.parseObjectProperty;
+ parseObjectPropertyKey = extra.parseObjectPropertyKey;
+ parsePrimaryExpression = extra.parsePrimaryExpression;
+ parsePostfixExpression = extra.parsePostfixExpression;
+ parseProgram = extra.parseProgram;
+ parsePropertyFunction = extra.parsePropertyFunction;
+ parseRelationalExpression = extra.parseRelationalExpression;
+ parseStatement = extra.parseStatement;
+ parseShiftExpression = extra.parseShiftExpression;
+ parseSwitchCase = extra.parseSwitchCase;
+ parseUnaryExpression = extra.parseUnaryExpression;
+ parseVariableDeclaration = extra.parseVariableDeclaration;
+ parseVariableIdentifier = extra.parseVariableIdentifier;
+ }
+
+ if (typeof extra.scanRegExp === 'function') {
+ advance = extra.advance;
+ scanRegExp = extra.scanRegExp;
+ }
+ }
+
+ function stringToArray(str) {
+ var length = str.length,
+ result = [],
+ i;
+ for (i = 0; i < length; ++i) {
+ result[i] = str.charAt(i);
+ }
+ return result;
+ }
+
+ function parse(code, options) {
+ var program, toString;
+
+ toString = String;
+ if (typeof code !== 'string' && !(code instanceof String)) {
+ code = toString(code);
+ }
+
+ source = code;
+ index = 0;
+ lineNumber = (source.length > 0) ? 1 : 0;
+ lineStart = 0;
+ length = source.length;
+ buffer = null;
+ state = {
+ allowIn: true,
+ labelSet: {},
+ inFunctionBody: false,
+ inIteration: false,
+ inSwitch: false
+ };
+
+ extra = {};
+ if (typeof options !== 'undefined') {
+ extra.range = (typeof options.range === 'boolean') && options.range;
+ extra.loc = (typeof options.loc === 'boolean') && options.loc;
+ extra.raw = (typeof options.raw === 'boolean') && options.raw;
+ if (typeof options.tokens === 'boolean' && options.tokens) {
+ extra.tokens = [];
+ }
+ if (typeof options.comment === 'boolean' && options.comment) {
+ extra.comments = [];
+ }
+ if (typeof options.tolerant === 'boolean' && options.tolerant) {
+ extra.errors = [];
+ }
+ }
+
+ if (length > 0) {
+ if (typeof source[0] === 'undefined') {
+ // Try first to convert to a string. This is good as fast path
+ // for old IE which understands string indexing for string
+ // literals only and not for string object.
+ if (code instanceof String) {
+ source = code.valueOf();
+ }
+
+ // Force accessing the characters via an array.
+ if (typeof source[0] === 'undefined') {
+ source = stringToArray(code);
+ }
+ }
+ }
+
+ patch();
+ try {
+ program = parseProgram();
+ if (typeof extra.comments !== 'undefined') {
+ filterCommentLocation();
+ program.comments = extra.comments;
+ }
+ if (typeof extra.tokens !== 'undefined') {
+ filterTokenLocation();
+ program.tokens = extra.tokens;
+ }
+ if (typeof extra.errors !== 'undefined') {
+ program.errors = extra.errors;
+ }
+ if (extra.range || extra.loc) {
+ program.body = filterGroup(program.body);
+ }
+ } catch (e) {
+ throw e;
+ } finally {
+ unpatch();
+ extra = {};
+ }
+
+ return program;
+ }
+
+ // Sync with package.json.
+ exports.version = '1.0.3';
+
+ exports.parse = parse;
+
+ // Deep copy.
+ exports.Syntax = (function () {
+ var name, types = {};
+
+ if (typeof Object.create === 'function') {
+ types = Object.create(null);
+ }
+
+ for (name in Syntax) {
+ if (Syntax.hasOwnProperty(name)) {
+ types[name] = Syntax[name];
+ }
+ }
+
+ if (typeof Object.freeze === 'function') {
+ Object.freeze(types);
+ }
+
+ return types;
+ }());
+
+}));
+/* vim: set sw=4 ts=4 et tw=80 : */
+/**
+ * @license Copyright (c) 2012, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+
+/*global define, Reflect */
+
+/*
+ * xpcshell has a smaller stack on linux and windows (1MB vs 9MB on mac),
+ * and the recursive nature of esprima can cause it to overflow pretty
+ * quickly. So favor it built in Reflect parser:
+ * https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API
+ */
+define('esprimaAdapter', ['./esprima', 'env'], function (esprima, env) {
+ if (env.get() === 'xpconnect' && typeof Reflect !== 'undefined') {
+ return Reflect;
+ } else {
+ return esprima;
+ }
+});
+define('uglifyjs/consolidator', ["require", "exports", "module", "./parse-js", "./process"], function(require, exports, module) {
+/**
+ * @preserve Copyright 2012 Robert Gust-Bardon <http://robert.gust-bardon.org/>.
+ * All rights reserved.
+ *
+ * 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
+ * disclaimer in the documentation and/or other materials
+ * 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.
+ */
+
+/**
+ * @fileoverview Enhances <a href="https://github.com/mishoo/UglifyJS/"
+ * >UglifyJS</a> with consolidation of null, Boolean, and String values.
+ * <p>Also known as aliasing, this feature has been deprecated in <a href=
+ * "http://closure-compiler.googlecode.com/">the Closure Compiler</a> since its
+ * initial release, where it is unavailable from the <abbr title=
+ * "command line interface">CLI</a>. The Closure Compiler allows one to log and
+ * influence this process. In contrast, this implementation does not introduce
+ * any variable declarations in global code and derives String values from
+ * identifier names used as property accessors.</p>
+ * <p>Consolidating literals may worsen the data compression ratio when an <a
+ * href="http://tools.ietf.org/html/rfc2616#section-3.5">encoding
+ * transformation</a> is applied. For instance, <a href=
+ * "http://code.jquery.com/jquery-1.7.1.js">jQuery 1.7.1</a> takes 248235 bytes.
+ * Building it with <a href="https://github.com/mishoo/UglifyJS/tarball/v1.2.5">
+ * UglifyJS v1.2.5</a> results in 93647 bytes (37.73% of the original) which are
+ * then compressed to 33154 bytes (13.36% of the original) using <a href=
+ * "http://linux.die.net/man/1/gzip">gzip(1)</a>. Building it with the same
+ * version of UglifyJS 1.2.5 patched with the implementation of consolidation
+ * results in 80784 bytes (a decrease of 12863 bytes, i.e. 13.74%, in comparison
+ * to the aforementioned 93647 bytes) which are then compressed to 34013 bytes
+ * (an increase of 859 bytes, i.e. 2.59%, in comparison to the aforementioned
+ * 33154 bytes).</p>
+ * <p>Written in <a href="http://es5.github.com/#x4.2.2">the strict variant</a>
+ * of <a href="http://es5.github.com/">ECMA-262 5.1 Edition</a>. Encoded in <a
+ * href="http://tools.ietf.org/html/rfc3629">UTF-8</a>. Follows <a href=
+ * "http://google-styleguide.googlecode.com/svn-history/r76/trunk/javascriptguide.xml"
+ * >Revision 2.28 of the Google JavaScript Style Guide</a> (except for the
+ * discouraged use of the {@code function} tag and the {@code namespace} tag).
+ * 100% typed for the <a href=
+ * "http://closure-compiler.googlecode.com/files/compiler-20120123.tar.gz"
+ * >Closure Compiler Version 1741</a>.</p>
+ * <p>Should you find this software useful, please consider <a href=
+ * "https://paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=JZLW72X8FD4WG"
+ * >a donation</a>.</p>
+ * @author follow.me@RGustBardon (Robert Gust-Bardon)
+ * @supported Tested with:
+ * <ul>
+ * <li><a href="http://nodejs.org/dist/v0.6.10/">Node v0.6.10</a>,</li>
+ * <li><a href="https://github.com/mishoo/UglifyJS/tarball/v1.2.5">UglifyJS
+ * v1.2.5</a>.</li>
+ * </ul>
+ */
+
+/*global console:false, exports:true, module:false, require:false */
+/*jshint sub:true */
+/**
+ * Consolidates null, Boolean, and String values found inside an <abbr title=
+ * "abstract syntax tree">AST</abbr>.
+ * @param {!TSyntacticCodeUnit} oAbstractSyntaxTree An array-like object
+ * representing an <abbr title="abstract syntax tree">AST</abbr>.
+ * @return {!TSyntacticCodeUnit} An array-like object representing an <abbr
+ * title="abstract syntax tree">AST</abbr> with its null, Boolean, and
+ * String values consolidated.
+ */
+// TODO(user) Consolidation of mathematical values found in numeric literals.
+// TODO(user) Unconsolidation.
+// TODO(user) Consolidation of ECMA-262 6th Edition programs.
+// TODO(user) Rewrite in ECMA-262 6th Edition.
+exports['ast_consolidate'] = function(oAbstractSyntaxTree) {
+ 'use strict';
+ /*jshint bitwise:true, curly:true, eqeqeq:true, forin:true, immed:true,
+ latedef:true, newcap:true, noarge:true, noempty:true, nonew:true,
+ onevar:true, plusplus:true, regexp:true, undef:true, strict:true,
+ sub:false, trailing:true */
+
+ var _,
+ /**
+ * A record consisting of data about one or more source elements.
+ * @constructor
+ * @nosideeffects
+ */
+ TSourceElementsData = function() {
+ /**
+ * The category of the elements.
+ * @type {number}
+ * @see ESourceElementCategories
+ */
+ this.nCategory = ESourceElementCategories.N_OTHER;
+ /**
+ * The number of occurrences (within the elements) of each primitive
+ * value that could be consolidated.
+ * @type {!Array.<!Object.<string, number>>}
+ */
+ this.aCount = [];
+ this.aCount[EPrimaryExpressionCategories.N_IDENTIFIER_NAMES] = {};
+ this.aCount[EPrimaryExpressionCategories.N_STRING_LITERALS] = {};
+ this.aCount[EPrimaryExpressionCategories.N_NULL_AND_BOOLEAN_LITERALS] =
+ {};
+ /**
+ * Identifier names found within the elements.
+ * @type {!Array.<string>}
+ */
+ this.aIdentifiers = [];
+ /**
+ * Prefixed representation Strings of each primitive value that could be
+ * consolidated within the elements.
+ * @type {!Array.<string>}
+ */
+ this.aPrimitiveValues = [];
+ },
+ /**
+ * A record consisting of data about a primitive value that could be
+ * consolidated.
+ * @constructor
+ * @nosideeffects
+ */
+ TPrimitiveValue = function() {
+ /**
+ * The difference in the number of terminal symbols between the original
+ * source text and the one with the primitive value consolidated. If the
+ * difference is positive, the primitive value is considered worthwhile.
+ * @type {number}
+ */
+ this.nSaving = 0;
+ /**
+ * An identifier name of the variable that will be declared and assigned
+ * the primitive value if the primitive value is consolidated.
+ * @type {string}
+ */
+ this.sName = '';
+ },
+ /**
+ * A record consisting of data on what to consolidate within the range of
+ * source elements that is currently being considered.
+ * @constructor
+ * @nosideeffects
+ */
+ TSolution = function() {
+ /**
+ * An object whose keys are prefixed representation Strings of each
+ * primitive value that could be consolidated within the elements and
+ * whose values are corresponding data about those primitive values.
+ * @type {!Object.<string, {nSaving: number, sName: string}>}
+ * @see TPrimitiveValue
+ */
+ this.oPrimitiveValues = {};
+ /**
+ * The difference in the number of terminal symbols between the original
+ * source text and the one with all the worthwhile primitive values
+ * consolidated.
+ * @type {number}
+ * @see TPrimitiveValue#nSaving
+ */
+ this.nSavings = 0;
+ },
+ /**
+ * The processor of <abbr title="abstract syntax tree">AST</abbr>s found
+ * in UglifyJS.
+ * @namespace
+ * @type {!TProcessor}
+ */
+ oProcessor = (/** @type {!TProcessor} */ require('./process')),
+ /**
+ * A record consisting of a number of constants that represent the
+ * difference in the number of terminal symbols between a source text with
+ * a modified syntactic code unit and the original one.
+ * @namespace
+ * @type {!Object.<string, number>}
+ */
+ oWeights = {
+ /**
+ * The difference in the number of punctuators required by the bracket
+ * notation and the dot notation.
+ * <p><code>'[]'.length - '.'.length</code></p>
+ * @const
+ * @type {number}
+ */
+ N_PROPERTY_ACCESSOR: 1,
+ /**
+ * The number of punctuators required by a variable declaration with an
+ * initialiser.
+ * <p><code>':'.length + ';'.length</code></p>
+ * @const
+ * @type {number}
+ */
+ N_VARIABLE_DECLARATION: 2,
+ /**
+ * The number of terminal symbols required to introduce a variable
+ * statement (excluding its variable declaration list).
+ * <p><code>'var '.length</code></p>
+ * @const
+ * @type {number}
+ */
+ N_VARIABLE_STATEMENT_AFFIXATION: 4,
+ /**
+ * The number of terminal symbols needed to enclose source elements
+ * within a function call with no argument values to a function with an
+ * empty parameter list.
+ * <p><code>'(function(){}());'.length</code></p>
+ * @const
+ * @type {number}
+ */
+ N_CLOSURE: 17
+ },
+ /**
+ * Categories of primary expressions from which primitive values that
+ * could be consolidated are derivable.
+ * @namespace
+ * @enum {number}
+ */
+ EPrimaryExpressionCategories = {
+ /**
+ * Identifier names used as property accessors.
+ * @type {number}
+ */
+ N_IDENTIFIER_NAMES: 0,
+ /**
+ * String literals.
+ * @type {number}
+ */
+ N_STRING_LITERALS: 1,
+ /**
+ * Null and Boolean literals.
+ * @type {number}
+ */
+ N_NULL_AND_BOOLEAN_LITERALS: 2
+ },
+ /**
+ * Prefixes of primitive values that could be consolidated.
+ * The String values of the prefixes must have same number of characters.
+ * The prefixes must not be used in any properties defined in any version
+ * of <a href=
+ * "http://www.ecma-international.org/publications/standards/Ecma-262.htm"
+ * >ECMA-262</a>.
+ * @namespace
+ * @enum {string}
+ */
+ EValuePrefixes = {
+ /**
+ * Identifies String values.
+ * @type {string}
+ */
+ S_STRING: '#S',
+ /**
+ * Identifies null and Boolean values.
+ * @type {string}
+ */
+ S_SYMBOLIC: '#O'
+ },
+ /**
+ * Categories of source elements in terms of their appropriateness of
+ * having their primitive values consolidated.
+ * @namespace
+ * @enum {number}
+ */
+ ESourceElementCategories = {
+ /**
+ * Identifies a source element that includes the <a href=
+ * "http://es5.github.com/#x12.10">{@code with}</a> statement.
+ * @type {number}
+ */
+ N_WITH: 0,
+ /**
+ * Identifies a source element that includes the <a href=
+ * "http://es5.github.com/#x15.1.2.1">{@code eval}</a> identifier name.
+ * @type {number}
+ */
+ N_EVAL: 1,
+ /**
+ * Identifies a source element that must be excluded from the process
+ * unless its whole scope is examined.
+ * @type {number}
+ */
+ N_EXCLUDABLE: 2,
+ /**
+ * Identifies source elements not posing any problems.
+ * @type {number}
+ */
+ N_OTHER: 3
+ },
+ /**
+ * The list of literals (other than the String ones) whose primitive
+ * values can be consolidated.
+ * @const
+ * @type {!Array.<string>}
+ */
+ A_OTHER_SUBSTITUTABLE_LITERALS = [
+ 'null', // The null literal.
+ 'false', // The Boolean literal {@code false}.
+ 'true' // The Boolean literal {@code true}.
+ ];
+
+ (/**
+ * Consolidates all worthwhile primitive values in a syntactic code unit.
+ * @param {!TSyntacticCodeUnit} oSyntacticCodeUnit An array-like object
+ * representing the branch of the abstract syntax tree representing the
+ * syntactic code unit along with its scope.
+ * @see TPrimitiveValue#nSaving
+ */
+ function fExamineSyntacticCodeUnit(oSyntacticCodeUnit) {
+ var _,
+ /**
+ * Indicates whether the syntactic code unit represents global code.
+ * @type {boolean}
+ */
+ bIsGlobal = 'toplevel' === oSyntacticCodeUnit[0],
+ /**
+ * Indicates whether the whole scope is being examined.
+ * @type {boolean}
+ */
+ bIsWhollyExaminable = !bIsGlobal,
+ /**
+ * An array-like object representing source elements that constitute a
+ * syntactic code unit.
+ * @type {!TSyntacticCodeUnit}
+ */
+ oSourceElements,
+ /**
+ * A record consisting of data about the source element that is
+ * currently being examined.
+ * @type {!TSourceElementsData}
+ */
+ oSourceElementData,
+ /**
+ * The scope of the syntactic code unit.
+ * @type {!TScope}
+ */
+ oScope,
+ /**
+ * An instance of an object that allows the traversal of an <abbr
+ * title="abstract syntax tree">AST</abbr>.
+ * @type {!TWalker}
+ */
+ oWalker,
+ /**
+ * An object encompassing collections of functions used during the
+ * traversal of an <abbr title="abstract syntax tree">AST</abbr>.
+ * @namespace
+ * @type {!Object.<string, !Object.<string, function(...[*])>>}
+ */
+ oWalkers = {
+ /**
+ * A collection of functions used during the surveyance of source
+ * elements.
+ * @namespace
+ * @type {!Object.<string, function(...[*])>}
+ */
+ oSurveySourceElement: {
+ /**#nocode+*/ // JsDoc Toolkit 2.4.0 hides some of the keys.
+ /**
+ * Classifies the source element as excludable if it does not
+ * contain a {@code with} statement or the {@code eval} identifier
+ * name. Adds the identifier of the function and its formal
+ * parameters to the list of identifier names found.
+ * @param {string} sIdentifier The identifier of the function.
+ * @param {!Array.<string>} aFormalParameterList Formal parameters.
+ * @param {!TSyntacticCodeUnit} oFunctionBody Function code.
+ */
+ 'defun': function(
+ sIdentifier,
+ aFormalParameterList,
+ oFunctionBody) {
+ fClassifyAsExcludable();
+ fAddIdentifier(sIdentifier);
+ aFormalParameterList.forEach(fAddIdentifier);
+ },
+ /**
+ * Increments the count of the number of occurrences of the String
+ * value that is equivalent to the sequence of terminal symbols
+ * that constitute the encountered identifier name.
+ * @param {!TSyntacticCodeUnit} oExpression The nonterminal
+ * MemberExpression.
+ * @param {string} sIdentifierName The identifier name used as the
+ * property accessor.
+ * @return {!Array} The encountered branch of an <abbr title=
+ * "abstract syntax tree">AST</abbr> with its nonterminal
+ * MemberExpression traversed.
+ */
+ 'dot': function(oExpression, sIdentifierName) {
+ fCountPrimaryExpression(
+ EPrimaryExpressionCategories.N_IDENTIFIER_NAMES,
+ EValuePrefixes.S_STRING + sIdentifierName);
+ return ['dot', oWalker.walk(oExpression), sIdentifierName];
+ },
+ /**
+ * Adds the optional identifier of the function and its formal
+ * parameters to the list of identifier names found.
+ * @param {?string} sIdentifier The optional identifier of the
+ * function.
+ * @param {!Array.<string>} aFormalParameterList Formal parameters.
+ * @param {!TSyntacticCodeUnit} oFunctionBody Function code.
+ */
+ 'function': function(
+ sIdentifier,
+ aFormalParameterList,
+ oFunctionBody) {
+ if ('string' === typeof sIdentifier) {
+ fAddIdentifier(sIdentifier);
+ }
+ aFormalParameterList.forEach(fAddIdentifier);
+ },
+ /**
+ * Either increments the count of the number of occurrences of the
+ * encountered null or Boolean value or classifies a source element
+ * as containing the {@code eval} identifier name.
+ * @param {string} sIdentifier The identifier encountered.
+ */
+ 'name': function(sIdentifier) {
+ if (-1 !== A_OTHER_SUBSTITUTABLE_LITERALS.indexOf(sIdentifier)) {
+ fCountPrimaryExpression(
+ EPrimaryExpressionCategories.N_NULL_AND_BOOLEAN_LITERALS,
+ EValuePrefixes.S_SYMBOLIC + sIdentifier);
+ } else {
+ if ('eval' === sIdentifier) {
+ oSourceElementData.nCategory =
+ ESourceElementCategories.N_EVAL;
+ }
+ fAddIdentifier(sIdentifier);
+ }
+ },
+ /**
+ * Classifies the source element as excludable if it does not
+ * contain a {@code with} statement or the {@code eval} identifier
+ * name.
+ * @param {TSyntacticCodeUnit} oExpression The expression whose
+ * value is to be returned.
+ */
+ 'return': function(oExpression) {
+ fClassifyAsExcludable();
+ },
+ /**
+ * Increments the count of the number of occurrences of the
+ * encountered String value.
+ * @param {string} sStringValue The String value of the string
+ * literal encountered.
+ */
+ 'string': function(sStringValue) {
+ if (sStringValue.length > 0) {
+ fCountPrimaryExpression(
+ EPrimaryExpressionCategories.N_STRING_LITERALS,
+ EValuePrefixes.S_STRING + sStringValue);
+ }
+ },
+ /**
+ * Adds the identifier reserved for an exception to the list of
+ * identifier names found.
+ * @param {!TSyntacticCodeUnit} oTry A block of code in which an
+ * exception can occur.
+ * @param {Array} aCatch The identifier reserved for an exception
+ * and a block of code to handle the exception.
+ * @param {TSyntacticCodeUnit} oFinally An optional block of code
+ * to be evaluated regardless of whether an exception occurs.
+ */
+ 'try': function(oTry, aCatch, oFinally) {
+ if (Array.isArray(aCatch)) {
+ fAddIdentifier(aCatch[0]);
+ }
+ },
+ /**
+ * Classifies the source element as excludable if it does not
+ * contain a {@code with} statement or the {@code eval} identifier
+ * name. Adds the identifier of each declared variable to the list
+ * of identifier names found.
+ * @param {!Array.<!Array>} aVariableDeclarationList Variable
+ * declarations.
+ */
+ 'var': function(aVariableDeclarationList) {
+ fClassifyAsExcludable();
+ aVariableDeclarationList.forEach(fAddVariable);
+ },
+ /**
+ * Classifies a source element as containing the {@code with}
+ * statement.
+ * @param {!TSyntacticCodeUnit} oExpression An expression whose
+ * value is to be converted to a value of type Object and
+ * become the binding object of a new object environment
+ * record of a new lexical environment in which the statement
+ * is to be executed.
+ * @param {!TSyntacticCodeUnit} oStatement The statement to be
+ * executed in the augmented lexical environment.
+ * @return {!Array} An empty array to stop the traversal.
+ */
+ 'with': function(oExpression, oStatement) {
+ oSourceElementData.nCategory = ESourceElementCategories.N_WITH;
+ return [];
+ }
+ /**#nocode-*/ // JsDoc Toolkit 2.4.0 hides some of the keys.
+ },
+ /**
+ * A collection of functions used while looking for nested functions.
+ * @namespace
+ * @type {!Object.<string, function(...[*])>}
+ */
+ oExamineFunctions: {
+ /**#nocode+*/ // JsDoc Toolkit 2.4.0 hides some of the keys.
+ /**
+ * Orders an examination of a nested function declaration.
+ * @this {!TSyntacticCodeUnit} An array-like object representing
+ * the branch of an <abbr title="abstract syntax tree"
+ * >AST</abbr> representing the syntactic code unit along with
+ * its scope.
+ * @return {!Array} An empty array to stop the traversal.
+ */
+ 'defun': function() {
+ fExamineSyntacticCodeUnit(this);
+ return [];
+ },
+ /**
+ * Orders an examination of a nested function expression.
+ * @this {!TSyntacticCodeUnit} An array-like object representing
+ * the branch of an <abbr title="abstract syntax tree"
+ * >AST</abbr> representing the syntactic code unit along with
+ * its scope.
+ * @return {!Array} An empty array to stop the traversal.
+ */
+ 'function': function() {
+ fExamineSyntacticCodeUnit(this);
+ return [];
+ }
+ /**#nocode-*/ // JsDoc Toolkit 2.4.0 hides some of the keys.
+ }
+ },
+ /**
+ * Records containing data about source elements.
+ * @type {Array.<TSourceElementsData>}
+ */
+ aSourceElementsData = [],
+ /**
+ * The index (in the source text order) of the source element
+ * immediately following a <a href="http://es5.github.com/#x14.1"
+ * >Directive Prologue</a>.
+ * @type {number}
+ */
+ nAfterDirectivePrologue = 0,
+ /**
+ * The index (in the source text order) of the source element that is
+ * currently being considered.
+ * @type {number}
+ */
+ nPosition,
+ /**
+ * The index (in the source text order) of the source element that is
+ * the last element of the range of source elements that is currently
+ * being considered.
+ * @type {(undefined|number)}
+ */
+ nTo,
+ /**
+ * Initiates the traversal of a source element.
+ * @param {!TWalker} oWalker An instance of an object that allows the
+ * traversal of an abstract syntax tree.
+ * @param {!TSyntacticCodeUnit} oSourceElement A source element from
+ * which the traversal should commence.
+ * @return {function(): !TSyntacticCodeUnit} A function that is able to
+ * initiate the traversal from a given source element.
+ */
+ cContext = function(oWalker, oSourceElement) {
+ /**
+ * @return {!TSyntacticCodeUnit} A function that is able to
+ * initiate the traversal from a given source element.
+ */
+ var fLambda = function() {
+ return oWalker.walk(oSourceElement);
+ };
+
+ return fLambda;
+ },
+ /**
+ * Classifies the source element as excludable if it does not
+ * contain a {@code with} statement or the {@code eval} identifier
+ * name.
+ */
+ fClassifyAsExcludable = function() {
+ if (oSourceElementData.nCategory ===
+ ESourceElementCategories.N_OTHER) {
+ oSourceElementData.nCategory =
+ ESourceElementCategories.N_EXCLUDABLE;
+ }
+ },
+ /**
+ * Adds an identifier to the list of identifier names found.
+ * @param {string} sIdentifier The identifier to be added.
+ */
+ fAddIdentifier = function(sIdentifier) {
+ if (-1 === oSourceElementData.aIdentifiers.indexOf(sIdentifier)) {
+ oSourceElementData.aIdentifiers.push(sIdentifier);
+ }
+ },
+ /**
+ * Adds the identifier of a variable to the list of identifier names
+ * found.
+ * @param {!Array} aVariableDeclaration A variable declaration.
+ */
+ fAddVariable = function(aVariableDeclaration) {
+ fAddIdentifier(/** @type {string} */ aVariableDeclaration[0]);
+ },
+ /**
+ * Increments the count of the number of occurrences of the prefixed
+ * String representation attributed to the primary expression.
+ * @param {number} nCategory The category of the primary expression.
+ * @param {string} sName The prefixed String representation attributed
+ * to the primary expression.
+ */
+ fCountPrimaryExpression = function(nCategory, sName) {
+ if (!oSourceElementData.aCount[nCategory].hasOwnProperty(sName)) {
+ oSourceElementData.aCount[nCategory][sName] = 0;
+ if (-1 === oSourceElementData.aPrimitiveValues.indexOf(sName)) {
+ oSourceElementData.aPrimitiveValues.push(sName);
+ }
+ }
+ oSourceElementData.aCount[nCategory][sName] += 1;
+ },
+ /**
+ * Consolidates all worthwhile primitive values in a range of source
+ * elements.
+ * @param {number} nFrom The index (in the source text order) of the
+ * source element that is the first element of the range.
+ * @param {number} nTo The index (in the source text order) of the
+ * source element that is the last element of the range.
+ * @param {boolean} bEnclose Indicates whether the range should be
+ * enclosed within a function call with no argument values to a
+ * function with an empty parameter list if any primitive values
+ * are consolidated.
+ * @see TPrimitiveValue#nSaving
+ */
+ fExamineSourceElements = function(nFrom, nTo, bEnclose) {
+ var _,
+ /**
+ * The index of the last mangled name.
+ * @type {number}
+ */
+ nIndex = oScope.cname,
+ /**
+ * The index of the source element that is currently being
+ * considered.
+ * @type {number}
+ */
+ nPosition,
+ /**
+ * A collection of functions used during the consolidation of
+ * primitive values and identifier names used as property
+ * accessors.
+ * @namespace
+ * @type {!Object.<string, function(...[*])>}
+ */
+ oWalkersTransformers = {
+ /**
+ * If the String value that is equivalent to the sequence of
+ * terminal symbols that constitute the encountered identifier
+ * name is worthwhile, a syntactic conversion from the dot
+ * notation to the bracket notation ensues with that sequence
+ * being substituted by an identifier name to which the value
+ * is assigned.
+ * Applies to property accessors that use the dot notation.
+ * @param {!TSyntacticCodeUnit} oExpression The nonterminal
+ * MemberExpression.
+ * @param {string} sIdentifierName The identifier name used as
+ * the property accessor.
+ * @return {!Array} A syntactic code unit that is equivalent to
+ * the one encountered.
+ * @see TPrimitiveValue#nSaving
+ */
+ 'dot': function(oExpression, sIdentifierName) {
+ /**
+ * The prefixed String value that is equivalent to the
+ * sequence of terminal symbols that constitute the
+ * encountered identifier name.
+ * @type {string}
+ */
+ var sPrefixed = EValuePrefixes.S_STRING + sIdentifierName;
+
+ return oSolutionBest.oPrimitiveValues.hasOwnProperty(
+ sPrefixed) &&
+ oSolutionBest.oPrimitiveValues[sPrefixed].nSaving > 0 ?
+ ['sub',
+ oWalker.walk(oExpression),
+ ['name',
+ oSolutionBest.oPrimitiveValues[sPrefixed].sName]] :
+ ['dot', oWalker.walk(oExpression), sIdentifierName];
+ },
+ /**
+ * If the encountered identifier is a null or Boolean literal
+ * and its value is worthwhile, the identifier is substituted
+ * by an identifier name to which that value is assigned.
+ * Applies to identifier names.
+ * @param {string} sIdentifier The identifier encountered.
+ * @return {!Array} A syntactic code unit that is equivalent to
+ * the one encountered.
+ * @see TPrimitiveValue#nSaving
+ */
+ 'name': function(sIdentifier) {
+ /**
+ * The prefixed representation String of the identifier.
+ * @type {string}
+ */
+ var sPrefixed = EValuePrefixes.S_SYMBOLIC + sIdentifier;
+
+ return [
+ 'name',
+ oSolutionBest.oPrimitiveValues.hasOwnProperty(sPrefixed) &&
+ oSolutionBest.oPrimitiveValues[sPrefixed].nSaving > 0 ?
+ oSolutionBest.oPrimitiveValues[sPrefixed].sName :
+ sIdentifier
+ ];
+ },
+ /**
+ * If the encountered String value is worthwhile, it is
+ * substituted by an identifier name to which that value is
+ * assigned.
+ * Applies to String values.
+ * @param {string} sStringValue The String value of the string
+ * literal encountered.
+ * @return {!Array} A syntactic code unit that is equivalent to
+ * the one encountered.
+ * @see TPrimitiveValue#nSaving
+ */
+ 'string': function(sStringValue) {
+ /**
+ * The prefixed representation String of the primitive value
+ * of the literal.
+ * @type {string}
+ */
+ var sPrefixed =
+ EValuePrefixes.S_STRING + sStringValue;
+
+ return oSolutionBest.oPrimitiveValues.hasOwnProperty(
+ sPrefixed) &&
+ oSolutionBest.oPrimitiveValues[sPrefixed].nSaving > 0 ?
+ ['name',
+ oSolutionBest.oPrimitiveValues[sPrefixed].sName] :
+ ['string', sStringValue];
+ }
+ },
+ /**
+ * Such data on what to consolidate within the range of source
+ * elements that is currently being considered that lead to the
+ * greatest known reduction of the number of the terminal symbols
+ * in comparison to the original source text.
+ * @type {!TSolution}
+ */
+ oSolutionBest = new TSolution(),
+ /**
+ * Data representing an ongoing attempt to find a better
+ * reduction of the number of the terminal symbols in comparison
+ * to the original source text than the best one that is
+ * currently known.
+ * @type {!TSolution}
+ * @see oSolutionBest
+ */
+ oSolutionCandidate = new TSolution(),
+ /**
+ * A record consisting of data about the range of source elements
+ * that is currently being examined.
+ * @type {!TSourceElementsData}
+ */
+ oSourceElementsData = new TSourceElementsData(),
+ /**
+ * Variable declarations for each primitive value that is to be
+ * consolidated within the elements.
+ * @type {!Array.<!Array>}
+ */
+ aVariableDeclarations = [],
+ /**
+ * Augments a list with a prefixed representation String.
+ * @param {!Array.<string>} aList A list that is to be augmented.
+ * @return {function(string)} A function that augments a list
+ * with a prefixed representation String.
+ */
+ cAugmentList = function(aList) {
+ /**
+ * @param {string} sPrefixed Prefixed representation String of
+ * a primitive value that could be consolidated within the
+ * elements.
+ */
+ var fLambda = function(sPrefixed) {
+ if (-1 === aList.indexOf(sPrefixed)) {
+ aList.push(sPrefixed);
+ }
+ };
+
+ return fLambda;
+ },
+ /**
+ * Adds the number of occurrences of a primitive value of a given
+ * category that could be consolidated in the source element with
+ * a given index to the count of occurrences of that primitive
+ * value within the range of source elements that is currently
+ * being considered.
+ * @param {number} nPosition The index (in the source text order)
+ * of a source element.
+ * @param {number} nCategory The category of the primary
+ * expression from which the primitive value is derived.
+ * @return {function(string)} A function that performs the
+ * addition.
+ * @see cAddOccurrencesInCategory
+ */
+ cAddOccurrences = function(nPosition, nCategory) {
+ /**
+ * @param {string} sPrefixed The prefixed representation String
+ * of a primitive value.
+ */
+ var fLambda = function(sPrefixed) {
+ if (!oSourceElementsData.aCount[nCategory].hasOwnProperty(
+ sPrefixed)) {
+ oSourceElementsData.aCount[nCategory][sPrefixed] = 0;
+ }
+ oSourceElementsData.aCount[nCategory][sPrefixed] +=
+ aSourceElementsData[nPosition].aCount[nCategory][
+ sPrefixed];
+ };
+
+ return fLambda;
+ },
+ /**
+ * Adds the number of occurrences of each primitive value of a
+ * given category that could be consolidated in the source
+ * element with a given index to the count of occurrences of that
+ * primitive values within the range of source elements that is
+ * currently being considered.
+ * @param {number} nPosition The index (in the source text order)
+ * of a source element.
+ * @return {function(number)} A function that performs the
+ * addition.
+ * @see fAddOccurrences
+ */
+ cAddOccurrencesInCategory = function(nPosition) {
+ /**
+ * @param {number} nCategory The category of the primary
+ * expression from which the primitive value is derived.
+ */
+ var fLambda = function(nCategory) {
+ Object.keys(
+ aSourceElementsData[nPosition].aCount[nCategory]
+ ).forEach(cAddOccurrences(nPosition, nCategory));
+ };
+
+ return fLambda;
+ },
+ /**
+ * Adds the number of occurrences of each primitive value that
+ * could be consolidated in the source element with a given index
+ * to the count of occurrences of that primitive values within
+ * the range of source elements that is currently being
+ * considered.
+ * @param {number} nPosition The index (in the source text order)
+ * of a source element.
+ */
+ fAddOccurrences = function(nPosition) {
+ Object.keys(aSourceElementsData[nPosition].aCount).forEach(
+ cAddOccurrencesInCategory(nPosition));
+ },
+ /**
+ * Creates a variable declaration for a primitive value if that
+ * primitive value is to be consolidated within the elements.
+ * @param {string} sPrefixed Prefixed representation String of a
+ * primitive value that could be consolidated within the
+ * elements.
+ * @see aVariableDeclarations
+ */
+ cAugmentVariableDeclarations = function(sPrefixed) {
+ if (oSolutionBest.oPrimitiveValues[sPrefixed].nSaving > 0) {
+ aVariableDeclarations.push([
+ oSolutionBest.oPrimitiveValues[sPrefixed].sName,
+ [0 === sPrefixed.indexOf(EValuePrefixes.S_SYMBOLIC) ?
+ 'name' : 'string',
+ sPrefixed.substring(EValuePrefixes.S_SYMBOLIC.length)]
+ ]);
+ }
+ },
+ /**
+ * Sorts primitive values with regard to the difference in the
+ * number of terminal symbols between the original source text
+ * and the one with those primitive values consolidated.
+ * @param {string} sPrefixed0 The prefixed representation String
+ * of the first of the two primitive values that are being
+ * compared.
+ * @param {string} sPrefixed1 The prefixed representation String
+ * of the second of the two primitive values that are being
+ * compared.
+ * @return {number}
+ * <dl>
+ * <dt>-1</dt>
+ * <dd>if the first primitive value must be placed before
+ * the other one,</dd>
+ * <dt>0</dt>
+ * <dd>if the first primitive value may be placed before
+ * the other one,</dd>
+ * <dt>1</dt>
+ * <dd>if the first primitive value must not be placed
+ * before the other one.</dd>
+ * </dl>
+ * @see TSolution.oPrimitiveValues
+ */
+ cSortPrimitiveValues = function(sPrefixed0, sPrefixed1) {
+ /**
+ * The difference between:
+ * <ol>
+ * <li>the difference in the number of terminal symbols
+ * between the original source text and the one with the
+ * first primitive value consolidated, and</li>
+ * <li>the difference in the number of terminal symbols
+ * between the original source text and the one with the
+ * second primitive value consolidated.</li>
+ * </ol>
+ * @type {number}
+ */
+ var nDifference =
+ oSolutionCandidate.oPrimitiveValues[sPrefixed0].nSaving -
+ oSolutionCandidate.oPrimitiveValues[sPrefixed1].nSaving;
+
+ return nDifference > 0 ? -1 : nDifference < 0 ? 1 : 0;
+ },
+ /**
+ * Assigns an identifier name to a primitive value and calculates
+ * whether instances of that primitive value are worth
+ * consolidating.
+ * @param {string} sPrefixed The prefixed representation String
+ * of a primitive value that is being evaluated.
+ */
+ fEvaluatePrimitiveValue = function(sPrefixed) {
+ var _,
+ /**
+ * The index of the last mangled name.
+ * @type {number}
+ */
+ nIndex,
+ /**
+ * The representation String of the primitive value that is
+ * being evaluated.
+ * @type {string}
+ */
+ sName =
+ sPrefixed.substring(EValuePrefixes.S_SYMBOLIC.length),
+ /**
+ * The number of source characters taken up by the
+ * representation String of the primitive value that is
+ * being evaluated.
+ * @type {number}
+ */
+ nLengthOriginal = sName.length,
+ /**
+ * The number of source characters taken up by the
+ * identifier name that could substitute the primitive
+ * value that is being evaluated.
+ * substituted.
+ * @type {number}
+ */
+ nLengthSubstitution,
+ /**
+ * The number of source characters taken up by by the
+ * representation String of the primitive value that is
+ * being evaluated when it is represented by a string
+ * literal.
+ * @type {number}
+ */
+ nLengthString = oProcessor.make_string(sName).length;
+
+ oSolutionCandidate.oPrimitiveValues[sPrefixed] =
+ new TPrimitiveValue();
+ do { // Find an identifier unused in this or any nested scope.
+ nIndex = oScope.cname;
+ oSolutionCandidate.oPrimitiveValues[sPrefixed].sName =
+ oScope.next_mangled();
+ } while (-1 !== oSourceElementsData.aIdentifiers.indexOf(
+ oSolutionCandidate.oPrimitiveValues[sPrefixed].sName));
+ nLengthSubstitution = oSolutionCandidate.oPrimitiveValues[
+ sPrefixed].sName.length;
+ if (0 === sPrefixed.indexOf(EValuePrefixes.S_SYMBOLIC)) {
+ // foo:null, or foo:null;
+ oSolutionCandidate.oPrimitiveValues[sPrefixed].nSaving -=
+ nLengthSubstitution + nLengthOriginal +
+ oWeights.N_VARIABLE_DECLARATION;
+ // null vs foo
+ oSolutionCandidate.oPrimitiveValues[sPrefixed].nSaving +=
+ oSourceElementsData.aCount[
+ EPrimaryExpressionCategories.
+ N_NULL_AND_BOOLEAN_LITERALS][sPrefixed] *
+ (nLengthOriginal - nLengthSubstitution);
+ } else {
+ // foo:'fromCharCode';
+ oSolutionCandidate.oPrimitiveValues[sPrefixed].nSaving -=
+ nLengthSubstitution + nLengthString +
+ oWeights.N_VARIABLE_DECLARATION;
+ // .fromCharCode vs [foo]
+ if (oSourceElementsData.aCount[
+ EPrimaryExpressionCategories.N_IDENTIFIER_NAMES
+ ].hasOwnProperty(sPrefixed)) {
+ oSolutionCandidate.oPrimitiveValues[sPrefixed].nSaving +=
+ oSourceElementsData.aCount[
+ EPrimaryExpressionCategories.N_IDENTIFIER_NAMES
+ ][sPrefixed] *
+ (nLengthOriginal - nLengthSubstitution -
+ oWeights.N_PROPERTY_ACCESSOR);
+ }
+ // 'fromCharCode' vs foo
+ if (oSourceElementsData.aCount[
+ EPrimaryExpressionCategories.N_STRING_LITERALS
+ ].hasOwnProperty(sPrefixed)) {
+ oSolutionCandidate.oPrimitiveValues[sPrefixed].nSaving +=
+ oSourceElementsData.aCount[
+ EPrimaryExpressionCategories.N_STRING_LITERALS
+ ][sPrefixed] *
+ (nLengthString - nLengthSubstitution);
+ }
+ }
+ if (oSolutionCandidate.oPrimitiveValues[sPrefixed].nSaving >
+ 0) {
+ oSolutionCandidate.nSavings +=
+ oSolutionCandidate.oPrimitiveValues[sPrefixed].nSaving;
+ } else {
+ oScope.cname = nIndex; // Free the identifier name.
+ }
+ },
+ /**
+ * Adds a variable declaration to an existing variable statement.
+ * @param {!Array} aVariableDeclaration A variable declaration
+ * with an initialiser.
+ */
+ cAddVariableDeclaration = function(aVariableDeclaration) {
+ (/** @type {!Array} */ oSourceElements[nFrom][1]).unshift(
+ aVariableDeclaration);
+ };
+
+ if (nFrom > nTo) {
+ return;
+ }
+ // If the range is a closure, reuse the closure.
+ if (nFrom === nTo &&
+ 'stat' === oSourceElements[nFrom][0] &&
+ 'call' === oSourceElements[nFrom][1][0] &&
+ 'function' === oSourceElements[nFrom][1][1][0]) {
+ fExamineSyntacticCodeUnit(oSourceElements[nFrom][1][1]);
+ return;
+ }
+ // Create a list of all derived primitive values within the range.
+ for (nPosition = nFrom; nPosition <= nTo; nPosition += 1) {
+ aSourceElementsData[nPosition].aPrimitiveValues.forEach(
+ cAugmentList(oSourceElementsData.aPrimitiveValues));
+ }
+ if (0 === oSourceElementsData.aPrimitiveValues.length) {
+ return;
+ }
+ for (nPosition = nFrom; nPosition <= nTo; nPosition += 1) {
+ // Add the number of occurrences to the total count.
+ fAddOccurrences(nPosition);
+ // Add identifiers of this or any nested scope to the list.
+ aSourceElementsData[nPosition].aIdentifiers.forEach(
+ cAugmentList(oSourceElementsData.aIdentifiers));
+ }
+ // Distribute identifier names among derived primitive values.
+ do { // If there was any progress, find a better distribution.
+ oSolutionBest = oSolutionCandidate;
+ if (Object.keys(oSolutionCandidate.oPrimitiveValues).length > 0) {
+ // Sort primitive values descending by their worthwhileness.
+ oSourceElementsData.aPrimitiveValues.sort(cSortPrimitiveValues);
+ }
+ oSolutionCandidate = new TSolution();
+ oSourceElementsData.aPrimitiveValues.forEach(
+ fEvaluatePrimitiveValue);
+ oScope.cname = nIndex;
+ } while (oSolutionCandidate.nSavings > oSolutionBest.nSavings);
+ // Take the necessity of adding a variable statement into account.
+ if ('var' !== oSourceElements[nFrom][0]) {
+ oSolutionBest.nSavings -= oWeights.N_VARIABLE_STATEMENT_AFFIXATION;
+ }
+ if (bEnclose) {
+ // Take the necessity of forming a closure into account.
+ oSolutionBest.nSavings -= oWeights.N_CLOSURE;
+ }
+ if (oSolutionBest.nSavings > 0) {
+ // Create variable declarations suitable for UglifyJS.
+ Object.keys(oSolutionBest.oPrimitiveValues).forEach(
+ cAugmentVariableDeclarations);
+ // Rewrite expressions that contain worthwhile primitive values.
+ for (nPosition = nFrom; nPosition <= nTo; nPosition += 1) {
+ oWalker = oProcessor.ast_walker();
+ oSourceElements[nPosition] =
+ oWalker.with_walkers(
+ oWalkersTransformers,
+ cContext(oWalker, oSourceElements[nPosition]));
+ }
+ if ('var' === oSourceElements[nFrom][0]) { // Reuse the statement.
+ (/** @type {!Array.<!Array>} */ aVariableDeclarations.reverse(
+ )).forEach(cAddVariableDeclaration);
+ } else { // Add a variable statement.
+ Array.prototype.splice.call(
+ oSourceElements,
+ nFrom,
+ 0,
+ ['var', aVariableDeclarations]);
+ nTo += 1;
+ }
+ if (bEnclose) {
+ // Add a closure.
+ Array.prototype.splice.call(
+ oSourceElements,
+ nFrom,
+ 0,
+ ['stat', ['call', ['function', null, [], []], []]]);
+ // Copy source elements into the closure.
+ for (nPosition = nTo + 1; nPosition > nFrom; nPosition -= 1) {
+ Array.prototype.unshift.call(
+ oSourceElements[nFrom][1][1][3],
+ oSourceElements[nPosition]);
+ }
+ // Remove source elements outside the closure.
+ Array.prototype.splice.call(
+ oSourceElements,
+ nFrom + 1,
+ nTo - nFrom + 1);
+ }
+ }
+ if (bEnclose) {
+ // Restore the availability of identifier names.
+ oScope.cname = nIndex;
+ }
+ };
+
+ oSourceElements = (/** @type {!TSyntacticCodeUnit} */
+ oSyntacticCodeUnit[bIsGlobal ? 1 : 3]);
+ if (0 === oSourceElements.length) {
+ return;
+ }
+ oScope = bIsGlobal ? oSyntacticCodeUnit.scope : oSourceElements.scope;
+ // Skip a Directive Prologue.
+ while (nAfterDirectivePrologue < oSourceElements.length &&
+ 'directive' === oSourceElements[nAfterDirectivePrologue][0]) {
+ nAfterDirectivePrologue += 1;
+ aSourceElementsData.push(null);
+ }
+ if (oSourceElements.length === nAfterDirectivePrologue) {
+ return;
+ }
+ for (nPosition = nAfterDirectivePrologue;
+ nPosition < oSourceElements.length;
+ nPosition += 1) {
+ oSourceElementData = new TSourceElementsData();
+ oWalker = oProcessor.ast_walker();
+ // Classify a source element.
+ // Find its derived primitive values and count their occurrences.
+ // Find all identifiers used (including nested scopes).
+ oWalker.with_walkers(
+ oWalkers.oSurveySourceElement,
+ cContext(oWalker, oSourceElements[nPosition]));
+ // Establish whether the scope is still wholly examinable.
+ bIsWhollyExaminable = bIsWhollyExaminable &&
+ ESourceElementCategories.N_WITH !== oSourceElementData.nCategory &&
+ ESourceElementCategories.N_EVAL !== oSourceElementData.nCategory;
+ aSourceElementsData.push(oSourceElementData);
+ }
+ if (bIsWhollyExaminable) { // Examine the whole scope.
+ fExamineSourceElements(
+ nAfterDirectivePrologue,
+ oSourceElements.length - 1,
+ false);
+ } else { // Examine unexcluded ranges of source elements.
+ for (nPosition = oSourceElements.length - 1;
+ nPosition >= nAfterDirectivePrologue;
+ nPosition -= 1) {
+ oSourceElementData = (/** @type {!TSourceElementsData} */
+ aSourceElementsData[nPosition]);
+ if (ESourceElementCategories.N_OTHER ===
+ oSourceElementData.nCategory) {
+ if ('undefined' === typeof nTo) {
+ nTo = nPosition; // Indicate the end of a range.
+ }
+ // Examine the range if it immediately follows a Directive Prologue.
+ if (nPosition === nAfterDirectivePrologue) {
+ fExamineSourceElements(nPosition, nTo, true);
+ }
+ } else {
+ if ('undefined' !== typeof nTo) {
+ // Examine the range that immediately follows this source element.
+ fExamineSourceElements(nPosition + 1, nTo, true);
+ nTo = void 0; // Obliterate the range.
+ }
+ // Examine nested functions.
+ oWalker = oProcessor.ast_walker();
+ oWalker.with_walkers(
+ oWalkers.oExamineFunctions,
+ cContext(oWalker, oSourceElements[nPosition]));
+ }
+ }
+ }
+ }(oAbstractSyntaxTree = oProcessor.ast_add_scope(oAbstractSyntaxTree)));
+ return oAbstractSyntaxTree;
+};
+/*jshint sub:false */
+
+/* Local Variables: */
+/* mode: js */
+/* coding: utf-8 */
+/* indent-tabs-mode: nil */
+/* tab-width: 2 */
+/* End: */
+/* vim: set ft=javascript fenc=utf-8 et ts=2 sts=2 sw=2: */
+/* :mode=javascript:noTabs=true:tabSize=2:indentSize=2:deepIndent=true: */
+});
+define('uglifyjs/parse-js', ["exports"], function(exports) {
+/***********************************************************************
+
+ 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 contains the tokenizer/parser. It is a port to JavaScript
+ of parse-js [1], a JavaScript parser library written in Common Lisp
+ by Marijn Haverbeke. Thank you Marijn!
+
+ [1] http://marijn.haverbeke.nl/parse-js/
+
+ 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>
+ http://mihai.bazon.net/blog
+
+ 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
+ disclaimer in the documentation and/or other materials
+ 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",
+ "debugger",
+ "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",
+ "double",
+ "enum",
+ "export",
+ "extends",
+ "final",
+ "float",
+ "goto",
+ "implements",
+ "import",
+ "int",
+ "interface",
+ "long",
+ "native",
+ "package",
+ "private",
+ "protected",
+ "public",
+ "short",
+ "static",
+ "super",
+ "synchronized",
+ "throws",
+ "transient",
+ "volatile"
+]);
+
+var KEYWORDS_BEFORE_EXPRESSION = array_to_hash([
+ "return",
+ "new",
+ "delete",
+ "throw",
+ "else",
+ "case"
+]);
+
+var KEYWORDS_ATOM = array_to_hash([
+ "false",
+ "null",
+ "true",
+ "undefined"
+]);
+
+var OPERATOR_CHARS = array_to_hash(characters("+-*&%=<>!?|~^"));
+
+var RE_HEX_NUMBER = /^0x[0-9a-f]+$/i;
+var RE_OCT_NUMBER = /^0[0-7]+$/;
+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\uFEFF"));
+
+var PUNC_BEFORE_EXPRESSION = array_to_hash(characters("[{(,.;:"));
+
+var PUNC_CHARS = array_to_hash(characters("[]{}(),;:"));
+
+var REGEXP_MODIFIERS = array_to_hash(characters("gmsiy"));
+
+/* -----[ Tokenizer ]----- */
+
+var UNICODE = { // Unicode 6.1
+ 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-\\u0527\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0620-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0800-\\u0815\\u081A\\u0824\\u0828\\u0840-\\u0858\\u08A0\\u08A2-\\u08AC\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971-\\u0977\\u0979-\\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\\u0CF1\\u0CF2\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\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-\\u0EDF\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\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-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16EE-\\u16F0\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191C\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19C1-\\u19C7\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1AA7\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1BBA-\\u1BE5\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1CE9-\\u1CEC\\u1CEE-\\u1CF1\\u1CF5\\u1CF6\\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-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2160-\\u2188\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CEE\\u2CF2\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FCC\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA66E\\uA67F-\\uA697\\uA6A0-\\uA6EF\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA78E\\uA790-\\uA793\\uA7A0-\\uA7AA\\uA7F8-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA8F2-\\uA8F7\\uA8FB\\uA90A-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9CF\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA60-\\uAA76\\uAA7A\\uAA80-\\uAAAF\\uAAB1\\uAAB5\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEA\\uAAF2-\\uAAF4\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uABC0-\\uABE2\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\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]"),
+ combining_mark: new RegExp("[\\u0300-\\u036F\\u0483-\\u0487\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u0610-\\u061A\\u064B-\\u065F\\u0670\\u06D6-\\u06DC\\u06DF-\\u06E4\\u06E7\\u06E8\\u06EA-\\u06ED\\u0711\\u0730-\\u074A\\u07A6-\\u07B0\\u07EB-\\u07F3\\u0816-\\u0819\\u081B-\\u0823\\u0825-\\u0827\\u0829-\\u082D\\u0859-\\u085B\\u08E4-\\u08FE\\u0900-\\u0903\\u093A-\\u093C\\u093E-\\u094F\\u0951-\\u0957\\u0962\\u0963\\u0981-\\u0983\\u09BC\\u09BE-\\u09C4\\u09C7\\u09C8\\u09CB-\\u09CD\\u09D7\\u09E2\\u09E3\\u0A01-\\u0A03\\u0A3C\\u0A3E-\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A70\\u0A71\\u0A75\\u0A81-\\u0A83\\u0ABC\\u0ABE-\\u0AC5\\u0AC7-\\u0AC9\\u0ACB-\\u0ACD\\u0AE2\\u0AE3\\u0B01-\\u0B03\\u0B3C\\u0B3E-\\u0B44\\u0B47\\u0B48\\u0B4B-\\u0B4D\\u0B56\\u0B57\\u0B62\\u0B63\\u0B82\\u0BBE-\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCD\\u0BD7\\u0C01-\\u0C03\\u0C3E-\\u0C44\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C62\\u0C63\\u0C82\\u0C83\\u0CBC\\u0CBE-\\u0CC4\\u0CC6-\\u0CC8\\u0CCA-\\u0CCD\\u0CD5\\u0CD6\\u0CE2\\u0CE3\\u0D02\\u0D03\\u0D3E-\\u0D44\\u0D46-\\u0D48\\u0D4A-\\u0D4D\\u0D57\\u0D62\\u0D63\\u0D82\\u0D83\\u0DCA\\u0DCF-\\u0DD4\\u0DD6\\u0DD8-\\u0DDF\\u0DF2\\u0DF3\\u0E31\\u0E34-\\u0E3A\\u0E47-\\u0E4E\\u0EB1\\u0EB4-\\u0EB9\\u0EBB\\u0EBC\\u0EC8-\\u0ECD\\u0F18\\u0F19\\u0F35\\u0F37\\u0F39\\u0F3E\\u0F3F\\u0F71-\\u0F84\\u0F86\\u0F87\\u0F8D-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u102B-\\u103E\\u1056-\\u1059\\u105E-\\u1060\\u1062-\\u1064\\u1067-\\u106D\\u1071-\\u1074\\u1082-\\u108D\\u108F\\u109A-\\u109D\\u135D-\\u135F\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17B4-\\u17D3\\u17DD\\u180B-\\u180D\\u18A9\\u1920-\\u192B\\u1930-\\u193B\\u19B0-\\u19C0\\u19C8\\u19C9\\u1A17-\\u1A1B\\u1A55-\\u1A5E\\u1A60-\\u1A7C\\u1A7F\\u1B00-\\u1B04\\u1B34-\\u1B44\\u1B6B-\\u1B73\\u1B80-\\u1B82\\u1BA1-\\u1BAD\\u1BE6-\\u1BF3\\u1C24-\\u1C37\\u1CD0-\\u1CD2\\u1CD4-\\u1CE8\\u1CED\\u1CF2-\\u1CF4\\u1DC0-\\u1DE6\\u1DFC-\\u1DFF\\u20D0-\\u20DC\\u20E1\\u20E5-\\u20F0\\u2CEF-\\u2CF1\\u2D7F\\u2DE0-\\u2DFF\\u302A-\\u302F\\u3099\\u309A\\uA66F\\uA674-\\uA67D\\uA69F\\uA6F0\\uA6F1\\uA802\\uA806\\uA80B\\uA823-\\uA827\\uA880\\uA881\\uA8B4-\\uA8C4\\uA8E0-\\uA8F1\\uA926-\\uA92D\\uA947-\\uA953\\uA980-\\uA983\\uA9B3-\\uA9C0\\uAA29-\\uAA36\\uAA43\\uAA4C\\uAA4D\\uAA7B\\uAAB0\\uAAB2-\\uAAB4\\uAAB7\\uAAB8\\uAABE\\uAABF\\uAAC1\\uAAEB-\\uAAEF\\uAAF5\\uAAF6\\uABE3-\\uABEA\\uABEC\\uABED\\uFB1E\\uFE00-\\uFE0F\\uFE20-\\uFE26]"),
+ connector_punctuation: new RegExp("[\\u005F\\u203F\\u2040\\u2054\\uFE33\\uFE34\\uFE4D-\\uFE4F\\uFF3F]"),
+ digit: new RegExp("[\\u0030-\\u0039\\u0660-\\u0669\\u06F0-\\u06F9\\u07C0-\\u07C9\\u0966-\\u096F\\u09E6-\\u09EF\\u0A66-\\u0A6F\\u0AE6-\\u0AEF\\u0B66-\\u0B6F\\u0BE6-\\u0BEF\\u0C66-\\u0C6F\\u0CE6-\\u0CEF\\u0D66-\\u0D6F\\u0E50-\\u0E59\\u0ED0-\\u0ED9\\u0F20-\\u0F29\\u1040-\\u1049\\u1090-\\u1099\\u17E0-\\u17E9\\u1810-\\u1819\\u1946-\\u194F\\u19D0-\\u19D9\\u1A80-\\u1A89\\u1A90-\\u1A99\\u1B50-\\u1B59\\u1BB0-\\u1BB9\\u1C40-\\u1C49\\u1C50-\\u1C59\\uA620-\\uA629\\uA8D0-\\uA8D9\\uA900-\\uA909\\uA9D0-\\uA9D9\\uAA50-\\uAA59\\uABF0-\\uABF9\\uFF10-\\uFF19]")
+};
+
+function is_letter(ch) {
+ return UNICODE.letter.test(ch);
+};
+
+function is_digit(ch) {
+ ch = ch.charCodeAt(0);
+ return ch >= 48 && ch <= 57;
+};
+
+function is_unicode_digit(ch) {
+ return UNICODE.digit.test(ch);
+}
+
+function is_alphanumeric_char(ch) {
+ return is_digit(ch) || is_letter(ch);
+};
+
+function is_unicode_combining_mark(ch) {
+ return UNICODE.combining_mark.test(ch);
+};
+
+function is_unicode_connector_punctuation(ch) {
+ return UNICODE.connector_punctuation.test(ch);
+};
+
+function is_identifier_start(ch) {
+ return ch == "$" || ch == "_" || is_letter(ch);
+};
+
+function is_identifier_char(ch) {
+ return is_identifier_start(ch)
+ || is_unicode_combining_mark(ch)
+ || is_unicode_digit(ch)
+ || is_unicode_connector_punctuation(ch)
+ || ch == "\u200c" // zero-width non-joiner <ZWNJ>
+ || ch == "\u200d" // zero-width joiner <ZWJ> (in my ECMA-262 PDF, this is also 200c)
+ ;
+};
+
+function parse_js_number(num) {
+ if (RE_HEX_NUMBER.test(num)) {
+ return parseInt(num.substr(2), 16);
+ } else if (RE_OCT_NUMBER.test(num)) {
+ return parseInt(num.substr(1), 8);
+ } else if (RE_DEC_NUMBER.test(num)) {
+ return parseFloat(num);
+ }
+};
+
+function JS_Parse_Error(message, line, col, pos) {
+ this.message = message;
+ this.line = line + 1;
+ this.col = col + 1;
+ this.pos = pos + 1;
+ this.stack = new Error().stack;
+};
+
+JS_Parse_Error.prototype.toString = function() {
+ return this.message + " (line: " + this.line + ", col: " + this.col + ", pos: " + this.pos + ")" + "\n\n" + this.stack;
+};
+
+function js_error(message, line, col, pos) {
+ throw new JS_Parse_Error(message, line, col, pos);
+};
+
+function is_token(token, type, val) {
+ return token.type == type && (val == null || token.value == val);
+};
+
+var EX_EOF = {};
+
+function tokenizer($TEXT) {
+
+ var S = {
+ text : $TEXT.replace(/\r\n?|[\n\u2028\u2029]/g, "\n").replace(/^\uFEFF/, ''),
+ pos : 0,
+ tokpos : 0,
+ line : 0,
+ tokline : 0,
+ col : 0,
+ tokcol : 0,
+ newline_before : false,
+ regex_allowed : false,
+ comments_before : []
+ };
+
+ function peek() { return S.text.charAt(S.pos); };
+
+ function next(signal_eof, in_string) {
+ var ch = S.text.charAt(S.pos++);
+ if (signal_eof && !ch)
+ throw EX_EOF;
+ if (ch == "\n") {
+ S.newline_before = S.newline_before || !in_string;
+ ++S.line;
+ S.col = 0;
+ } else {
+ ++S.col;
+ }
+ return ch;
+ };
+
+ function eof() {
+ return !S.peek();
+ };
+
+ function find(what, signal_eof) {
+ var pos = S.text.indexOf(what, S.pos);
+ if (signal_eof && pos == -1) throw EX_EOF;
+ return pos;
+ };
+
+ function start_token() {
+ S.tokline = S.line;
+ S.tokcol = S.col;
+ S.tokpos = S.pos;
+ };
+
+ function token(type, value, is_comment) {
+ S.regex_allowed = ((type == "operator" && !HOP(UNARY_POSTFIX, value)) ||
+ (type == "keyword" && HOP(KEYWORDS_BEFORE_EXPRESSION, value)) ||
+ (type == "punc" && HOP(PUNC_BEFORE_EXPRESSION, value)));
+ var ret = {
+ type : type,
+ value : value,
+ line : S.tokline,
+ col : S.tokcol,
+ pos : S.tokpos,
+ endpos : S.pos,
+ nlb : S.newline_before
+ };
+ if (!is_comment) {
+ ret.comments_before = S.comments_before;
+ S.comments_before = [];
+ // make note of any newlines in the comments that came before
+ for (var i = 0, len = ret.comments_before.length; i < len; i++) {
+ ret.nlb = ret.nlb || ret.comments_before[i].nlb;
+ }
+ }
+ S.newline_before = false;
+ return ret;
+ };
+
+ function skip_whitespace() {
+ while (HOP(WHITESPACE_CHARS, peek()))
+ next();
+ };
+
+ function read_while(pred) {
+ var ret = "", ch = peek(), i = 0;
+ while (ch && pred(ch, i++)) {
+ ret += next();
+ ch = peek();
+ }
+ return ret;
+ };
+
+ function parse_error(err) {
+ js_error(err, S.tokline, S.tokcol, S.tokpos);
+ };
+
+ function read_num(prefix) {
+ var has_e = false, after_e = false, has_x = false, has_dot = prefix == ".";
+ var num = read_while(function(ch, i){
+ if (ch == "x" || ch == "X") {
+ if (has_x) return false;
+ return has_x = true;
+ }
+ if (!has_x && (ch == "E" || ch == "e")) {
+ if (has_e) return false;
+ return has_e = after_e = true;
+ }
+ if (ch == "-") {
+ if (after_e || (i == 0 && !prefix)) return true;
+ return false;
+ }
+ if (ch == "+") return after_e;
+ after_e = false;
+ if (ch == ".") {
+ if (!has_dot && !has_x && !has_e)
+ return has_dot = true;
+ return false;
+ }
+ return is_alphanumeric_char(ch);
+ });
+ if (prefix)
+ num = prefix + num;
+ var valid = parse_js_number(num);
+ if (!isNaN(valid)) {
+ return token("num", valid);
+ } else {
+ parse_error("Invalid syntax: " + num);
+ }
+ };
+
+ function read_escaped_char(in_string) {
+ var ch = next(true, 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 "x" : return String.fromCharCode(hex_bytes(2));
+ case "u" : return String.fromCharCode(hex_bytes(4));
+ case "\n": return "";
+ default : return ch;
+ }
+ };
+
+ function hex_bytes(n) {
+ var num = 0;
+ for (; n > 0; --n) {
+ var digit = parseInt(next(true), 16);
+ if (isNaN(digit))
+ parse_error("Invalid hex-character pattern in string");
+ num = (num << 4) | digit;
+ }
+ return num;
+ };
+
+ function read_string() {
+ return with_eof_error("Unterminated string constant", function(){
+ var quote = next(), ret = "";
+ for (;;) {
+ var ch = next(true);
+ if (ch == "\\") {
+ // read OctalEscapeSequence (XXX: deprecated if "strict mode")
+ // https://github.com/mishoo/UglifyJS/issues/178
+ var octal_len = 0, first = null;
+ ch = read_while(function(ch){
+ if (ch >= "0" && ch <= "7") {
+ if (!first) {
+ first = ch;
+ return ++octal_len;
+ }
+ else if (first <= "3" && octal_len <= 2) return ++octal_len;
+ else if (first >= "4" && octal_len <= 1) return ++octal_len;
+ }
+ return false;
+ });
+ if (octal_len > 0) ch = String.fromCharCode(parseInt(ch, 8));
+ else ch = read_escaped_char(true);
+ }
+ else if (ch == quote) break;
+ else if (ch == "\n") throw EX_EOF;
+ ret += ch;
+ }
+ return token("string", ret);
+ });
+ };
+
+ function read_line_comment() {
+ next();
+ var i = find("\n"), ret;
+ if (i == -1) {
+ ret = S.text.substr(S.pos);
+ S.pos = S.text.length;
+ } else {
+ ret = S.text.substring(S.pos, i);
+ S.pos = i;
+ }
+ return token("comment1", ret, true);
+ };
+
+ function read_multiline_comment() {
+ next();
+ return with_eof_error("Unterminated multiline comment", function(){
+ var i = find("*/", true),
+ text = S.text.substring(S.pos, i);
+ S.pos = i + 2;
+ S.line += text.split("\n").length - 1;
+ S.newline_before = S.newline_before || text.indexOf("\n") >= 0;
+
+ // https://github.com/mishoo/UglifyJS/issues/#issue/100
+ if (/^@cc_on/i.test(text)) {
+ warn("WARNING: at line " + S.line);
+ warn("*** Found \"conditional comment\": " + text);
+ warn("*** UglifyJS DISCARDS ALL COMMENTS. This means your code might no longer work properly in Internet Explorer.");
+ }
+
+ return token("comment2", text, true);
+ });
+ };
+
+ function read_name() {
+ var backslash = false, name = "", ch, escaped = false, hex;
+ while ((ch = peek()) != null) {
+ if (!backslash) {
+ if (ch == "\\") escaped = backslash = true, next();
+ else if (is_identifier_char(ch)) name += next();
+ else break;
+ }
+ else {
+ if (ch != "u") parse_error("Expecting UnicodeEscapeSequence -- uXXXX");
+ ch = read_escaped_char();
+ if (!is_identifier_char(ch)) parse_error("Unicode char: " + ch.charCodeAt(0) + " is not valid in identifier");
+ name += ch;
+ backslash = false;
+ }
+ }
+ if (HOP(KEYWORDS, name) && escaped) {
+ hex = name.charCodeAt(0).toString(16).toUpperCase();
+ name = "\\u" + "0000".substr(hex.length) + hex + name.slice(1);
+ }
+ return name;
+ };
+
+ function read_regexp(regexp) {
+ return with_eof_error("Unterminated regular expression", function(){
+ var prev_backslash = false, ch, in_class = false;
+ while ((ch = next(true))) if (prev_backslash) {
+ regexp += "\\" + ch;
+ prev_backslash = false;
+ } else if (ch == "[") {
+ in_class = true;
+ regexp += ch;
+ } else if (ch == "]" && in_class) {
+ in_class = false;
+ regexp += ch;
+ } else if (ch == "/" && !in_class) {
+ break;
+ } else if (ch == "\\") {
+ prev_backslash = true;
+ } else {
+ regexp += ch;
+ }
+ var mods = read_name();
+ return token("regexp", [ regexp, mods ]);
+ });
+ };
+
+ function read_operator(prefix) {
+ function grow(op) {
+ if (!peek()) return op;
+ var bigger = op + peek();
+ if (HOP(OPERATORS, bigger)) {
+ next();
+ return grow(bigger);
+ } else {
+ return op;
+ }
+ };
+ return token("operator", grow(prefix || next()));
+ };
+
+ function handle_slash() {
+ next();
+ var regex_allowed = S.regex_allowed;
+ switch (peek()) {
+ case "/":
+ S.comments_before.push(read_line_comment());
+ S.regex_allowed = regex_allowed;
+ return next_token();
+ case "*":
+ S.comments_before.push(read_multiline_comment());
+ S.regex_allowed = regex_allowed;
+ return next_token();
+ }
+ return S.regex_allowed ? read_regexp("") : read_operator("/");
+ };
+
+ function handle_dot() {
+ next();
+ return is_digit(peek())
+ ? read_num(".")
+ : token("punc", ".");
+ };
+
+ function read_word() {
+ var word = read_name();
+ return !HOP(KEYWORDS, word)
+ ? token("name", word)
+ : HOP(OPERATORS, word)
+ ? token("operator", word)
+ : HOP(KEYWORDS_ATOM, word)
+ ? token("atom", word)
+ : token("keyword", word);
+ };
+
+ function with_eof_error(eof_error, cont) {
+ try {
+ return cont();
+ } catch(ex) {
+ if (ex === EX_EOF) parse_error(eof_error);
+ else throw ex;
+ }
+ };
+
+ function next_token(force_regexp) {
+ if (force_regexp != null)
+ return read_regexp(force_regexp);
+ skip_whitespace();
+ start_token();
+ var ch = peek();
+ if (!ch) return token("eof");
+ if (is_digit(ch)) return read_num();
+ if (ch == '"' || ch == "'") return read_string();
+ if (HOP(PUNC_CHARS, ch)) return token("punc", next());
+ if (ch == ".") return handle_dot();
+ if (ch == "/") return handle_slash();
+ if (HOP(OPERATOR_CHARS, ch)) return read_operator();
+ if (ch == "\\" || is_identifier_start(ch)) return read_word();
+ parse_error("Unexpected character '" + ch + "'");
+ };
+
+ next_token.context = function(nc) {
+ if (nc) S = nc;
+ return S;
+ };
+
+ return next_token;
+
+};
+
+/* -----[ Parser (constants) ]----- */
+
+var UNARY_PREFIX = array_to_hash([
+ "typeof",
+ "void",
+ "delete",
+ "--",
+ "++",
+ "!",
+ "~",
+ "-",
+ "+"
+]);
+
+var UNARY_POSTFIX = array_to_hash([ "--", "++" ]);
+
+var ASSIGNMENT = (function(a, ret, i){
+ while (i < a.length) {
+ ret[a[i]] = a[i].substr(0, a[i].length - 1);
+ i++;
+ }
+ return ret;
+})(
+ ["+=", "-=", "/=", "*=", "%=", ">>=", "<<=", ">>>=", "|=", "^=", "&="],
+ { "=": true },
+ 0
+);
+
+var PRECEDENCE = (function(a, ret){
+ for (var i = 0, n = 1; i < a.length; ++i, ++n) {
+ var b = a[i];
+ for (var j = 0; j < b.length; ++j) {
+ ret[b[j]] = n;
+ }
+ }
+ return ret;
+})(
+ [
+ ["||"],
+ ["&&"],
+ ["|"],
+ ["^"],
+ ["&"],
+ ["==", "===", "!=", "!=="],
+ ["<", ">", "<=", ">=", "in", "instanceof"],
+ [">>", "<<", ">>>"],
+ ["+", "-"],
+ ["*", "/", "%"]
+ ],
+ {}
+);
+
+var STATEMENTS_WITH_LABELS = array_to_hash([ "for", "do", "while", "switch" ]);
+
+var ATOMIC_START_TOKEN = array_to_hash([ "atom", "num", "string", "regexp", "name" ]);
+
+/* -----[ Parser ]----- */
+
+function NodeWithToken(str, start, end) {
+ this.name = str;
+ this.start = start;
+ this.end = end;
+};
+
+NodeWithToken.prototype.toString = function() { return this.name; };
+
+function parse($TEXT, exigent_mode, embed_tokens) {
+
+ var S = {
+ input : typeof $TEXT == "string" ? tokenizer($TEXT, true) : $TEXT,
+ token : null,
+ prev : null,
+ peeked : null,
+ in_function : 0,
+ in_directives : true,
+ in_loop : 0,
+ labels : []
+ };
+
+ S.token = next();
+
+ function is(type, value) {
+ return is_token(S.token, type, value);
+ };
+
+ function peek() { return S.peeked || (S.peeked = S.input()); };
+
+ function next() {
+ S.prev = S.token;
+ if (S.peeked) {
+ S.token = S.peeked;
+ S.peeked = null;
+ } else {
+ S.token = S.input();
+ }
+ S.in_directives = S.in_directives && (
+ S.token.type == "string" || is("punc", ";")
+ );
+ return S.token;
+ };
+
+ function prev() {
+ return S.prev;
+ };
+
+ function croak(msg, line, col, pos) {
+ var ctx = S.input.context();
+ js_error(msg,
+ line != null ? line : ctx.tokline,
+ col != null ? col : ctx.tokcol,
+ pos != null ? pos : ctx.tokpos);
+ };
+
+ function token_error(token, msg) {
+ croak(msg, token.line, token.col);
+ };
+
+ function unexpected(token) {
+ if (token == null)
+ token = S.token;
+ token_error(token, "Unexpected token: " + token.type + " (" + token.value + ")");
+ };
+
+ function expect_token(type, val) {
+ if (is(type, val)) {
+ return next();
+ }
+ token_error(S.token, "Unexpected token " + S.token.type + ", expected " + type);
+ };
+
+ function expect(punc) { return expect_token("punc", punc); };
+
+ function can_insert_semicolon() {
+ return !exigent_mode && (
+ S.token.nlb || is("eof") || is("punc", "}")
+ );
+ };
+
+ function semicolon() {
+ if (is("punc", ";")) next();
+ else if (!can_insert_semicolon()) unexpected();
+ };
+
+ function as() {
+ return slice(arguments);
+ };
+
+ function parenthesised() {
+ expect("(");
+ var ex = expression();
+ expect(")");
+ return ex;
+ };
+
+ function add_tokens(str, start, end) {
+ return str instanceof NodeWithToken ? str : new NodeWithToken(str, start, end);
+ };
+
+ function maybe_embed_tokens(parser) {
+ if (embed_tokens) return function() {
+ var start = S.token;
+ var ast = parser.apply(this, arguments);
+ ast[0] = add_tokens(ast[0], start, prev());
+ return ast;
+ };
+ else return parser;
+ };
+
+ var statement = maybe_embed_tokens(function() {
+ if (is("operator", "/") || is("operator", "/=")) {
+ S.peeked = null;
+ S.token = S.input(S.token.value.substr(1)); // force regexp
+ }
+ switch (S.token.type) {
+ case "string":
+ var dir = S.in_directives, stat = simple_statement();
+ if (dir && stat[1][0] == "string" && !is("punc", ","))
+ return as("directive", stat[1][1]);
+ return stat;
+ case "num":
+ case "regexp":
+ case "operator":
+ case "atom":
+ return simple_statement();
+
+ case "name":
+ return is_token(peek(), "punc", ":")
+ ? labeled_statement(prog1(S.token.value, next, next))
+ : simple_statement();
+
+ case "punc":
+ switch (S.token.value) {
+ case "{":
+ return as("block", block_());
+ case "[":
+ case "(":
+ return simple_statement();
+ case ";":
+ next();
+ return as("block");
+ default:
+ unexpected();
+ }
+
+ case "keyword":
+ switch (prog1(S.token.value, next)) {
+ case "break":
+ return break_cont("break");
+
+ case "continue":
+ return break_cont("continue");
+
+ case "debugger":
+ semicolon();
+ return as("debugger");
+
+ case "do":
+ return (function(body){
+ expect_token("keyword", "while");
+ return as("do", prog1(parenthesised, semicolon), body);
+ })(in_loop(statement));
+
+ 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",
+ is("punc", ";")
+ ? (next(), null)
+ : can_insert_semicolon()
+ ? null
+ : prog1(expression, semicolon));
+
+ case "switch":
+ return as("switch", parenthesised(), switch_block_());
+
+ case "throw":
+ if (S.token.nlb)
+ croak("Illegal newline after 'throw'");
+ return as("throw", prog1(expression, semicolon));
+
+ case "try":
+ return try_();
+
+ case "var":
+ return prog1(var_, semicolon);
+
+ case "const":
+ return prog1(const_, semicolon);
+
+ case "while":
+ return as("while", parenthesised(), in_loop(statement));
+
+ case "with":
+ return as("with", parenthesised(), statement());
+
+ default:
+ unexpected();
+ }
+ }
+ });
+
+ function labeled_statement(label) {
+ S.labels.push(label);
+ var start = S.token, stat = statement();
+ if (exigent_mode && !HOP(STATEMENTS_WITH_LABELS, stat[0]))
+ unexpected(start);
+ S.labels.pop();
+ return as("label", label, stat);
+ };
+
+ function simple_statement() {
+ return as("stat", prog1(expression, semicolon));
+ };
+
+ function break_cont(type) {
+ var name;
+ if (!can_insert_semicolon()) {
+ name = is("name") ? S.token.value : null;
+ }
+ if (name != null) {
+ next();
+ if (!member(name, S.labels))
+ croak("Label " + name + " without matching loop or statement");
+ }
+ else if (S.in_loop == 0)
+ croak(type + " not inside a loop or switch");
+ semicolon();
+ return as(type, name);
+ };
+
+ function for_() {
+ expect("(");
+ var init = null;
+ if (!is("punc", ";")) {
+ init = is("keyword", "var")
+ ? (next(), var_(true))
+ : expression(true, true);
+ if (is("operator", "in")) {
+ if (init[0] == "var" && init[1].length > 1)
+ croak("Only one variable declaration allowed in for..in loop");
+ return for_in(init);
+ }
+ }
+ return regular_for(init);
+ };
+
+ function regular_for(init) {
+ expect(";");
+ var test = is("punc", ";") ? null : expression();
+ expect(";");
+ var step = is("punc", ")") ? null : expression();
+ expect(")");
+ return as("for", init, test, step, in_loop(statement));
+ };
+
+ function for_in(init) {
+ var lhs = init[0] == "var" ? as("name", init[1][0]) : init;
+ next();
+ var obj = expression();
+ expect(")");
+ return as("for-in", init, lhs, obj, in_loop(statement));
+ };
+
+ var function_ = function(in_statement) {
+ var name = is("name") ? prog1(S.token.value, next) : null;
+ if (in_statement && !name)
+ unexpected();
+ expect("(");
+ return as(in_statement ? "defun" : "function",
+ name,
+ // arguments
+ (function(first, a){
+ while (!is("punc", ")")) {
+ if (first) first = false; else expect(",");
+ if (!is("name")) unexpected();
+ a.push(S.token.value);
+ next();
+ }
+ next();
+ return a;
+ })(true, []),
+ // body
+ (function(){
+ ++S.in_function;
+ var loop = S.in_loop;
+ S.in_directives = true;
+ S.in_loop = 0;
+ var a = block_();
+ --S.in_function;
+ S.in_loop = loop;
+ return a;
+ })());
+ };
+
+ function if_() {
+ var cond = parenthesised(), body = statement(), belse;
+ if (is("keyword", "else")) {
+ next();
+ belse = statement();
+ }
+ return as("if", cond, body, belse);
+ };
+
+ function block_() {
+ expect("{");
+ var a = [];
+ while (!is("punc", "}")) {
+ if (is("eof")) unexpected();
+ a.push(statement());
+ }
+ next();
+ return a;
+ };
+
+ var switch_block_ = curry(in_loop, function(){
+ expect("{");
+ var a = [], cur = null;
+ while (!is("punc", "}")) {
+ if (is("eof")) unexpected();
+ if (is("keyword", "case")) {
+ next();
+ cur = [];
+ a.push([ expression(), cur ]);
+ expect(":");
+ }
+ else if (is("keyword", "default")) {
+ next();
+ expect(":");
+ cur = [];
+ a.push([ null, cur ]);
+ }
+ else {
+ if (!cur) unexpected();
+ cur.push(statement());
+ }
+ }
+ next();
+ return a;
+ });
+
+ function try_() {
+ var body = block_(), bcatch, bfinally;
+ if (is("keyword", "catch")) {
+ next();
+ expect("(");
+ if (!is("name"))
+ croak("Name expected");
+ var name = S.token.value;
+ next();
+ expect(")");
+ bcatch = [ name, block_() ];
+ }
+ if (is("keyword", "finally")) {
+ next();
+ bfinally = block_();
+ }
+ if (!bcatch && !bfinally)
+ croak("Missing catch/finally blocks");
+ return as("try", body, bcatch, bfinally);
+ };
+
+ function vardefs(no_in) {
+ var a = [];
+ for (;;) {
+ if (!is("name"))
+ unexpected();
+ var name = S.token.value;
+ next();
+ if (is("operator", "=")) {
+ next();
+ a.push([ name, expression(false, no_in) ]);
+ } else {
+ a.push([ name ]);
+ }
+ if (!is("punc", ","))
+ break;
+ next();
+ }
+ return a;
+ };
+
+ function var_(no_in) {
+ return as("var", vardefs(no_in));
+ };
+
+ function const_() {
+ return as("const", vardefs());
+ };
+
+ function new_() {
+ var newexp = expr_atom(false), args;
+ if (is("punc", "(")) {
+ next();
+ args = expr_list(")");
+ } else {
+ args = [];
+ }
+ return subscripts(as("new", newexp, args), true);
+ };
+
+ var expr_atom = maybe_embed_tokens(function(allow_calls) {
+ if (is("operator", "new")) {
+ next();
+ return new_();
+ }
+ if (is("punc")) {
+ switch (S.token.value) {
+ case "(":
+ next();
+ return subscripts(prog1(expression, curry(expect, ")")), allow_calls);
+ case "[":
+ next();
+ return subscripts(array_(), allow_calls);
+ case "{":
+ next();
+ return subscripts(object_(), allow_calls);
+ }
+ unexpected();
+ }
+ if (is("keyword", "function")) {
+ next();
+ return subscripts(function_(false), allow_calls);
+ }
+ if (HOP(ATOMIC_START_TOKEN, S.token.type)) {
+ var atom = S.token.type == "regexp"
+ ? as("regexp", S.token.value[0], S.token.value[1])
+ : as(S.token.type, S.token.value);
+ return subscripts(prog1(atom, next), allow_calls);
+ }
+ unexpected();
+ });
+
+ function expr_list(closing, allow_trailing_comma, allow_empty) {
+ var first = true, a = [];
+ while (!is("punc", closing)) {
+ if (first) first = false; else expect(",");
+ if (allow_trailing_comma && is("punc", closing)) break;
+ if (is("punc", ",") && allow_empty) {
+ a.push([ "atom", "undefined" ]);
+ } else {
+ a.push(expression(false));
+ }
+ }
+ next();
+ return a;
+ };
+
+ function array_() {
+ return as("array", expr_list("]", !exigent_mode, true));
+ };
+
+ function object_() {
+ var first = true, a = [];
+ while (!is("punc", "}")) {
+ if (first) first = false; else expect(",");
+ if (!exigent_mode && is("punc", "}"))
+ // allow trailing comma
+ break;
+ var type = S.token.type;
+ var name = as_property_name();
+ if (type == "name" && (name == "get" || name == "set") && !is("punc", ":")) {
+ a.push([ as_name(), function_(false), name ]);
+ } else {
+ expect(":");
+ a.push([ name, expression(false) ]);
+ }
+ }
+ next();
+ return as("object", a);
+ };
+
+ function as_property_name() {
+ switch (S.token.type) {
+ case "num":
+ case "string":
+ return prog1(S.token.value, next);
+ }
+ return as_name();
+ };
+
+ function as_name() {
+ switch (S.token.type) {
+ case "name":
+ case "operator":
+ case "keyword":
+ case "atom":
+ return prog1(S.token.value, next);
+ default:
+ unexpected();
+ }
+ };
+
+ function subscripts(expr, allow_calls) {
+ if (is("punc", ".")) {
+ next();
+ return subscripts(as("dot", expr, as_name()), allow_calls);
+ }
+ if (is("punc", "[")) {
+ next();
+ return subscripts(as("sub", expr, prog1(expression, curry(expect, "]"))), allow_calls);
+ }
+ if (allow_calls && is("punc", "(")) {
+ next();
+ return subscripts(as("call", expr, expr_list(")")), true);
+ }
+ return expr;
+ };
+
+ function maybe_unary(allow_calls) {
+ if (is("operator") && HOP(UNARY_PREFIX, S.token.value)) {
+ return make_unary("unary-prefix",
+ prog1(S.token.value, next),
+ maybe_unary(allow_calls));
+ }
+ var val = expr_atom(allow_calls);
+ while (is("operator") && HOP(UNARY_POSTFIX, S.token.value) && !S.token.nlb) {
+ val = make_unary("unary-postfix", S.token.value, val);
+ next();
+ }
+ return val;
+ };
+
+ function make_unary(tag, op, expr) {
+ if ((op == "++" || op == "--") && !is_assignable(expr))
+ croak("Invalid use of " + op + " operator");
+ return as(tag, op, expr);
+ };
+
+ function expr_op(left, min_prec, no_in) {
+ var op = is("operator") ? S.token.value : null;
+ if (op && op == "in" && no_in) op = null;
+ var prec = op != null ? PRECEDENCE[op] : null;
+ if (prec != null && prec > min_prec) {
+ next();
+ var right = expr_op(maybe_unary(true), prec, no_in);
+ return expr_op(as("binary", op, left, right), min_prec, no_in);
+ }
+ return left;
+ };
+
+ function expr_ops(no_in) {
+ return expr_op(maybe_unary(true), 0, no_in);
+ };
+
+ function maybe_conditional(no_in) {
+ var expr = expr_ops(no_in);
+ if (is("operator", "?")) {
+ next();
+ var yes = expression(false);
+ expect(":");
+ return as("conditional", expr, yes, expression(false, no_in));
+ }
+ return expr;
+ };
+
+ function is_assignable(expr) {
+ if (!exigent_mode) return true;
+ switch (expr[0]+"") {
+ case "dot":
+ case "sub":
+ case "new":
+ case "call":
+ return true;
+ case "name":
+ return expr[1] != "this";
+ }
+ };
+
+ function maybe_assign(no_in) {
+ var left = maybe_conditional(no_in), val = S.token.value;
+ if (is("operator") && HOP(ASSIGNMENT, val)) {
+ if (is_assignable(left)) {
+ next();
+ return as("assign", ASSIGNMENT[val], left, maybe_assign(no_in));
+ }
+ croak("Invalid assignment");
+ }
+ return left;
+ };
+
+ var expression = maybe_embed_tokens(function(commas, no_in) {
+ if (arguments.length == 0)
+ commas = true;
+ var expr = maybe_assign(no_in);
+ if (commas && is("punc", ",")) {
+ next();
+ return as("seq", expr, expression(true, no_in));
+ }
+ return expr;
+ });
+
+ function in_loop(cont) {
+ try {
+ ++S.in_loop;
+ return cont();
+ } finally {
+ --S.in_loop;
+ }
+ };
+
+ return as("toplevel", (function(a){
+ while (!is("eof"))
+ a.push(statement());
+ return a;
+ })([]));
+
+};
+
+/* -----[ Utilities ]----- */
+
+function curry(f) {
+ var args = slice(arguments, 1);
+ return function() { return f.apply(this, args.concat(slice(arguments))); };
+};
+
+function prog1(ret) {
+ if (ret instanceof Function)
+ ret = ret();
+ for (var i = 1, n = arguments.length; --n > 0; ++i)
+ 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 slice(a, start) {
+ return Array.prototype.slice.call(a, start || 0);
+};
+
+function characters(str) {
+ return str.split("");
+};
+
+function member(name, array) {
+ for (var i = array.length; --i >= 0;)
+ if (array[i] == name)
+ return true;
+ return false;
+};
+
+function HOP(obj, prop) {
+ return Object.prototype.hasOwnProperty.call(obj, prop);
+};
+
+var warn = function() {};
+
+/* -----[ Exports ]----- */
+
+exports.tokenizer = tokenizer;
+exports.parse = parse;
+exports.slice = slice;
+exports.curry = curry;
+exports.member = member;
+exports.array_to_hash = array_to_hash;
+exports.PRECEDENCE = PRECEDENCE;
+exports.KEYWORDS_ATOM = KEYWORDS_ATOM;
+exports.RESERVED_WORDS = RESERVED_WORDS;
+exports.KEYWORDS = KEYWORDS;
+exports.ATOMIC_START_TOKEN = ATOMIC_START_TOKEN;
+exports.OPERATORS = OPERATORS;
+exports.is_alphanumeric_char = is_alphanumeric_char;
+exports.is_identifier_start = is_identifier_start;
+exports.is_identifier_char = is_identifier_char;
+exports.set_logger = function(logger) {
+ warn = logger;
+};
+
+// Local variables:
+// js-indent-level: 4
+// End:
+});define('uglifyjs/squeeze-more', ["require", "exports", "module", "./parse-js", "./squeeze-more"], function(require, exports, module) {
+var jsp = require("./parse-js"),
+ pro = require("./process"),
+ slice = jsp.slice,
+ member = jsp.member,
+ curry = jsp.curry,
+ MAP = pro.MAP,
+ PRECEDENCE = jsp.PRECEDENCE,
+ OPERATORS = jsp.OPERATORS;
+
+function ast_squeeze_more(ast) {
+ var w = pro.ast_walker(), walk = w.walk, scope;
+ function with_scope(s, cont) {
+ var save = scope, ret;
+ scope = s;
+ ret = cont();
+ scope = save;
+ return ret;
+ };
+ function _lambda(name, args, body) {
+ return [ this[0], name, args, with_scope(body.scope, curry(MAP, body, walk)) ];
+ };
+ return w.with_walkers({
+ "toplevel": function(body) {
+ return [ this[0], with_scope(this.scope, curry(MAP, body, walk)) ];
+ },
+ "function": _lambda,
+ "defun": _lambda,
+ "new": function(ctor, args) {
+ if (ctor[0] == "name") {
+ if (ctor[1] == "Array" && !scope.has("Array")) {
+ if (args.length != 1) {
+ return [ "array", args ];
+ } else {
+ return walk([ "call", [ "name", "Array" ], args ]);
+ }
+ } else if (ctor[1] == "Object" && !scope.has("Object")) {
+ if (!args.length) {
+ return [ "object", [] ];
+ } else {
+ return walk([ "call", [ "name", "Object" ], args ]);
+ }
+ } else if ((ctor[1] == "RegExp" || ctor[1] == "Function" || ctor[1] == "Error") && !scope.has(ctor[1])) {
+ return walk([ "call", [ "name", ctor[1] ], args]);
+ }
+ }
+ },
+ "call": function(expr, args) {
+ if (expr[0] == "dot" && expr[1][0] == "string" && args.length == 1
+ && (args[0][1] > 0 && expr[2] == "substring" || expr[2] == "substr")) {
+ return [ "call", [ "dot", expr[1], "slice"], args];
+ }
+ if (expr[0] == "dot" && expr[2] == "toString" && args.length == 0) {
+ // foo.toString() ==> foo+""
+ if (expr[1][0] == "string") return expr[1];
+ return [ "binary", "+", expr[1], [ "string", "" ]];
+ }
+ if (expr[0] == "name") {
+ if (expr[1] == "Array" && args.length != 1 && !scope.has("Array")) {
+ return [ "array", args ];
+ }
+ if (expr[1] == "Object" && !args.length && !scope.has("Object")) {
+ return [ "object", [] ];
+ }
+ if (expr[1] == "String" && !scope.has("String")) {
+ return [ "binary", "+", args[0], [ "string", "" ]];
+ }
+ }
+ }
+ }, function() {
+ return walk(pro.ast_add_scope(ast));
+ });
+};
+
+exports.ast_squeeze_more = ast_squeeze_more;
+
+// Local variables:
+// js-indent-level: 4
+// End:
+});
+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:
+
+ - ast_mangle(ast, options) -- mangles the variable/function names
+ 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>
+ http://mihai.bazon.net/blog
+
+ 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
+ disclaimer in the documentation and/or other materials
+ 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.
+
+ ***********************************************************************/
+
+var jsp = require("./parse-js"),
+ curry = jsp.curry,
+ slice = jsp.slice,
+ member = jsp.member,
+ is_identifier_char = jsp.is_identifier_char,
+ PRECEDENCE = jsp.PRECEDENCE,
+ OPERATORS = jsp.OPERATORS;
+
+/* -----[ helper for AST traversal ]----- */
+
+function ast_walker() {
+ function _vardefs(defs) {
+ return [ this[0], MAP(defs, function(def){
+ var a = [ def[0] ];
+ if (def.length > 1)
+ a[1] = walk(def[1]);
+ return a;
+ }) ];
+ };
+ function _block(statements) {
+ var out = [ this[0] ];
+ if (statements != null)
+ out.push(MAP(statements, walk));
+ 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) {
+ return [ this[0], MAP(statements, walk) ];
+ },
+ "block": _block,
+ "splice": _block,
+ "var": _vardefs,
+ "const": _vardefs,
+ "try": function(t, c, f) {
+ return [
+ this[0],
+ MAP(t, walk),
+ c != null ? [ c[0], MAP(c[1], walk) ] : null,
+ f != null ? MAP(f, walk) : null
+ ];
+ },
+ "throw": function(expr) {
+ return [ this[0], walk(expr) ];
+ },
+ "new": function(ctor, args) {
+ return [ this[0], walk(ctor), MAP(args, walk) ];
+ },
+ "switch": function(expr, body) {
+ return [ this[0], walk(expr), MAP(body, function(branch){
+ return [ branch[0] ? walk(branch[0]) : null,
+ MAP(branch[1], walk) ];
+ }) ];
+ },
+ "break": function(label) {
+ return [ this[0], label ];
+ },
+ "continue": function(label) {
+ return [ this[0], label ];
+ },
+ "conditional": function(cond, t, e) {
+ return [ this[0], walk(cond), walk(t), walk(e) ];
+ },
+ "assign": function(op, lvalue, rvalue) {
+ return [ this[0], op, walk(lvalue), walk(rvalue) ];
+ },
+ "dot": function(expr) {
+ return [ this[0], walk(expr) ].concat(slice(arguments, 1));
+ },
+ "call": function(expr, args) {
+ return [ this[0], walk(expr), MAP(args, walk) ];
+ },
+ "function": function(name, args, body) {
+ return [ this[0], name, args.slice(), MAP(body, walk) ];
+ },
+ "debugger": function() {
+ return [ this[0] ];
+ },
+ "defun": function(name, args, body) {
+ return [ this[0], name, args.slice(), MAP(body, walk) ];
+ },
+ "if": function(conditional, t, e) {
+ return [ this[0], walk(conditional), walk(t), walk(e) ];
+ },
+ "for": function(init, cond, step, block) {
+ return [ this[0], walk(init), walk(cond), walk(step), walk(block) ];
+ },
+ "for-in": function(vvar, key, hash, block) {
+ return [ this[0], walk(vvar), walk(key), walk(hash), walk(block) ];
+ },
+ "while": function(cond, block) {
+ return [ this[0], walk(cond), walk(block) ];
+ },
+ "do": function(cond, block) {
+ return [ this[0], walk(cond), walk(block) ];
+ },
+ "return": function(expr) {
+ return [ this[0], walk(expr) ];
+ },
+ "binary": function(op, left, right) {
+ return [ this[0], op, walk(left), walk(right) ];
+ },
+ "unary-prefix": function(op, expr) {
+ return [ this[0], op, walk(expr) ];
+ },
+ "unary-postfix": function(op, expr) {
+ return [ this[0], op, walk(expr) ];
+ },
+ "sub": function(expr, subscript) {
+ return [ this[0], walk(expr), walk(subscript) ];
+ },
+ "object": function(props) {
+ return [ this[0], MAP(props, function(p){
+ return p.length == 2
+ ? [ p[0], walk(p[1]) ]
+ : [ p[0], walk(p[1]), p[2] ]; // get/set-ter
+ }) ];
+ },
+ "regexp": function(rx, mods) {
+ return [ this[0], rx, mods ];
+ },
+ "array": function(elements) {
+ return [ this[0], MAP(elements, walk) ];
+ },
+ "stat": function(stat) {
+ return [ this[0], walk(stat) ];
+ },
+ "seq": function() {
+ return [ this[0] ].concat(MAP(slice(arguments), walk));
+ },
+ "label": function(name, block) {
+ return [ this[0], name, walk(block) ];
+ },
+ "with": function(expr, block) {
+ return [ this[0], walk(expr), walk(block) ];
+ },
+ "atom": function(name) {
+ return [ this[0], name ];
+ },
+ "directive": function(dir) {
+ return [ this[0], dir ];
+ }
+ };
+
+ var user = {};
+ var stack = [];
+ function walk(ast) {
+ if (ast == null)
+ return null;
+ try {
+ stack.push(ast);
+ var type = ast[0];
+ var gen = user[type];
+ if (gen) {
+ var ret = gen.apply(ast, ast.slice(1));
+ if (ret != null)
+ return ret;
+ }
+ gen = walkers[type];
+ return gen.apply(ast, ast.slice(1));
+ } finally {
+ stack.pop();
+ }
+ };
+
+ function dive(ast) {
+ if (ast == null)
+ return null;
+ try {
+ stack.push(ast);
+ return walkers[ast[0]].apply(ast, ast.slice(1));
+ } finally {
+ stack.pop();
+ }
+ };
+
+ function with_walkers(walkers, cont){
+ var save = {}, i;
+ for (i in walkers) if (HOP(walkers, i)) {
+ save[i] = user[i];
+ user[i] = walkers[i];
+ }
+ var ret = cont();
+ for (i in save) if (HOP(save, i)) {
+ if (!save[i]) delete user[i];
+ else user[i] = save[i];
+ }
+ return ret;
+ };
+
+ return {
+ walk: walk,
+ dive: dive,
+ with_walkers: with_walkers,
+ parent: function() {
+ return stack[stack.length - 2]; // last one is current node
+ },
+ stack: function() {
+ return stack;
+ }
+ };
+};
+
+/* -----[ Scope and mangling ]----- */
+
+function Scope(parent) {
+ this.names = {}; // names defined in this scope
+ this.mangled = {}; // mangled names (orig.name => mangled)
+ this.rev_mangled = {}; // reverse lookup (mangled => orig.name)
+ this.cname = -1; // current mangled 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.directives = []; // directives activated from this scope
+ this.parent = parent; // parent scope
+ this.children = []; // sub-scopes
+ if (parent) {
+ this.level = parent.level + 1;
+ parent.children.push(this);
+ } else {
+ this.level = 0;
+ }
+};
+
+function base54_digits() {
+ if (typeof DIGITS_OVERRIDE_FOR_TESTING != "undefined")
+ return DIGITS_OVERRIDE_FOR_TESTING;
+ else
+ return "etnrisouaflchpdvmgybwESxTNCkLAOM_DPHBjFIqRUzWXV$JKQGYZ0516372984";
+}
+
+var base54 = (function(){
+ var DIGITS = base54_digits();
+ return function(num) {
+ var ret = "", base = 54;
+ do {
+ ret += DIGITS.charAt(num % base);
+ num = Math.floor(num / base);
+ base = 64;
+ } while (num > 0);
+ return ret;
+ };
+})();
+
+Scope.prototype = {
+ has: function(name) {
+ for (var s = this; s; s = s.parent)
+ if (HOP(s.names, name))
+ return s;
+ },
+ has_mangled: function(mname) {
+ for (var s = this; s; s = s.parent)
+ if (HOP(s.rev_mangled, mname))
+ return s;
+ },
+ toJSON: function() {
+ return {
+ names: this.names,
+ uses_eval: this.uses_eval,
+ uses_with: this.uses_with
+ };
+ },
+
+ 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 (;;) {
+ var m = base54(++this.cname), prior;
+
+ // case 1.
+ prior = this.has_mangled(m);
+ if (prior && this.refs[prior.rev_mangled[m]] === prior)
+ continue;
+
+ // case 2.
+ prior = this.has(m);
+ if (prior && prior !== this && this.refs[m] === prior && !prior.has_mangled(m))
+ continue;
+
+ // case 3.
+ if (HOP(this.refs, m) && this.refs[m] == null)
+ continue;
+
+ // I got "do" once. :-/
+ if (!is_identifier(m))
+ continue;
+
+ return m;
+ }
+ },
+ set_mangle: function(name, m) {
+ this.rev_mangled[m] = name;
+ return this.mangled[name] = m;
+ },
+ get_mangled: function(name, newMangle) {
+ if (this.uses_eval || this.uses_with) return name; // no mangle if eval or with is in use
+ var s = this.has(name);
+ if (!s) return name; // not in visible scope, no mangle
+ if (HOP(s.mangled, name)) return s.mangled[name]; // already mangled in this scope
+ if (!newMangle) return name; // not found and no mangling requested
+ return s.set_mangle(name, s.next_mangled());
+ },
+ references: function(name) {
+ return name && !this.parent || this.uses_with || this.uses_eval || this.refs[name];
+ },
+ define: function(name, type) {
+ if (name != null) {
+ if (type == "var" || !HOP(this.names, name))
+ this.names[name] = type || "var";
+ return name;
+ }
+ },
+ active_directive: function(dir) {
+ return member(dir, this.directives) || this.parent && this.parent.active_directive(dir);
+ }
+};
+
+function ast_add_scope(ast) {
+
+ var current_scope = null;
+ var w = ast_walker(), walk = w.walk;
+ var having_eval = [];
+
+ function with_new_scope(cont) {
+ current_scope = new Scope(current_scope);
+ current_scope.labels = new Scope();
+ var ret = current_scope.body = cont();
+ ret.scope = current_scope;
+ current_scope = current_scope.parent;
+ return ret;
+ };
+
+ function define(name, type) {
+ return current_scope.define(name, type);
+ };
+
+ function reference(name) {
+ current_scope.refs[name] = true;
+ };
+
+ function _lambda(name, args, body) {
+ var is_defun = this[0] == "defun";
+ return [ this[0], is_defun ? define(name, "defun") : name, args, with_new_scope(function(){
+ if (!is_defun) define(name, "lambda");
+ MAP(args, function(name){ define(name, "arg") });
+ return MAP(body, walk);
+ })];
+ };
+
+ function _vardefs(type) {
+ return function(defs) {
+ MAP(defs, function(d){
+ define(d[0], type);
+ if (d[1]) reference(d[0]);
+ });
+ };
+ };
+
+ function _breacont(label) {
+ if (label)
+ current_scope.labels.refs[label] = true;
+ };
+
+ return with_new_scope(function(){
+ // process AST
+ var ret = w.with_walkers({
+ "function": _lambda,
+ "defun": _lambda,
+ "label": function(name, stat) { current_scope.labels.define(name) },
+ "break": _breacont,
+ "continue": _breacont,
+ "with": function(expr, block) {
+ for (var s = current_scope; s; s = s.parent)
+ s.uses_with = true;
+ },
+ "var": _vardefs("var"),
+ "const": _vardefs("const"),
+ "try": function(t, c, f) {
+ if (c != null) return [
+ this[0],
+ MAP(t, walk),
+ [ define(c[0], "catch"), MAP(c[1], walk) ],
+ f != null ? MAP(f, walk) : null
+ ];
+ },
+ "name": function(name) {
+ if (name == "eval")
+ having_eval.push(current_scope);
+ reference(name);
+ }
+ }, function(){
+ return walk(ast);
+ });
+
+ // 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.
+ MAP(having_eval, function(scope){
+ if (!scope.has("eval")) while (scope) {
+ scope.uses_eval = true;
+ scope = scope.parent;
+ }
+ });
+
+ // for referenced names it might be useful to know
+ // their origin scope. current_scope here is the
+ // toplevel one.
+ function fixrefs(scope, i) {
+ // do children first; order shouldn't matter
+ for (i = scope.children.length; --i >= 0;)
+ fixrefs(scope.children[i]);
+ for (i in scope.refs) if (HOP(scope.refs, i)) {
+ // find origin scope and propagate the reference to origin
+ for (var origin = scope.has(i), s = scope; s; s = s.parent) {
+ s.refs[i] = origin;
+ if (s === origin) break;
+ }
+ }
+ };
+ fixrefs(current_scope);
+
+ return ret;
+ });
+
+};
+
+/* -----[ mangle names ]----- */
+
+function ast_mangle(ast, options) {
+ var w = ast_walker(), walk = w.walk, scope;
+ options = defaults(options, {
+ mangle : true,
+ toplevel : false,
+ defines : null,
+ except : null,
+ no_functions : false
+ });
+
+ function get_mangled(name, newMangle) {
+ if (!options.mangle) return name;
+ if (!options.toplevel && !scope.parent) return name; // don't mangle toplevel
+ if (options.except && member(name, options.except))
+ return name;
+ if (options.no_functions && HOP(scope.names, name) &&
+ (scope.names[name] == 'defun' || scope.names[name] == 'lambda'))
+ return name;
+ return scope.get_mangled(name, newMangle);
+ };
+
+ function get_define(name) {
+ if (options.defines) {
+ // 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
+ if (!scope.has(name)) {
+ if (HOP(options.defines, name)) {
+ return options.defines[name];
+ }
+ }
+ return null;
+ }
+ };
+
+ function _lambda(name, args, body) {
+ if (!options.no_functions && options.mangle) {
+ var is_defun = this[0] == "defun", extra;
+ if (name) {
+ if (is_defun) name = get_mangled(name);
+ else if (body.scope.references(name)) {
+ extra = {};
+ if (!(scope.uses_eval || scope.uses_with))
+ name = extra[name] = scope.next_mangled();
+ else
+ extra[name] = name;
+ }
+ else name = null;
+ }
+ }
+ body = with_scope(body.scope, function(){
+ args = MAP(args, function(name){ return get_mangled(name) });
+ return MAP(body, walk);
+ }, extra);
+ return [ this[0], name, args, body ];
+ };
+
+ function with_scope(s, cont, extra) {
+ var _scope = scope;
+ scope = s;
+ if (extra) for (var i in extra) if (HOP(extra, i)) {
+ s.set_mangle(i, extra[i]);
+ }
+ for (var i in s.names) if (HOP(s.names, i)) {
+ get_mangled(i, true);
+ }
+ var ret = cont();
+ ret.scope = s;
+ scope = _scope;
+ return ret;
+ };
+
+ function _vardefs(defs) {
+ return [ this[0], MAP(defs, function(d){
+ return [ get_mangled(d[0]), walk(d[1]) ];
+ }) ];
+ };
+
+ function _breacont(label) {
+ if (label) return [ this[0], scope.labels.get_mangled(label) ];
+ };
+
+ return w.with_walkers({
+ "function": _lambda,
+ "defun": function() {
+ // move function declarations to the top when
+ // they are not in some block.
+ var ast = _lambda.apply(this, arguments);
+ switch (w.parent()[0]) {
+ case "toplevel":
+ case "function":
+ case "defun":
+ return MAP.at_top(ast);
+ }
+ return ast;
+ },
+ "label": function(label, stat) {
+ if (scope.labels.refs[label]) return [
+ this[0],
+ scope.labels.get_mangled(label, true),
+ walk(stat)
+ ];
+ return walk(stat);
+ },
+ "break": _breacont,
+ "continue": _breacont,
+ "var": _vardefs,
+ "const": _vardefs,
+ "name": function(name) {
+ return get_define(name) || [ this[0], get_mangled(name) ];
+ },
+ "try": function(t, c, f) {
+ return [ this[0],
+ MAP(t, walk),
+ c != null ? [ get_mangled(c[0]), MAP(c[1], walk) ] : null,
+ f != null ? MAP(f, walk) : null ];
+ },
+ "toplevel": function(body) {
+ var self = this;
+ return with_scope(self.scope, function(){
+ return [ self[0], MAP(body, walk) ];
+ });
+ },
+ "directive": function() {
+ return MAP.at_top(this);
+ }
+ }, function() {
+ return walk(ast_add_scope(ast));
+ });
+};
+
+/* -----[
+ - 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 best_of(ast1, ast2) {
+ return gen_code(ast1).length > gen_code(ast2[0] == "stat" ? ast2[1] : ast2).length ? ast2 : ast1;
+};
+
+function last_stat(b) {
+ if (b[0] == "block" && b[1] && b[1].length > 0)
+ return b[1][b[1].length - 1];
+ 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) {
+ return ( (expr[0] == "unary-prefix"
+ && member(expr[1], [ "!", "delete" ])) ||
+
+ (expr[0] == "binary"
+ && member(expr[1], [ "in", "instanceof", "==", "!=", "===", "!==", "<", "<=", ">=", ">" ])) ||
+
+ (expr[0] == "binary"
+ && member(expr[1], [ "&&", "||" ])
+ && boolean_expr(expr[2])
+ && boolean_expr(expr[3])) ||
+
+ (expr[0] == "conditional"
+ && boolean_expr(expr[2])
+ && boolean_expr(expr[3])) ||
+
+ (expr[0] == "assign"
+ && expr[1] === true
+ && boolean_expr(expr[3])) ||
+
+ (expr[0] == "seq"
+ && boolean_expr(expr[expr.length - 1]))
+ );
+};
+
+function empty(b) {
+ return !b || (b[0] == "block" && (!b[1] || b[1].length == 0));
+};
+
+function is_string(node) {
+ return (node[0] == "string" ||
+ node[0] == "unary-prefix" && node[1] == "typeof" ||
+ node[0] == "binary" && node[1] == "+" &&
+ (is_string(node[2]) || is_string(node[3])));
+};
+
+var when_constant = (function(){
+
+ var $NOT_CONSTANT = {};
+
+ // this can only evaluate constant expressions. If it finds anything
+ // not constant, it throws $NOT_CONSTANT.
+ function evaluate(expr) {
+ 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]) {
+ case "!": return !evaluate(expr[2]);
+ case "typeof": return typeof evaluate(expr[2]);
+ case "~": return ~evaluate(expr[2]);
+ case "-": return -evaluate(expr[2]);
+ case "+": return +evaluate(expr[2]);
+ }
+ break;
+ case "binary":
+ var left = expr[2], right = expr[3];
+ switch (expr[1]) {
+ case "&&" : return evaluate(left) && evaluate(right);
+ case "||" : return evaluate(left) || evaluate(right);
+ case "|" : return evaluate(left) | evaluate(right);
+ case "&" : return evaluate(left) & evaluate(right);
+ case "^" : return evaluate(left) ^ evaluate(right);
+ case "+" : return evaluate(left) + evaluate(right);
+ case "*" : return evaluate(left) * evaluate(right);
+ case "/" : return evaluate(left) / evaluate(right);
+ case "%" : return evaluate(left) % evaluate(right);
+ case "-" : return evaluate(left) - evaluate(right);
+ case "<<" : return evaluate(left) << evaluate(right);
+ case ">>" : return evaluate(left) >> evaluate(right);
+ case ">>>" : return evaluate(left) >>> evaluate(right);
+ case "==" : return evaluate(left) == evaluate(right);
+ case "===" : return evaluate(left) === evaluate(right);
+ case "!=" : return evaluate(left) != evaluate(right);
+ case "!==" : return evaluate(left) !== evaluate(right);
+ case "<" : return evaluate(left) < evaluate(right);
+ case "<=" : return evaluate(left) <= evaluate(right);
+ case ">" : return evaluate(left) > evaluate(right);
+ case ">=" : return evaluate(left) >= evaluate(right);
+ case "in" : return evaluate(left) in evaluate(right);
+ case "instanceof" : return evaluate(left) instanceof evaluate(right);
+ }
+ }
+ throw $NOT_CONSTANT;
+ };
+
+ return function(expr, yes, no) {
+ try {
+ var val = evaluate(expr), ast;
+ switch (typeof val) {
+ case "string": ast = [ "string", val ]; break;
+ case "number": ast = [ "num", val ]; break;
+ case "boolean": ast = [ "name", String(val) ]; break;
+ default:
+ if (val === null) { ast = [ "atom", "null" ]; break; }
+ throw new Error("Can't handle constant of type: " + (typeof val));
+ }
+ return yes.call(expr, ast, val);
+ } catch(ex) {
+ if (ex === $NOT_CONSTANT) {
+ if (expr[0] == "binary"
+ && (expr[1] == "===" || expr[1] == "!==")
+ && ((is_string(expr[2]) && is_string(expr[3]))
+ || (boolean_expr(expr[2]) && boolean_expr(expr[3])))) {
+ expr[1] = expr[1].substr(0, 2);
+ }
+ else if (no && expr[0] == "binary"
+ && (expr[1] == "||" || expr[1] == "&&")) {
+ // the whole expression is not constant but the lval may be...
+ try {
+ var lval = evaluate(expr[2]);
+ expr = ((expr[1] == "&&" && (lval ? expr[3] : lval)) ||
+ (expr[1] == "||" && (lval ? lval : expr[3])) ||
+ expr);
+ } catch(ex2) {
+ // IGNORE... lval is not constant
+ }
+ }
+ return no ? no.call(expr, expr) : null;
+ }
+ else throw ex;
+ }
+ };
+
+})();
+
+function warn_unreachable(ast) {
+ if (!empty(ast))
+ warn("Dropping unreachable code: " + gen_code(ast, true));
+};
+
+function prepare_ifs(ast) {
+ var w = ast_walker(), walk = w.walk;
+ // 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) {
+ statements = MAP(statements, walk);
+
+ for (var i = 0; i < statements.length; ++i) {
+ var fi = statements[i];
+ if (fi[0] != "if") continue;
+
+ if (fi[3]) continue;
+
+ var t = fi[2];
+ if (!aborts(t)) continue;
+
+ var conditional = walk(fi[1]);
+
+ var e_body = redo_if(statements.slice(i + 1));
+ var e = e_body.length == 1 ? e_body[0] : [ "block", e_body ];
+
+ return statements.slice(0, i).concat([ [
+ fi[0], // "if"
+ conditional, // conditional
+ t, // then
+ e // else
+ ] ]);
+ }
+
+ return statements;
+ };
+
+ function redo_if_lambda(name, args, body) {
+ body = redo_if(body);
+ return [ this[0], name, args, body ];
+ };
+
+ function redo_if_block(statements) {
+ return [ this[0], statements != null ? redo_if(statements) : null ];
+ };
+
+ return w.with_walkers({
+ "defun": redo_if_lambda,
+ "function": redo_if_lambda,
+ "block": redo_if_block,
+ "splice": redo_if_block,
+ "toplevel": function(statements) {
+ return [ this[0], redo_if(statements) ];
+ },
+ "try": function(t, c, f) {
+ return [
+ this[0],
+ redo_if(t),
+ c != null ? [ c[0], redo_if(c[1]) ] : null,
+ f != null ? redo_if(f) : null
+ ];
+ }
+ }, function() {
+ return walk(ast);
+ });
+};
+
+function for_side_effects(ast, handler) {
+ var w = ast_walker(), walk = w.walk;
+ var $stop = {}, $restart = {};
+ function stop() { throw $stop };
+ function restart() { throw $restart };
+ function found(){ return handler.call(this, this, w, stop, restart) };
+ function unary(op) {
+ if (op == "++" || op == "--")
+ return found.apply(this, arguments);
+ };
+ function binary(op) {
+ if (op == "&&" || op == "||")
+ return found.apply(this, arguments);
+ };
+ 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,
+ "conditional": found,
+ "binary": binary,
+ "defun": found
+ }, function(){
+ while (true) try {
+ walk(ast);
+ break;
+ } catch(ex) {
+ if (ex === $stop) break;
+ if (ex === $restart) continue;
+ throw ex;
+ }
+ });
+};
+
+function ast_lift_variables(ast) {
+ var w = ast_walker(), walk = w.walk, scope;
+ function do_body(body, env) {
+ var _scope = scope;
+ scope = env;
+ body = MAP(body, walk);
+ var hash = {}, names = MAP(env.names, function(type, name){
+ if (type != "var") return MAP.skip;
+ if (!env.references(name)) return MAP.skip;
+ hash[name] = true;
+ return [ name ];
+ });
+ if (names.length > 0) {
+ // looking for assignments to any of these variables.
+ // we can save considerable space by moving the definitions
+ // in the var declaration.
+ for_side_effects([ "block", body ], function(ast, walker, stop, restart) {
+ if (ast[0] == "assign"
+ && ast[1] === true
+ && ast[2][0] == "name"
+ && HOP(hash, ast[2][1])) {
+ // insert the definition into the var declaration
+ for (var i = names.length; --i >= 0;) {
+ if (names[i][0] == ast[2][1]) {
+ if (names[i][1]) // this name already defined, we must stop
+ stop();
+ names[i][1] = ast[3]; // definition
+ names.push(names.splice(i, 1)[0]);
+ break;
+ }
+ }
+ // remove this assignment from the AST.
+ var p = walker.parent();
+ if (p[0] == "seq") {
+ var a = p[2];
+ a.unshift(0, p.length);
+ p.splice.apply(p, a);
+ }
+ else if (p[0] == "stat") {
+ p.splice(0, p.length, "block"); // empty statement
+ }
+ else {
+ stop();
+ }
+ restart();
+ }
+ stop();
+ });
+ body.unshift([ "var", names ]);
+ }
+ scope = _scope;
+ return body;
+ };
+ function _vardefs(defs) {
+ var ret = null;
+ for (var i = defs.length; --i >= 0;) {
+ var d = defs[i];
+ if (!d[1]) continue;
+ d = [ "assign", true, [ "name", d[0] ], d[1] ];
+ if (ret == null) ret = d;
+ else ret = [ "seq", d, ret ];
+ }
+ if (ret == null && w.parent()[0] != "for") {
+ if (w.parent()[0] == "for-in")
+ return [ "name", defs[0][0] ];
+ return MAP.skip;
+ }
+ return [ "stat", ret ];
+ };
+ function _toplevel(body) {
+ return [ this[0], do_body(body, this.scope) ];
+ };
+ return w.with_walkers({
+ "function": function(name, args, body){
+ for (var i = args.length; --i >= 0 && !body.scope.references(args[i]);)
+ args.pop();
+ if (!body.scope.references(name)) name = null;
+ return [ this[0], name, args, do_body(body, body.scope) ];
+ },
+ "defun": function(name, args, body){
+ if (!scope.references(name)) return MAP.skip;
+ for (var i = args.length; --i >= 0 && !body.scope.references(args[i]);)
+ args.pop();
+ return [ this[0], name, args, do_body(body, body.scope) ];
+ },
+ "var": _vardefs,
+ "toplevel": _toplevel
+ }, function(){
+ return walk(ast_add_scope(ast));
+ });
+};
+
+function ast_squeeze(ast, options) {
+ ast = squeeze_1(ast, options);
+ ast = squeeze_2(ast, options);
+ return ast;
+};
+
+function squeeze_1(ast, options) {
+ options = defaults(options, {
+ make_seqs : true,
+ dead_code : true,
+ no_warnings : false,
+ keep_comps : true,
+ unsafe : false
+ });
+
+ var w = ast_walker(), walk = w.walk, scope;
+
+ function negate(c) {
+ var not_c = [ "unary-prefix", "!", c ];
+ switch (c[0]) {
+ case "unary-prefix":
+ return c[1] == "!" && boolean_expr(c[2]) ? c[2] : not_c;
+ case "seq":
+ c = slice(c);
+ c[c.length - 1] = negate(c[c.length - 1]);
+ return c;
+ case "conditional":
+ return best_of(not_c, [ "conditional", c[1], negate(c[2]), negate(c[3]) ]);
+ case "binary":
+ var op = c[1], left = c[2], right = c[3];
+ if (!options.keep_comps) switch (op) {
+ case "<=" : return [ "binary", ">", left, right ];
+ case "<" : return [ "binary", ">=", left, right ];
+ case ">=" : return [ "binary", "<", left, right ];
+ case ">" : return [ "binary", "<=", left, right ];
+ }
+ switch (op) {
+ case "==" : return [ "binary", "!=", left, right ];
+ case "!=" : return [ "binary", "==", left, right ];
+ case "===" : return [ "binary", "!==", left, right ];
+ case "!==" : return [ "binary", "===", left, right ];
+ case "&&" : return best_of(not_c, [ "binary", "||", negate(left), negate(right) ]);
+ case "||" : return best_of(not_c, [ "binary", "&&", negate(left), negate(right) ]);
+ }
+ 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
+ return when_constant(c, function(ast, val){
+ warn_unreachable(val ? e : t);
+ return (val ? t : e);
+ }, make_real_conditional);
+ };
+
+ function rmblock(block) {
+ if (block != null && block[0] == "block" && block[1]) {
+ if (block[1].length == 1)
+ block = block[1][0];
+ else if (block[1].length == 0)
+ block = [ "block" ];
+ }
+ return block;
+ };
+
+ function _lambda(name, args, body) {
+ return [ this[0], name, args, tighten(body, "lambda") ];
+ };
+
+ // 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) { ... }
+ function tighten(statements, block_type) {
+ statements = MAP(statements, walk);
+
+ statements = statements.reduce(function(a, stat){
+ if (stat[0] == "block") {
+ if (stat[1]) {
+ a.push.apply(a, stat[1]);
+ }
+ } else {
+ a.push(stat);
+ }
+ return a;
+ }, []);
+
+ statements = (function(a, prev){
+ statements.forEach(function(cur){
+ if (prev && ((cur[0] == "var" && prev[0] == "var") ||
+ (cur[0] == "const" && prev[0] == "const"))) {
+ prev[1] = prev[1].concat(cur[1]);
+ } else {
+ a.push(cur);
+ prev = cur;
+ }
+ });
+ return a;
+ })([]);
+
+ if (options.dead_code) statements = (function(a, has_quit){
+ statements.forEach(function(st){
+ if (has_quit) {
+ if (st[0] == "function" || st[0] == "defun") {
+ a.push(st);
+ }
+ else if (st[0] == "var" || st[0] == "const") {
+ if (!options.no_warnings)
+ warn("Variables declared in unreachable code");
+ st[1] = MAP(st[1], function(def){
+ if (def[1] && !options.no_warnings)
+ warn_unreachable([ "assign", true, [ "name", def[0] ], def[1] ]);
+ return [ def[0] ];
+ });
+ a.push(st);
+ }
+ else if (!options.no_warnings)
+ warn_unreachable(st);
+ }
+ else {
+ a.push(st);
+ if (member(st[0], [ "return", "throw", "break", "continue" ]))
+ has_quit = true;
+ }
+ });
+ return a;
+ })([]);
+
+ if (options.make_seqs) statements = (function(a, prev) {
+ statements.forEach(function(cur){
+ if (prev && prev[0] == "stat" && cur[0] == "stat") {
+ prev[1] = [ "seq", prev[1], cur[1] ];
+ } else {
+ a.push(cur);
+ prev = cur;
+ }
+ });
+ if (a.length >= 2
+ && a[a.length-2][0] == "stat"
+ && (a[a.length-1][0] == "return" || a[a.length-1][0] == "throw")
+ && a[a.length-1][1])
+ {
+ a.splice(a.length - 2, 2,
+ [ a[a.length-1][0],
+ [ "seq", a[a.length-2][1], a[a.length-1][1] ]]);
+ }
+ 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) {
+ return when_constant(c, function(ast, val){
+ 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 abort_else(c, t, e) {
+ var ret = [ [ "if", negate(c), e ] ];
+ if (t[0] == "block") {
+ if (t[1]) ret = ret.concat(t[1]);
+ } else {
+ ret.push(t);
+ }
+ return walk([ "block", ret ]);
+ };
+
+ function make_real_if(c, t, e) {
+ c = walk(c);
+ t = walk(t);
+ e = walk(e);
+
+ if (empty(e) && empty(t))
+ return [ "stat", c ];
+
+ 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);
+ if (b.length < a.length) {
+ var tmp = t;
+ t = e;
+ e = tmp;
+ c = n;
+ }
+ })();
+ }
+ var ret = [ "if", c, t, e ];
+ if (t[0] == "if" && empty(t[3]) && empty(e)) {
+ ret = best_of(ret, walk([ "if", [ "binary", "&&", c, t[1] ], t[2] ]));
+ }
+ else if (t[0] == "stat") {
+ if (e) {
+ if (e[0] == "stat")
+ ret = best_of(ret, [ "stat", make_conditional(c, t[1], e[1]) ]);
+ else if (aborts(e))
+ ret = abort_else(c, t, e);
+ }
+ else {
+ ret = best_of(ret, [ "stat", make_conditional(c, t[1]) ]);
+ }
+ }
+ else if (e && t[0] == e[0] && (t[0] == "return" || t[0] == "throw") && t[1] && e[1]) {
+ ret = best_of(ret, [ t[0], make_conditional(c, t[1], e[1] ) ]);
+ }
+ else if (e && aborts(t)) {
+ ret = [ [ "if", c, t ] ];
+ if (e[0] == "block") {
+ if (e[1]) ret = ret.concat(e[1]);
+ }
+ else {
+ ret.push(e);
+ }
+ ret = walk([ "block", ret ]);
+ }
+ else if (t && aborts(e)) {
+ ret = abort_else(c, t, e);
+ }
+ return ret;
+ };
+
+ function _do_while(cond, body) {
+ return when_constant(cond, function(cond, val){
+ if (!val) {
+ warn_unreachable(body);
+ return [ "block" ];
+ } else {
+ return [ "for", null, null, null, walk(body) ];
+ }
+ });
+ };
+
+ return w.with_walkers({
+ "sub": function(expr, subscript) {
+ if (subscript[0] == "string") {
+ var name = subscript[1];
+ if (is_identifier(name))
+ return [ "dot", walk(expr), name ];
+ else if (/^[1-9][0-9]*$/.test(name) || name === "0")
+ return [ "sub", walk(expr), [ "num", parseInt(name, 10) ] ];
+ }
+ },
+ "if": make_if,
+ "toplevel": function(body) {
+ return [ "toplevel", tighten(body) ];
+ },
+ "switch": function(expr, body) {
+ var last = body.length - 1;
+ return [ "switch", walk(expr), MAP(body, function(branch, i){
+ var block = tighten(branch[1]);
+ if (i == last && block.length > 0) {
+ var node = block[block.length - 1];
+ if (node[0] == "break" && !node[1])
+ block.pop();
+ }
+ return [ branch[0] ? walk(branch[0]) : null, block ];
+ }) ];
+ },
+ "function": _lambda,
+ "defun": _lambda,
+ "block": function(body) {
+ if (body) return rmblock([ "block", tighten(body) ]);
+ },
+ "binary": function(op, left, right) {
+ return when_constant([ "binary", op, walk(left), walk(right) ], function yes(c){
+ return best_of(walk(c), this);
+ }, function no() {
+ return function(){
+ if(op != "==" && op != "!=") return;
+ var l = walk(left), r = walk(right);
+ if(l && l[0] == "unary-prefix" && l[1] == "!" && l[2][0] == "num")
+ left = ['num', +!l[2][1]];
+ else if (r && r[0] == "unary-prefix" && r[1] == "!" && r[2][0] == "num")
+ right = ['num', +!r[2][1]];
+ return ["binary", op, left, right];
+ }() || this;
+ });
+ },
+ "conditional": function(c, t, e) {
+ return make_conditional(walk(c), walk(t), walk(e));
+ },
+ "try": function(t, c, f) {
+ return [
+ "try",
+ tighten(t),
+ c != null ? [ c[0], tighten(c[1]) ] : null,
+ f != null ? tighten(f) : null
+ ];
+ },
+ "unary-prefix": function(op, expr) {
+ expr = walk(expr);
+ var ret = [ "unary-prefix", op, expr ];
+ if (op == "!")
+ ret = best_of(ret, negate(expr));
+ return when_constant(ret, function(ast, val){
+ return walk(ast); // it's either true or false, so minifies to !0 or !1
+ }, 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,
+ "assign": function(op, lvalue, rvalue) {
+ lvalue = walk(lvalue);
+ rvalue = walk(rvalue);
+ var okOps = [ '+', '-', '/', '*', '%', '>>', '<<', '>>>', '|', '^', '&' ];
+ if (op === true && lvalue[0] === "name" && rvalue[0] === "binary" &&
+ ~okOps.indexOf(rvalue[1]) && rvalue[2][0] === "name" &&
+ rvalue[2][1] === lvalue[1]) {
+ return [ this[0], rvalue[1], lvalue, rvalue[3] ]
+ }
+ return [ this[0], op, lvalue, rvalue ];
+ },
+ "call": function(expr, args) {
+ expr = walk(expr);
+ if (options.unsafe && expr[0] == "dot" && expr[1][0] == "string" && expr[2] == "toString") {
+ return expr[1];
+ }
+ return [ this[0], expr, MAP(args, walk) ];
+ },
+ "num": function (num) {
+ if (!isFinite(num))
+ return [ "binary", "/", num === 1 / 0
+ ? [ "num", 1 ] : num === -1 / 0
+ ? [ "unary-prefix", "-", [ "num", 1 ] ]
+ : [ "num", 0 ], [ "num", 0 ] ];
+
+ return [ this[0], num ];
+ }
+ }, function() {
+ return walk(prepare_ifs(walk(prepare_ifs(ast))));
+ });
+};
+
+function squeeze_2(ast, options) {
+ var w = ast_walker(), walk = w.walk, scope;
+ function with_scope(s, cont) {
+ var save = scope, ret;
+ scope = s;
+ ret = cont();
+ scope = save;
+ return ret;
+ };
+ function lambda(name, args, body) {
+ return [ this[0], name, args, with_scope(body.scope, curry(MAP, body, walk)) ];
+ };
+ return w.with_walkers({
+ "directive": function(dir) {
+ if (scope.active_directive(dir))
+ return [ "block" ];
+ scope.directives.push(dir);
+ },
+ "toplevel": function(body) {
+ return [ this[0], with_scope(this.scope, curry(MAP, body, walk)) ];
+ },
+ "function": lambda,
+ "defun": lambda
+ }, function(){
+ return walk(ast_add_scope(ast));
+ });
+};
+
+/* -----[ re-generate code from the AST ]----- */
+
+var DOT_CALL_NO_PARENS = jsp.array_to_hash([
+ "name",
+ "array",
+ "object",
+ "string",
+ "dot",
+ "sub",
+ "call",
+ "regexp",
+ "defun"
+]);
+
+function make_string(str, ascii_only) {
+ var dq = 0, sq = 0;
+ str = str.replace(/[\\\b\f\n\r\t\x22\x27\u2028\u2029\0]/g, function(s){
+ switch (s) {
+ case "\\": return "\\\\";
+ case "\b": return "\\b";
+ case "\f": return "\\f";
+ case "\n": return "\\n";
+ case "\r": return "\\r";
+ case "\u2028": return "\\u2028";
+ case "\u2029": return "\\u2029";
+ case '"': ++dq; return '"';
+ case "'": ++sq; return "'";
+ case "\0": return "\\0";
+ }
+ return s;
+ });
+ if (ascii_only) str = to_ascii(str);
+ if (dq > sq) return "'" + str.replace(/\x27/g, "\\'") + "'";
+ else return '"' + str.replace(/\x22/g, '\\"') + '"';
+};
+
+function to_ascii(str) {
+ return str.replace(/[\u0080-\uffff]/g, function(ch) {
+ var code = ch.charCodeAt(0).toString(16);
+ while (code.length < 4) code = "0" + code;
+ return "\\u" + code;
+ });
+};
+
+var SPLICE_NEEDS_BRACKETS = jsp.array_to_hash([ "if", "while", "do", "for", "for-in", "with" ]);
+
+function gen_code(ast, options) {
+ options = defaults(options, {
+ indent_start : 0,
+ indent_level : 4,
+ quote_keys : false,
+ space_colon : false,
+ beautify : false,
+ ascii_only : false,
+ inline_script: false
+ });
+ var beautify = !!options.beautify;
+ var indentation = 0,
+ newline = beautify ? "\n" : "",
+ space = beautify ? " " : "";
+
+ function encode_string(str) {
+ var ret = make_string(str, options.ascii_only);
+ if (options.inline_script)
+ ret = ret.replace(/<\x2fscript([>\/\t\n\f\r ])/gi, "<\\/script$1");
+ return ret;
+ };
+
+ function make_name(name) {
+ name = name.toString();
+ if (options.ascii_only)
+ name = to_ascii(name);
+ return name;
+ };
+
+ function indent(line) {
+ if (line == null)
+ line = "";
+ if (beautify)
+ line = repeat_string(" ", options.indent_start + indentation * options.indent_level) + line;
+ return line;
+ };
+
+ function with_indent(cont, incr) {
+ if (incr == null) incr = 1;
+ indentation += incr;
+ try { return cont.apply(null, slice(arguments, 1)); }
+ finally { indentation -= incr; }
+ };
+
+ function last_char(str) {
+ str = str.toString();
+ return str.charAt(str.length - 1);
+ };
+
+ function first_char(str) {
+ return str.toString().charAt(0);
+ };
+
+ 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 &&
+ ((is_identifier_char(last_char(a[i])) && (is_identifier_char(first_char(next))
+ || first_char(next) == "\\")) ||
+ (/[\+\-]$/.test(a[i].toString()) && /^[\+\-]/.test(next.toString()) ||
+ last_char(a[i]) == "/" && first_char(next) == "/"))) {
+ b.push(" ");
+ }
+ }
+ return b.join("");
+ };
+
+ function add_commas(a) {
+ return a.join("," + space);
+ };
+
+ function parenthesize(expr) {
+ var gen = make(expr);
+ for (var i = 1; i < arguments.length; ++i) {
+ var el = arguments[i];
+ if ((el instanceof Function && el(expr)) || expr[0] == el)
+ return "(" + gen + ")";
+ }
+ return gen;
+ };
+
+ function best_of(a) {
+ if (a.length == 1) {
+ return a[0];
+ }
+ if (a.length == 2) {
+ var b = a[1];
+ a = a[0];
+ return a.length <= b.length ? a : b;
+ }
+ return best_of([ a[0], best_of(a.slice(1)) ]);
+ };
+
+ function needs_parens(expr) {
+ if (expr[0] == "function" || expr[0] == "object") {
+ // dot/call on a literal function requires the
+ // 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.
+ var a = slice(w.stack()), self = a.pop(), p = a.pop();
+ 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) ||
+ ((p[0] == "binary" || p[0] == "assign" || p[0] == "unary-postfix") && p[2] === self)) {
+ self = p;
+ p = a.pop();
+ } else {
+ return false;
+ }
+ }
+ }
+ return !HOP(DOT_CALL_NO_PARENS, expr[0]);
+ };
+
+ function make_num(num) {
+ var str = num.toString(10), a = [ str.replace(/^0\./, ".").replace('e+', 'e') ], m;
+ if (Math.floor(num) === num) {
+ if (num >= 0) {
+ a.push("0x" + num.toString(16).toLowerCase(), // probably pointless
+ "0" + num.toString(8)); // same.
+ } else {
+ a.push("-0x" + (-num).toString(16).toLowerCase(), // probably pointless
+ "-0" + (-num).toString(8)); // same.
+ }
+ if ((m = /^(.*?)(0+)$/.exec(num))) {
+ a.push(m[1] + "e" + m[2].length);
+ }
+ } else if ((m = /^0?\.(0+)(.*)$/.exec(num))) {
+ a.push(m[2] + "e-" + (m[1].length + m[2].length),
+ str.substr(str.indexOf(".")));
+ }
+ return best_of(a);
+ };
+
+ var w = ast_walker();
+ var make = w.walk;
+ return w.with_walkers({
+ "string": encode_string,
+ "num": make_num,
+ "name": make_name,
+ "debugger": function(){ return "debugger;" },
+ "toplevel": function(statements) {
+ return make_block_statements(statements)
+ .join(newline + newline);
+ },
+ "splice": function(statements) {
+ var parent = w.parent();
+ if (HOP(SPLICE_NEEDS_BRACKETS, parent)) {
+ // we need block brackets in this case
+ return make_block.apply(this, arguments);
+ } else {
+ return MAP(make_block_statements(statements, true),
+ function(line, i) {
+ // the first line is already indented
+ return i > 0 ? indent(line) : line;
+ }).join(newline);
+ }
+ },
+ "block": make_block,
+ "var": function(defs) {
+ return "var " + add_commas(MAP(defs, make_1vardef)) + ";";
+ },
+ "const": function(defs) {
+ return "const " + add_commas(MAP(defs, make_1vardef)) + ";";
+ },
+ "try": function(tr, ca, fi) {
+ var out = [ "try", make_block(tr) ];
+ if (ca) out.push("catch", "(" + ca[0] + ")", make_block(ca[1]));
+ if (fi) out.push("finally", make_block(fi));
+ return add_spaces(out);
+ },
+ "throw": function(expr) {
+ return add_spaces([ "throw", make(expr) ]) + ";";
+ },
+ "new": function(ctor, args) {
+ args = args.length > 0 ? "(" + add_commas(MAP(args, function(expr){
+ return parenthesize(expr, "seq");
+ })) + ")" : "";
+ 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(){
+ w.walk(expr);
+ });
+ } catch(ex) {
+ if (ex === has_call)
+ return true;
+ throw ex;
+ }
+ }) + args ]);
+ },
+ "switch": function(expr, body) {
+ return add_spaces([ "switch", "(" + make(expr) + ")", make_switch_block(body) ]);
+ },
+ "break": function(label) {
+ var out = "break";
+ if (label != null)
+ out += " " + make_name(label);
+ return out + ";";
+ },
+ "continue": function(label) {
+ var out = "continue";
+ if (label != null)
+ out += " " + make_name(label);
+ return out + ";";
+ },
+ "conditional": function(co, th, el) {
+ return add_spaces([ parenthesize(co, "assign", "seq", "conditional"), "?",
+ parenthesize(th, "seq"), ":",
+ parenthesize(el, "seq") ]);
+ },
+ "assign": function(op, lvalue, rvalue) {
+ if (op && op !== true) op += "=";
+ else op = "=";
+ return add_spaces([ make(lvalue), op, parenthesize(rvalue, "seq") ]);
+ },
+ "dot": function(expr) {
+ var out = make(expr), i = 1;
+ if (expr[0] == "num") {
+ if (!/[a-f.]/i.test(out))
+ out += ".";
+ } else if (expr[0] != "function" && needs_parens(expr))
+ out = "(" + out + ")";
+ while (i < arguments.length)
+ out += "." + make_name(arguments[i++]);
+ return out;
+ },
+ "call": function(func, args) {
+ var f = make(func);
+ if (f.charAt(0) != "(" && needs_parens(func))
+ f = "(" + f + ")";
+ return f + "(" + add_commas(MAP(args, function(expr){
+ return parenthesize(expr, "seq");
+ })) + ")";
+ },
+ "function": make_function,
+ "defun": make_function,
+ "if": function(co, th, el) {
+ var out = [ "if", "(" + make(co) + ")", el ? make_then(th) : make(th) ];
+ if (el) {
+ out.push("else", make(el));
+ }
+ return add_spaces(out);
+ },
+ "for": function(init, cond, step, block) {
+ var out = [ "for" ];
+ init = (init != null ? make(init) : "").replace(/;*\s*$/, ";" + space);
+ cond = (cond != null ? make(cond) : "").replace(/;*\s*$/, ";" + space);
+ step = (step != null ? make(step) : "").replace(/;*\s*$/, "");
+ var args = init + cond + step;
+ if (args == "; ; ") args = ";;";
+ out.push("(" + args + ")", make(block));
+ return add_spaces(out);
+ },
+ "for-in": function(vvar, key, hash, block) {
+ return add_spaces([ "for", "(" +
+ (vvar ? make(vvar).replace(/;+$/, "") : make(key)),
+ "in",
+ make(hash) + ")", make(block) ]);
+ },
+ "while": function(condition, block) {
+ return add_spaces([ "while", "(" + make(condition) + ")", make(block) ]);
+ },
+ "do": function(condition, block) {
+ return add_spaces([ "do", make(block), "while", "(" + make(condition) + ")" ]) + ";";
+ },
+ "return": function(expr) {
+ var out = [ "return" ];
+ if (expr != null) out.push(make(expr));
+ return add_spaces(out) + ";";
+ },
+ "binary": function(operator, lvalue, rvalue) {
+ var left = make(lvalue), right = make(rvalue);
+ // 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 (member(lvalue[0], [ "assign", "conditional", "seq" ]) ||
+ lvalue[0] == "binary" && PRECEDENCE[operator] > PRECEDENCE[lvalue[1]] ||
+ lvalue[0] == "function" && needs_parens(this)) {
+ left = "(" + left + ")";
+ }
+ if (member(rvalue[0], [ "assign", "conditional", "seq" ]) ||
+ rvalue[0] == "binary" && PRECEDENCE[operator] >= PRECEDENCE[rvalue[1]] &&
+ !(rvalue[1] == operator && member(operator, [ "&&", "||", "*" ]))) {
+ right = "(" + right + ")";
+ }
+ else if (!beautify && options.inline_script && (operator == "<" || operator == "<<")
+ && rvalue[0] == "regexp" && /^script/i.test(rvalue[1])) {
+ right = " " + right;
+ }
+ return add_spaces([ left, operator, right ]);
+ },
+ "unary-prefix": function(operator, expr) {
+ var val = make(expr);
+ if (!(expr[0] == "num" || (expr[0] == "unary-prefix" && !HOP(OPERATORS, operator + expr[1])) || !needs_parens(expr)))
+ val = "(" + val + ")";
+ return operator + (jsp.is_alphanumeric_char(operator.charAt(0)) ? " " : "") + val;
+ },
+ "unary-postfix": function(operator, expr) {
+ var val = make(expr);
+ if (!(expr[0] == "num" || (expr[0] == "unary-postfix" && !HOP(OPERATORS, operator + expr[1])) || !needs_parens(expr)))
+ val = "(" + val + ")";
+ return val + operator;
+ },
+ "sub": function(expr, subscript) {
+ var hash = make(expr);
+ if (needs_parens(expr))
+ hash = "(" + hash + ")";
+ return hash + "[" + make(subscript) + "]";
+ },
+ "object": function(props) {
+ var obj_needs_parens = needs_parens(this);
+ if (props.length == 0)
+ return obj_needs_parens ? "({})" : "{}";
+ var out = "{" + newline + with_indent(function(){
+ return MAP(props, function(p){
+ if (p.length == 3) {
+ // getter/setter. The name is in p[0], the arg.list in p[1][2], the
+ // body in p[1][3] and type ("get" / "set") in p[2].
+ return indent(make_function(p[0], p[1][2], p[1][3], p[2], true));
+ }
+ var key = p[0], val = parenthesize(p[1], "seq");
+ if (options.quote_keys) {
+ key = encode_string(key);
+ } else if ((typeof key == "number" || !beautify && +key + "" == key)
+ && parseFloat(key) >= 0) {
+ key = make_num(+key);
+ } else if (!is_identifier(key)) {
+ key = encode_string(key);
+ }
+ return indent(add_spaces(beautify && options.space_colon
+ ? [ key, ":", val ]
+ : [ key + ":", val ]));
+ }).join("," + newline);
+ }) + newline + indent("}");
+ return obj_needs_parens ? "(" + out + ")" : out;
+ },
+ "regexp": function(rx, mods) {
+ if (options.ascii_only) rx = to_ascii(rx);
+ return "/" + rx + "/" + mods;
+ },
+ "array": function(elements) {
+ if (elements.length == 0) return "[]";
+ return add_spaces([ "[", add_commas(MAP(elements, function(el, i){
+ if (!beautify && el[0] == "atom" && el[1] == "undefined") return i === elements.length - 1 ? "," : "";
+ return parenthesize(el, "seq");
+ })), "]" ]);
+ },
+ "stat": function(stmt) {
+ return stmt != null
+ ? make(stmt).replace(/;*\s*$/, ";")
+ : ";";
+ },
+ "seq": function() {
+ return add_commas(MAP(slice(arguments), make));
+ },
+ "label": function(name, block) {
+ return add_spaces([ make_name(name), ":", make(block) ]);
+ },
+ "with": function(expr, block) {
+ return add_spaces([ "with", "(" + make(expr) + ")", make(block) ]);
+ },
+ "atom": function(name) {
+ return make_name(name);
+ },
+ "directive": function(dir) {
+ return make_string(dir) + ";";
+ }
+ }, function(){ return make(ast) });
+
+ // 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.
+ function make_then(th) {
+ if (th == null) return ";";
+ if (th[0] == "do") {
+ // https://github.com/mishoo/UglifyJS/issues/#issue/57
+ // IE croaks with "syntax error" on code like this:
+ // if (foo) do ... while(cond); else ...
+ // we need block brackets around do/while
+ 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
+ return make([ "block", [ th ]]);
+ b = b[3];
+ }
+ else if (type == "while" || type == "do") b = b[2];
+ else if (type == "for" || type == "for-in") b = b[4];
+ else break;
+ }
+ return make(th);
+ };
+
+ function make_function(name, args, body, keyword, no_parens) {
+ var out = keyword || "function";
+ if (name) {
+ out += " " + make_name(name);
+ }
+ out += "(" + add_commas(MAP(args, make_name)) + ")";
+ out = add_spaces([ out, make_block(body) ]);
+ return (!no_parens && needs_parens(this)) ? "(" + out + ")" : out;
+ };
+
+ function must_has_semicolon(node) {
+ switch (node[0]) {
+ case "with":
+ case "while":
+ return empty(node[2]) || must_has_semicolon(node[2]);
+ case "for":
+ case "for-in":
+ return empty(node[4]) || must_has_semicolon(node[4]);
+ case "if":
+ if (empty(node[2]) && !node[3]) return true; // `if' with empty `then' and no `else'
+ if (node[3]) {
+ if (empty(node[3])) return true; // `else' present but empty
+ return must_has_semicolon(node[3]); // dive into the `else' branch
+ }
+ return must_has_semicolon(node[2]); // dive into the `then' branch
+ case "directive":
+ return true;
+ }
+ };
+
+ function make_block_statements(statements, noindent) {
+ for (var a = [], last = statements.length - 1, i = 0; i <= last; ++i) {
+ var stat = statements[i];
+ var code = make(stat);
+ if (code != ";") {
+ if (!beautify && i == last && !must_has_semicolon(stat)) {
+ code = code.replace(/;+\s*$/, "");
+ }
+ a.push(code);
+ }
+ }
+ return noindent ? a : MAP(a, indent);
+ };
+
+ function make_switch_block(body) {
+ var n = body.length;
+ if (n == 0) return "{}";
+ return "{" + newline + MAP(body, function(branch, i){
+ var has_body = branch[1].length > 0, code = with_indent(function(){
+ return indent(branch[0]
+ ? add_spaces([ "case", make(branch[0]) + ":" ])
+ : "default:");
+ }, 0.5) + (has_body ? newline + with_indent(function(){
+ return make_block_statements(branch[1]).join(newline);
+ }) : "");
+ if (!beautify && has_body && i < n - 1)
+ code += ";";
+ return code;
+ }).join(newline) + newline + indent("}");
+ };
+
+ function make_block(statements) {
+ if (!statements) return ";";
+ if (statements.length == 0) return "{}";
+ return "{" + newline + with_indent(function(){
+ return make_block_statements(statements).join(newline);
+ }) + newline + indent("}");
+ };
+
+ function make_1vardef(def) {
+ var name = def[0], val = def[1];
+ if (val != null)
+ name = add_spaces([ make_name(name), "=", parenthesize(val, "seq") ]);
+ return name;
+ };
+
+};
+
+function split_lines(code, max_line_length) {
+ var splits = [ 0 ];
+ jsp.parse(function(){
+ var next_token = jsp.tokenizer(code);
+ var last_split = 0;
+ var prev_token;
+ function current_length(tok) {
+ return tok.pos - last_split;
+ };
+ function split_here(tok) {
+ last_split = tok.pos;
+ splits.push(last_split);
+ };
+ function custom(){
+ var tok = next_token.apply(this, arguments);
+ out: {
+ if (prev_token) {
+ if (prev_token.type == "keyword") break out;
+ }
+ if (current_length(tok) > max_line_length) {
+ switch (tok.type) {
+ case "keyword":
+ case "atom":
+ case "name":
+ case "punc":
+ split_here(tok);
+ break out;
+ }
+ }
+ }
+ prev_token = tok;
+ return tok;
+ };
+ custom.context = function() {
+ return next_token.context.apply(this, arguments);
+ };
+ return custom;
+ }());
+ return splits.map(function(pos, i){
+ return code.substring(pos, splits[i + 1] || code.length);
+ }).join("\n");
+};
+
+/* -----[ Utilities ]----- */
+
+function repeat_string(str, i) {
+ if (i <= 0) return "";
+ if (i == 1) return str;
+ var d = repeat_string(str, i >> 1);
+ d += d;
+ if (i & 1) d += str;
+ return d;
+};
+
+function defaults(args, defs) {
+ var ret = {};
+ if (args === true)
+ args = {};
+ for (var i in defs) if (HOP(defs, i)) {
+ ret[i] = (args && HOP(args, i)) ? args[i] : defs[i];
+ }
+ return ret;
+};
+
+function is_identifier(name) {
+ return /^[a-z_$][a-z0-9_$]*$/i.test(name)
+ && name != "this"
+ && !HOP(jsp.KEYWORDS_ATOM, name)
+ && !HOP(jsp.RESERVED_WORDS, name)
+ && !HOP(jsp.KEYWORDS, name);
+};
+
+function HOP(obj, prop) {
+ return Object.prototype.hasOwnProperty.call(obj, prop);
+};
+
+// some utilities
+
+var MAP;
+
+(function(){
+ MAP = function(a, f, o) {
+ var ret = [], top = [], i;
+ function doit() {
+ var val = f.call(o, a[i], i);
+ if (val instanceof AtTop) {
+ val = val.v;
+ if (val instanceof Splice) {
+ top.push.apply(top, val.v);
+ } else {
+ top.push(val);
+ }
+ }
+ else if (val != skip) {
+ if (val instanceof Splice) {
+ ret.push.apply(ret, val.v);
+ } else {
+ ret.push(val);
+ }
+ }
+ };
+ if (a instanceof Array) for (i = 0; i < a.length; ++i) doit();
+ else for (i in a) if (HOP(a, i)) doit();
+ return top.concat(ret);
+ };
+ MAP.at_top = function(val) { return new AtTop(val) };
+ MAP.splice = function(val) { return new Splice(val) };
+ var skip = MAP.skip = {};
+ function AtTop(val) { this.v = val };
+ function Splice(val) { this.v = val };
+})();
+
+/* -----[ Exports ]----- */
+
+exports.ast_walker = ast_walker;
+exports.ast_mangle = ast_mangle;
+exports.ast_squeeze = ast_squeeze;
+exports.ast_lift_variables = ast_lift_variables;
+exports.gen_code = gen_code;
+exports.ast_add_scope = ast_add_scope;
+exports.set_logger = function(logger) { warn = logger };
+exports.make_string = make_string;
+exports.split_lines = split_lines;
+exports.MAP = MAP;
+
+// keep this last!
+exports.ast_squeeze_more = require("./squeeze-more").ast_squeeze_more;
+
+// Local variables:
+// js-indent-level: 4
+// End:
+});
+define('uglifyjs/index', ["require", "exports", "module", "./parse-js", "./process", "./consolidator"], function(require, exports, module) {
+//convienence function(src, [options]);
+function uglify(orig_code, options){
+ options || (options = {});
+ var jsp = uglify.parser;
+ var pro = uglify.uglify;
+
+ var ast = jsp.parse(orig_code, options.strict_semicolons); // parse code and get the initial AST
+ ast = pro.ast_mangle(ast, options.mangle_options); // get a new AST with mangled names
+ ast = pro.ast_squeeze(ast, options.squeeze_options); // get an AST with compression optimizations
+ var final_code = pro.gen_code(ast, options.gen_options); // compressed code here
+ return final_code;
+};
+
+uglify.parser = require("./parse-js");
+uglify.uglify = require("./process");
+uglify.consolidator = require("./consolidator");
+
+module.exports = uglify
+});/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+define('source-map/array-set', function (require, exports, module) {
+
+ var util = require('./util');
+
+ /**
+ * A data structure which is a combination of an array and a set. Adding a new
+ * member is O(1), testing for membership is O(1), and finding the index of an
+ * element is O(1). Removing elements from the set is not supported. Only
+ * strings are supported for membership.
+ */
+ function ArraySet() {
+ this._array = [];
+ this._set = {};
+ }
+
+ /**
+ * Static method for creating ArraySet instances from an existing array.
+ */
+ ArraySet.fromArray = function ArraySet_fromArray(aArray) {
+ var set = new ArraySet();
+ for (var i = 0, len = aArray.length; i < len; i++) {
+ set.add(aArray[i]);
+ }
+ return set;
+ };
+
+ /**
+ * Add the given string to this set.
+ *
+ * @param String aStr
+ */
+ ArraySet.prototype.add = function ArraySet_add(aStr) {
+ if (this.has(aStr)) {
+ // Already a member; nothing to do.
+ return;
+ }
+ var idx = this._array.length;
+ this._array.push(aStr);
+ this._set[util.toSetString(aStr)] = idx;
+ };
+
+ /**
+ * Is the given string a member of this set?
+ *
+ * @param String aStr
+ */
+ ArraySet.prototype.has = function ArraySet_has(aStr) {
+ return Object.prototype.hasOwnProperty.call(this._set,
+ util.toSetString(aStr));
+ };
+
+ /**
+ * What is the index of the given string in the array?
+ *
+ * @param String aStr
+ */
+ ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
+ if (this.has(aStr)) {
+ return this._set[util.toSetString(aStr)];
+ }
+ throw new Error('"' + aStr + '" is not in the set.');
+ };
+
+ /**
+ * What is the element at the given index?
+ *
+ * @param Number aIdx
+ */
+ ArraySet.prototype.at = function ArraySet_at(aIdx) {
+ if (aIdx >= 0 && aIdx < this._array.length) {
+ return this._array[aIdx];
+ }
+ throw new Error('No element indexed by ' + aIdx);
+ };
+
+ /**
+ * Returns the array representation of this set (which has the proper indices
+ * indicated by indexOf). Note that this is a copy of the internal array used
+ * for storing the members so that no one can mess with internal state.
+ */
+ ArraySet.prototype.toArray = function ArraySet_toArray() {
+ return this._array.slice();
+ };
+
+ exports.ArraySet = ArraySet;
+
+});
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ *
+ * Based on the Base 64 VLQ implementation in Closure Compiler:
+ * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java
+ *
+ * Copyright 2011 The Closure Compiler Authors. All rights reserved.
+ * 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
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "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
+ * OWNER OR CONTRIBUTORS 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.
+ */
+
+define('source-map/base64-vlq', function (require, exports, module) {
+
+ var base64 = require('./base64');
+
+ // A single base 64 digit can contain 6 bits of data. For the base 64 variable
+ // length quantities we use in the source map spec, the first bit is the sign,
+ // the next four bits are the actual value, and the 6th bit is the
+ // continuation bit. The continuation bit tells us whether there are more
+ // digits in this value following this digit.
+ //
+ // Continuation
+ // | Sign
+ // | |
+ // V V
+ // 101011
+
+ var VLQ_BASE_SHIFT = 5;
+
+ // binary: 100000
+ var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
+
+ // binary: 011111
+ var VLQ_BASE_MASK = VLQ_BASE - 1;
+
+ // binary: 100000
+ var VLQ_CONTINUATION_BIT = VLQ_BASE;
+
+ /**
+ * Converts from a two-complement value to a value where the sign bit is
+ * is placed in the least significant bit. For example, as decimals:
+ * 1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
+ * 2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
+ */
+ function toVLQSigned(aValue) {
+ return aValue < 0
+ ? ((-aValue) << 1) + 1
+ : (aValue << 1) + 0;
+ }
+
+ /**
+ * Converts to a two-complement value from a value where the sign bit is
+ * is placed in the least significant bit. For example, as decimals:
+ * 2 (10 binary) becomes 1, 3 (11 binary) becomes -1
+ * 4 (100 binary) becomes 2, 5 (101 binary) becomes -2
+ */
+ function fromVLQSigned(aValue) {
+ var isNegative = (aValue & 1) === 1;
+ var shifted = aValue >> 1;
+ return isNegative
+ ? -shifted
+ : shifted;
+ }
+
+ /**
+ * Returns the base 64 VLQ encoded value.
+ */
+ exports.encode = function base64VLQ_encode(aValue) {
+ var encoded = "";
+ var digit;
+
+ var vlq = toVLQSigned(aValue);
+
+ do {
+ digit = vlq & VLQ_BASE_MASK;
+ vlq >>>= VLQ_BASE_SHIFT;
+ if (vlq > 0) {
+ // There are still more digits in this value, so we must make sure the
+ // continuation bit is marked.
+ digit |= VLQ_CONTINUATION_BIT;
+ }
+ encoded += base64.encode(digit);
+ } while (vlq > 0);
+
+ return encoded;
+ };
+
+ /**
+ * Decodes the next base 64 VLQ value from the given string and returns the
+ * value and the rest of the string.
+ */
+ exports.decode = function base64VLQ_decode(aStr) {
+ var i = 0;
+ var strLen = aStr.length;
+ var result = 0;
+ var shift = 0;
+ var continuation, digit;
+
+ do {
+ if (i >= strLen) {
+ throw new Error("Expected more digits in base 64 VLQ value.");
+ }
+ digit = base64.decode(aStr.charAt(i++));
+ continuation = !!(digit & VLQ_CONTINUATION_BIT);
+ digit &= VLQ_BASE_MASK;
+ result = result + (digit << shift);
+ shift += VLQ_BASE_SHIFT;
+ } while (continuation);
+
+ return {
+ value: fromVLQSigned(result),
+ rest: aStr.slice(i)
+ };
+ };
+
+});
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+define('source-map/base64', function (require, exports, module) {
+
+ var charToIntMap = {};
+ var intToCharMap = {};
+
+ 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+ .split('')
+ .forEach(function (ch, index) {
+ charToIntMap[ch] = index;
+ intToCharMap[index] = ch;
+ });
+
+ /**
+ * Encode an integer in the range of 0 to 63 to a single base 64 digit.
+ */
+ exports.encode = function base64_encode(aNumber) {
+ if (aNumber in intToCharMap) {
+ return intToCharMap[aNumber];
+ }
+ throw new TypeError("Must be between 0 and 63: " + aNumber);
+ };
+
+ /**
+ * Decode a single base 64 digit to an integer.
+ */
+ exports.decode = function base64_decode(aChar) {
+ if (aChar in charToIntMap) {
+ return charToIntMap[aChar];
+ }
+ throw new TypeError("Not a valid base 64 digit: " + aChar);
+ };
+
+});
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+define('source-map/binary-search', function (require, exports, module) {
+
+ /**
+ * Recursive implementation of binary search.
+ *
+ * @param aLow Indices here and lower do not contain the needle.
+ * @param aHigh Indices here and higher do not contain the needle.
+ * @param aNeedle The element being searched for.
+ * @param aHaystack The non-empty array being searched.
+ * @param aCompare Function which takes two elements and returns -1, 0, or 1.
+ */
+ function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare) {
+ // This function terminates when one of the following is true:
+ //
+ // 1. We find the exact element we are looking for.
+ //
+ // 2. We did not find the exact element, but we can return the next
+ // closest element that is less than that element.
+ //
+ // 3. We did not find the exact element, and there is no next-closest
+ // element which is less than the one we are searching for, so we
+ // return null.
+ var mid = Math.floor((aHigh - aLow) / 2) + aLow;
+ var cmp = aCompare(aNeedle, aHaystack[mid]);
+ if (cmp === 0) {
+ // Found the element we are looking for.
+ return aHaystack[mid];
+ }
+ else if (cmp > 0) {
+ // aHaystack[mid] is greater than our needle.
+ if (aHigh - mid > 1) {
+ // The element is in the upper half.
+ return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare);
+ }
+ // We did not find an exact match, return the next closest one
+ // (termination case 2).
+ return aHaystack[mid];
+ }
+ else {
+ // aHaystack[mid] is less than our needle.
+ if (mid - aLow > 1) {
+ // The element is in the lower half.
+ return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare);
+ }
+ // The exact needle element was not found in this haystack. Determine if
+ // we are in termination case (2) or (3) and return the appropriate thing.
+ return aLow < 0
+ ? null
+ : aHaystack[aLow];
+ }
+ }
+
+ /**
+ * This is an implementation of binary search which will always try and return
+ * the next lowest value checked if there is no exact hit. This is because
+ * mappings between original and generated line/col pairs are single points,
+ * and there is an implicit region between each of them, so a miss just means
+ * that you aren't on the very start of a region.
+ *
+ * @param aNeedle The element you are looking for.
+ * @param aHaystack The array that is being searched.
+ * @param aCompare A function which takes the needle and an element in the
+ * array and returns -1, 0, or 1 depending on whether the needle is less
+ * than, equal to, or greater than the element, respectively.
+ */
+ exports.search = function search(aNeedle, aHaystack, aCompare) {
+ return aHaystack.length > 0
+ ? recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack, aCompare)
+ : null;
+ };
+
+});
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+define('source-map/source-map-consumer', function (require, exports, module) {
+
+ var util = require('./util');
+ var binarySearch = require('./binary-search');
+ var ArraySet = require('./array-set').ArraySet;
+ var base64VLQ = require('./base64-vlq');
+
+ /**
+ * A SourceMapConsumer instance represents a parsed source map which we can
+ * query for information about the original file positions by giving it a file
+ * position in the generated source.
+ *
+ * The only parameter is the raw source map (either as a JSON string, or
+ * already parsed to an object). According to the spec, source maps have the
+ * following attributes:
+ *
+ * - version: Which version of the source map spec this map is following.
+ * - sources: An array of URLs to the original source files.
+ * - names: An array of identifiers which can be referrenced by individual mappings.
+ * - sourceRoot: Optional. The URL root from which all sources are relative.
+ * - sourcesContent: Optional. An array of contents of the original source files.
+ * - mappings: A string of base64 VLQs which contain the actual mappings.
+ * - file: The generated file this source map is associated with.
+ *
+ * Here is an example source map, taken from the source map spec[0]:
+ *
+ * {
+ * version : 3,
+ * file: "out.js",
+ * sourceRoot : "",
+ * sources: ["foo.js", "bar.js"],
+ * names: ["src", "maps", "are", "fun"],
+ * mappings: "AA,AB;;ABCDE;"
+ * }
+ *
+ * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
+ */
+ function SourceMapConsumer(aSourceMap) {
+ var sourceMap = aSourceMap;
+ if (typeof aSourceMap === 'string') {
+ sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ''));
+ }
+
+ var version = util.getArg(sourceMap, 'version');
+ var sources = util.getArg(sourceMap, 'sources');
+ var names = util.getArg(sourceMap, 'names');
+ var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);
+ var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);
+ var mappings = util.getArg(sourceMap, 'mappings');
+ var file = util.getArg(sourceMap, 'file');
+
+ if (version !== this._version) {
+ throw new Error('Unsupported version: ' + version);
+ }
+
+ this._names = ArraySet.fromArray(names);
+ this._sources = ArraySet.fromArray(sources);
+ this.sourceRoot = sourceRoot;
+ this.sourcesContent = sourcesContent;
+ this.file = file;
+
+ // `this._generatedMappings` and `this._originalMappings` hold the parsed
+ // mapping coordinates from the source map's "mappings" attribute. Each
+ // object in the array is of the form
+ //
+ // {
+ // generatedLine: The line number in the generated code,
+ // generatedColumn: The column number in the generated code,
+ // source: The path to the original source file that generated this
+ // chunk of code,
+ // originalLine: The line number in the original source that
+ // corresponds to this chunk of generated code,
+ // originalColumn: The column number in the original source that
+ // corresponds to this chunk of generated code,
+ // name: The name of the original symbol which generated this chunk of
+ // code.
+ // }
+ //
+ // All properties except for `generatedLine` and `generatedColumn` can be
+ // `null`.
+ //
+ // `this._generatedMappings` is ordered by the generated positions.
+ //
+ // `this._originalMappings` is ordered by the original positions.
+ this._generatedMappings = [];
+ this._originalMappings = [];
+ this._parseMappings(mappings, sourceRoot);
+ }
+
+ /**
+ * The version of the source mapping spec that we are consuming.
+ */
+ SourceMapConsumer.prototype._version = 3;
+
+ /**
+ * The list of original sources.
+ */
+ Object.defineProperty(SourceMapConsumer.prototype, 'sources', {
+ get: function () {
+ return this._sources.toArray().map(function (s) {
+ return this.sourceRoot ? util.join(this.sourceRoot, s) : s;
+ }, this);
+ }
+ });
+
+ /**
+ * Parse the mappings in a string in to a data structure which we can easily
+ * query (an ordered list in this._generatedMappings).
+ */
+ SourceMapConsumer.prototype._parseMappings =
+ function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
+ var generatedLine = 1;
+ var previousGeneratedColumn = 0;
+ var previousOriginalLine = 0;
+ var previousOriginalColumn = 0;
+ var previousSource = 0;
+ var previousName = 0;
+ var mappingSeparator = /^[,;]/;
+ var str = aStr;
+ var mapping;
+ var temp;
+
+ while (str.length > 0) {
+ if (str.charAt(0) === ';') {
+ generatedLine++;
+ str = str.slice(1);
+ previousGeneratedColumn = 0;
+ }
+ else if (str.charAt(0) === ',') {
+ str = str.slice(1);
+ }
+ else {
+ mapping = {};
+ mapping.generatedLine = generatedLine;
+
+ // Generated column.
+ temp = base64VLQ.decode(str);
+ mapping.generatedColumn = previousGeneratedColumn + temp.value;
+ previousGeneratedColumn = mapping.generatedColumn;
+ str = temp.rest;
+
+ if (str.length > 0 && !mappingSeparator.test(str.charAt(0))) {
+ // Original source.
+ temp = base64VLQ.decode(str);
+ mapping.source = this._sources.at(previousSource + temp.value);
+ previousSource += temp.value;
+ str = temp.rest;
+ if (str.length === 0 || mappingSeparator.test(str.charAt(0))) {
+ throw new Error('Found a source, but no line and column');
+ }
+
+ // Original line.
+ temp = base64VLQ.decode(str);
+ mapping.originalLine = previousOriginalLine + temp.value;
+ previousOriginalLine = mapping.originalLine;
+ // Lines are stored 0-based
+ mapping.originalLine += 1;
+ str = temp.rest;
+ if (str.length === 0 || mappingSeparator.test(str.charAt(0))) {
+ throw new Error('Found a source and line, but no column');
+ }
+
+ // Original column.
+ temp = base64VLQ.decode(str);
+ mapping.originalColumn = previousOriginalColumn + temp.value;
+ previousOriginalColumn = mapping.originalColumn;
+ str = temp.rest;
+
+ if (str.length > 0 && !mappingSeparator.test(str.charAt(0))) {
+ // Original name.
+ temp = base64VLQ.decode(str);
+ mapping.name = this._names.at(previousName + temp.value);
+ previousName += temp.value;
+ str = temp.rest;
+ }
+ }
+
+ this._generatedMappings.push(mapping);
+ if (typeof mapping.originalLine === 'number') {
+ this._originalMappings.push(mapping);
+ }
+ }
+ }
+
+ this._originalMappings.sort(this._compareOriginalPositions);
+ };
+
+ /**
+ * Comparator between two mappings where the original positions are compared.
+ */
+ SourceMapConsumer.prototype._compareOriginalPositions =
+ function SourceMapConsumer_compareOriginalPositions(mappingA, mappingB) {
+ if (mappingA.source > mappingB.source) {
+ return 1;
+ }
+ else if (mappingA.source < mappingB.source) {
+ return -1;
+ }
+ else {
+ var cmp = mappingA.originalLine - mappingB.originalLine;
+ return cmp === 0
+ ? mappingA.originalColumn - mappingB.originalColumn
+ : cmp;
+ }
+ };
+
+ /**
+ * Comparator between two mappings where the generated positions are compared.
+ */
+ SourceMapConsumer.prototype._compareGeneratedPositions =
+ function SourceMapConsumer_compareGeneratedPositions(mappingA, mappingB) {
+ var cmp = mappingA.generatedLine - mappingB.generatedLine;
+ return cmp === 0
+ ? mappingA.generatedColumn - mappingB.generatedColumn
+ : cmp;
+ };
+
+ /**
+ * Find the mapping that best matches the hypothetical "needle" mapping that
+ * we are searching for in the given "haystack" of mappings.
+ */
+ SourceMapConsumer.prototype._findMapping =
+ function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,
+ aColumnName, aComparator) {
+ // To return the position we are searching for, we must first find the
+ // mapping for the given position and then return the opposite position it
+ // points to. Because the mappings are sorted, we can use binary search to
+ // find the best mapping.
+
+ if (aNeedle[aLineName] <= 0) {
+ throw new TypeError('Line must be greater than or equal to 1, got '
+ + aNeedle[aLineName]);
+ }
+ if (aNeedle[aColumnName] < 0) {
+ throw new TypeError('Column must be greater than or equal to 0, got '
+ + aNeedle[aColumnName]);
+ }
+
+ return binarySearch.search(aNeedle, aMappings, aComparator);
+ };
+
+ /**
+ * Returns the original source, line, and column information for the generated
+ * source's line and column positions provided. The only argument is an object
+ * with the following properties:
+ *
+ * - line: The line number in the generated source.
+ * - column: The column number in the generated source.
+ *
+ * and an object is returned with the following properties:
+ *
+ * - source: The original source file, or null.
+ * - line: The line number in the original source, or null.
+ * - column: The column number in the original source, or null.
+ * - name: The original identifier, or null.
+ */
+ SourceMapConsumer.prototype.originalPositionFor =
+ function SourceMapConsumer_originalPositionFor(aArgs) {
+ var needle = {
+ generatedLine: util.getArg(aArgs, 'line'),
+ generatedColumn: util.getArg(aArgs, 'column')
+ };
+
+ var mapping = this._findMapping(needle,
+ this._generatedMappings,
+ "generatedLine",
+ "generatedColumn",
+ this._compareGeneratedPositions);
+
+ if (mapping) {
+ var source = util.getArg(mapping, 'source', null);
+ if (source && this.sourceRoot) {
+ source = util.join(this.sourceRoot, source);
+ }
+ return {
+ source: source,
+ line: util.getArg(mapping, 'originalLine', null),
+ column: util.getArg(mapping, 'originalColumn', null),
+ name: util.getArg(mapping, 'name', null)
+ };
+ }
+
+ return {
+ source: null,
+ line: null,
+ column: null,
+ name: null
+ };
+ };
+
+ /**
+ * Returns the original source content. The only argument is the url of the
+ * original source file. Returns null if no original source content is
+ * availible.
+ */
+ SourceMapConsumer.prototype.sourceContentFor =
+ function SourceMapConsumer_sourceContentFor(aSource) {
+ if (!this.sourcesContent) {
+ return null;
+ }
+
+ if (this.sourceRoot) {
+ aSource = util.relative(this.sourceRoot, aSource);
+ }
+
+ if (this._sources.has(aSource)) {
+ return this.sourcesContent[this._sources.indexOf(aSource)];
+ }
+
+ var url;
+ if (this.sourceRoot
+ && (url = util.urlParse(this.sourceRoot))) {
+ // XXX: file:// URIs and absolute paths lead to unexpected behavior for
+ // many users. We can help them out when they expect file:// URIs to
+ // behave like it would if they were running a local HTTP server. See
+ // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.
+ var fileUriAbsPath = aSource.replace(/^file:\/\//, "");
+ if (url.scheme == "file"
+ && this._sources.has(fileUriAbsPath)) {
+ return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]
+ }
+
+ if ((!url.path || url.path == "/")
+ && this._sources.has("/" + aSource)) {
+ return this.sourcesContent[this._sources.indexOf("/" + aSource)];
+ }
+ }
+
+ throw new Error('"' + aSource + '" is not in the SourceMap.');
+ };
+
+ /**
+ * Returns the generated line and column information for the original source,
+ * line, and column positions provided. The only argument is an object with
+ * the following properties:
+ *
+ * - source: The filename of the original source.
+ * - line: The line number in the original source.
+ * - column: The column number in the original source.
+ *
+ * and an object is returned with the following properties:
+ *
+ * - line: The line number in the generated source, or null.
+ * - column: The column number in the generated source, or null.
+ */
+ SourceMapConsumer.prototype.generatedPositionFor =
+ function SourceMapConsumer_generatedPositionFor(aArgs) {
+ var needle = {
+ source: util.getArg(aArgs, 'source'),
+ originalLine: util.getArg(aArgs, 'line'),
+ originalColumn: util.getArg(aArgs, 'column')
+ };
+
+ if (this.sourceRoot) {
+ needle.source = util.relative(this.sourceRoot, needle.source);
+ }
+
+ var mapping = this._findMapping(needle,
+ this._originalMappings,
+ "originalLine",
+ "originalColumn",
+ this._compareOriginalPositions);
+
+ if (mapping) {
+ return {
+ line: util.getArg(mapping, 'generatedLine', null),
+ column: util.getArg(mapping, 'generatedColumn', null)
+ };
+ }
+
+ return {
+ line: null,
+ column: null
+ };
+ };
+
+ SourceMapConsumer.GENERATED_ORDER = 1;
+ SourceMapConsumer.ORIGINAL_ORDER = 2;
+
+ /**
+ * Iterate over each mapping between an original source/line/column and a
+ * generated line/column in this source map.
+ *
+ * @param Function aCallback
+ * The function that is called with each mapping.
+ * @param Object aContext
+ * Optional. If specified, this object will be the value of `this` every
+ * time that `aCallback` is called.
+ * @param aOrder
+ * Either `SourceMapConsumer.GENERATED_ORDER` or
+ * `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
+ * iterate over the mappings sorted by the generated file's line/column
+ * order or the original's source/line/column order, respectively. Defaults to
+ * `SourceMapConsumer.GENERATED_ORDER`.
+ */
+ SourceMapConsumer.prototype.eachMapping =
+ function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
+ var context = aContext || null;
+ var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
+
+ var mappings;
+ switch (order) {
+ case SourceMapConsumer.GENERATED_ORDER:
+ mappings = this._generatedMappings;
+ break;
+ case SourceMapConsumer.ORIGINAL_ORDER:
+ mappings = this._originalMappings;
+ break;
+ default:
+ throw new Error("Unknown order of iteration.");
+ }
+
+ var sourceRoot = this.sourceRoot;
+ mappings.map(function (mapping) {
+ var source = mapping.source;
+ if (source && sourceRoot) {
+ source = util.join(sourceRoot, source);
+ }
+ return {
+ source: source,
+ generatedLine: mapping.generatedLine,
+ generatedColumn: mapping.generatedColumn,
+ originalLine: mapping.originalLine,
+ originalColumn: mapping.originalColumn,
+ name: mapping.name
+ };
+ }).forEach(aCallback, context);
+ };
+
+ exports.SourceMapConsumer = SourceMapConsumer;
+
+});
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+define('source-map/source-map-generator', function (require, exports, module) {
+
+ var base64VLQ = require('./base64-vlq');
+ var util = require('./util');
+ var ArraySet = require('./array-set').ArraySet;
+
+ /**
+ * An instance of the SourceMapGenerator represents a source map which is
+ * being built incrementally. To create a new one, you must pass an object
+ * with the following properties:
+ *
+ * - file: The filename of the generated source.
+ * - sourceRoot: An optional root for all URLs in this source map.
+ */
+ function SourceMapGenerator(aArgs) {
+ this._file = util.getArg(aArgs, 'file');
+ this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);
+ this._sources = new ArraySet();
+ this._names = new ArraySet();
+ this._mappings = [];
+ this._sourcesContents = null;
+ }
+
+ SourceMapGenerator.prototype._version = 3;
+
+ /**
+ * Creates a new SourceMapGenerator based on a SourceMapConsumer
+ *
+ * @param aSourceMapConsumer The SourceMap.
+ */
+ SourceMapGenerator.fromSourceMap =
+ function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {
+ var sourceRoot = aSourceMapConsumer.sourceRoot;
+ var generator = new SourceMapGenerator({
+ file: aSourceMapConsumer.file,
+ sourceRoot: sourceRoot
+ });
+ aSourceMapConsumer.eachMapping(function (mapping) {
+ var newMapping = {
+ generated: {
+ line: mapping.generatedLine,
+ column: mapping.generatedColumn
+ }
+ };
+
+ if (mapping.source) {
+ newMapping.source = mapping.source;
+ if (sourceRoot) {
+ newMapping.source = util.relative(sourceRoot, newMapping.source);
+ }
+
+ newMapping.original = {
+ line: mapping.originalLine,
+ column: mapping.originalColumn
+ };
+
+ if (mapping.name) {
+ newMapping.name = mapping.name;
+ }
+ }
+
+ generator.addMapping(newMapping);
+ });
+ aSourceMapConsumer.sources.forEach(function (sourceFile) {
+ var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+ if (content) {
+ generator.setSourceContent(sourceFile, content);
+ }
+ });
+ return generator;
+ };
+
+ /**
+ * Add a single mapping from original source line and column to the generated
+ * source's line and column for this source map being created. The mapping
+ * object should have the following properties:
+ *
+ * - generated: An object with the generated line and column positions.
+ * - original: An object with the original line and column positions.
+ * - source: The original source file (relative to the sourceRoot).
+ * - name: An optional original token name for this mapping.
+ */
+ SourceMapGenerator.prototype.addMapping =
+ function SourceMapGenerator_addMapping(aArgs) {
+ var generated = util.getArg(aArgs, 'generated');
+ var original = util.getArg(aArgs, 'original', null);
+ var source = util.getArg(aArgs, 'source', null);
+ var name = util.getArg(aArgs, 'name', null);
+
+ this._validateMapping(generated, original, source, name);
+
+ if (source && !this._sources.has(source)) {
+ this._sources.add(source);
+ }
+
+ if (name && !this._names.has(name)) {
+ this._names.add(name);
+ }
+
+ this._mappings.push({
+ generated: generated,
+ original: original,
+ source: source,
+ name: name
+ });
+ };
+
+ /**
+ * Set the source content for a source file.
+ */
+ SourceMapGenerator.prototype.setSourceContent =
+ function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
+ var source = aSourceFile;
+ if (this._sourceRoot) {
+ source = util.relative(this._sourceRoot, source);
+ }
+
+ if (aSourceContent !== null) {
+ // Add the source content to the _sourcesContents map.
+ // Create a new _sourcesContents map if the property is null.
+ if (!this._sourcesContents) {
+ this._sourcesContents = {};
+ }
+ this._sourcesContents[util.toSetString(source)] = aSourceContent;
+ } else {
+ // Remove the source file from the _sourcesContents map.
+ // If the _sourcesContents map is empty, set the property to null.
+ delete this._sourcesContents[util.toSetString(source)];
+ if (Object.keys(this._sourcesContents).length === 0) {
+ this._sourcesContents = null;
+ }
+ }
+ };
+
+ /**
+ * Applies the mappings of a sub-source-map for a specific source file to the
+ * source map being generated. Each mapping to the supplied source file is
+ * rewritten using the supplied source map. Note: The resolution for the
+ * resulting mappings is the minimium of this map and the supplied map.
+ *
+ * @param aSourceMapConsumer The source map to be applied.
+ * @param aSourceFile Optional. The filename of the source file.
+ * If omitted, SourceMapConsumer's file property will be used.
+ */
+ SourceMapGenerator.prototype.applySourceMap =
+ function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile) {
+ // If aSourceFile is omitted, we will use the file property of the SourceMap
+ if (!aSourceFile) {
+ aSourceFile = aSourceMapConsumer.file;
+ }
+ var sourceRoot = this._sourceRoot;
+ // Make "aSourceFile" relative if an absolute Url is passed.
+ if (sourceRoot) {
+ aSourceFile = util.relative(sourceRoot, aSourceFile);
+ }
+ // Applying the SourceMap can add and remove items from the sources and
+ // the names array.
+ var newSources = new ArraySet();
+ var newNames = new ArraySet();
+
+ // Find mappings for the "aSourceFile"
+ this._mappings.forEach(function (mapping) {
+ if (mapping.source === aSourceFile && mapping.original) {
+ // Check if it can be mapped by the source map, then update the mapping.
+ var original = aSourceMapConsumer.originalPositionFor({
+ line: mapping.original.line,
+ column: mapping.original.column
+ });
+ if (original.source !== null) {
+ // Copy mapping
+ if (sourceRoot) {
+ mapping.source = util.relative(sourceRoot, original.source);
+ } else {
+ mapping.source = original.source;
+ }
+ mapping.original.line = original.line;
+ mapping.original.column = original.column;
+ if (original.name !== null && mapping.name !== null) {
+ // Only use the identifier name if it's an identifier
+ // in both SourceMaps
+ mapping.name = original.name;
+ }
+ }
+ }
+
+ var source = mapping.source;
+ if (source && !newSources.has(source)) {
+ newSources.add(source);
+ }
+
+ var name = mapping.name;
+ if (name && !newNames.has(name)) {
+ newNames.add(name);
+ }
+
+ }, this);
+ this._sources = newSources;
+ this._names = newNames;
+
+ // Copy sourcesContents of applied map.
+ aSourceMapConsumer.sources.forEach(function (sourceFile) {
+ var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+ if (content) {
+ if (sourceRoot) {
+ sourceFile = util.relative(sourceRoot, sourceFile);
+ }
+ this.setSourceContent(sourceFile, content);
+ }
+ }, this);
+ };
+
+ /**
+ * A mapping can have one of the three levels of data:
+ *
+ * 1. Just the generated position.
+ * 2. The Generated position, original position, and original source.
+ * 3. Generated and original position, original source, as well as a name
+ * token.
+ *
+ * To maintain consistency, we validate that any new mapping being added falls
+ * in to one of these categories.
+ */
+ SourceMapGenerator.prototype._validateMapping =
+ function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,
+ aName) {
+ if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
+ && aGenerated.line > 0 && aGenerated.column >= 0
+ && !aOriginal && !aSource && !aName) {
+ // Case 1.
+ return;
+ }
+ else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
+ && aOriginal && 'line' in aOriginal && 'column' in aOriginal
+ && aGenerated.line > 0 && aGenerated.column >= 0
+ && aOriginal.line > 0 && aOriginal.column >= 0
+ && aSource) {
+ // Cases 2 and 3.
+ return;
+ }
+ else {
+ throw new Error('Invalid mapping.');
+ }
+ };
+
+ function cmpLocation(loc1, loc2) {
+ var cmp = (loc1 && loc1.line) - (loc2 && loc2.line);
+ return cmp ? cmp : (loc1 && loc1.column) - (loc2 && loc2.column);
+ }
+
+ function strcmp(str1, str2) {
+ str1 = str1 || '';
+ str2 = str2 || '';
+ return (str1 > str2) - (str1 < str2);
+ }
+
+ function cmpMapping(mappingA, mappingB) {
+ return cmpLocation(mappingA.generated, mappingB.generated) ||
+ cmpLocation(mappingA.original, mappingB.original) ||
+ strcmp(mappingA.source, mappingB.source) ||
+ strcmp(mappingA.name, mappingB.name);
+ }
+
+ /**
+ * Serialize the accumulated mappings in to the stream of base 64 VLQs
+ * specified by the source map format.
+ */
+ SourceMapGenerator.prototype._serializeMappings =
+ function SourceMapGenerator_serializeMappings() {
+ var previousGeneratedColumn = 0;
+ var previousGeneratedLine = 1;
+ var previousOriginalColumn = 0;
+ var previousOriginalLine = 0;
+ var previousName = 0;
+ var previousSource = 0;
+ var result = '';
+ var mapping;
+
+ // The mappings must be guaranteed to be in sorted order before we start
+ // serializing them or else the generated line numbers (which are defined
+ // via the ';' separators) will be all messed up. Note: it might be more
+ // performant to maintain the sorting as we insert them, rather than as we
+ // serialize them, but the big O is the same either way.
+ this._mappings.sort(cmpMapping);
+
+ for (var i = 0, len = this._mappings.length; i < len; i++) {
+ mapping = this._mappings[i];
+
+ if (mapping.generated.line !== previousGeneratedLine) {
+ previousGeneratedColumn = 0;
+ while (mapping.generated.line !== previousGeneratedLine) {
+ result += ';';
+ previousGeneratedLine++;
+ }
+ }
+ else {
+ if (i > 0) {
+ if (!cmpMapping(mapping, this._mappings[i - 1])) {
+ continue;
+ }
+ result += ',';
+ }
+ }
+
+ result += base64VLQ.encode(mapping.generated.column
+ - previousGeneratedColumn);
+ previousGeneratedColumn = mapping.generated.column;
+
+ if (mapping.source && mapping.original) {
+ result += base64VLQ.encode(this._sources.indexOf(mapping.source)
+ - previousSource);
+ previousSource = this._sources.indexOf(mapping.source);
+
+ // lines are stored 0-based in SourceMap spec version 3
+ result += base64VLQ.encode(mapping.original.line - 1
+ - previousOriginalLine);
+ previousOriginalLine = mapping.original.line - 1;
+
+ result += base64VLQ.encode(mapping.original.column
+ - previousOriginalColumn);
+ previousOriginalColumn = mapping.original.column;
+
+ if (mapping.name) {
+ result += base64VLQ.encode(this._names.indexOf(mapping.name)
+ - previousName);
+ previousName = this._names.indexOf(mapping.name);
+ }
+ }
+ }
+
+ return result;
+ };
+
+ /**
+ * Externalize the source map.
+ */
+ SourceMapGenerator.prototype.toJSON =
+ function SourceMapGenerator_toJSON() {
+ var map = {
+ version: this._version,
+ file: this._file,
+ sources: this._sources.toArray(),
+ names: this._names.toArray(),
+ mappings: this._serializeMappings()
+ };
+ if (this._sourceRoot) {
+ map.sourceRoot = this._sourceRoot;
+ }
+ if (this._sourcesContents) {
+ map.sourcesContent = map.sources.map(function (source) {
+ if (map.sourceRoot) {
+ source = util.relative(map.sourceRoot, source);
+ }
+ return Object.prototype.hasOwnProperty.call(
+ this._sourcesContents, util.toSetString(source))
+ ? this._sourcesContents[util.toSetString(source)]
+ : null;
+ }, this);
+ }
+ return map;
+ };
+
+ /**
+ * Render the source map being generated to a string.
+ */
+ SourceMapGenerator.prototype.toString =
+ function SourceMapGenerator_toString() {
+ return JSON.stringify(this);
+ };
+
+ exports.SourceMapGenerator = SourceMapGenerator;
+
+});
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+define('source-map/source-node', function (require, exports, module) {
+
+ var SourceMapGenerator = require('./source-map-generator').SourceMapGenerator;
+ var util = require('./util');
+
+ /**
+ * SourceNodes provide a way to abstract over interpolating/concatenating
+ * snippets of generated JavaScript source code while maintaining the line and
+ * column information associated with the original source code.
+ *
+ * @param aLine The original line number.
+ * @param aColumn The original column number.
+ * @param aSource The original source's filename.
+ * @param aChunks Optional. An array of strings which are snippets of
+ * generated JS, or other SourceNodes.
+ * @param aName The original identifier.
+ */
+ function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
+ this.children = [];
+ this.sourceContents = {};
+ this.line = aLine === undefined ? null : aLine;
+ this.column = aColumn === undefined ? null : aColumn;
+ this.source = aSource === undefined ? null : aSource;
+ this.name = aName === undefined ? null : aName;
+ if (aChunks != null) this.add(aChunks);
+ }
+
+ /**
+ * Creates a SourceNode from generated code and a SourceMapConsumer.
+ *
+ * @param aGeneratedCode The generated code
+ * @param aSourceMapConsumer The SourceMap for the generated code
+ */
+ SourceNode.fromStringWithSourceMap =
+ function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer) {
+ // The SourceNode we want to fill with the generated code
+ // and the SourceMap
+ var node = new SourceNode();
+
+ // The generated code
+ // Processed fragments are removed from this array.
+ var remainingLines = aGeneratedCode.split('\n');
+
+ // We need to remember the position of "remainingLines"
+ var lastGeneratedLine = 1, lastGeneratedColumn = 0;
+
+ // The generate SourceNodes we need a code range.
+ // To extract it current and last mapping is used.
+ // Here we store the last mapping.
+ var lastMapping = null;
+
+ aSourceMapConsumer.eachMapping(function (mapping) {
+ if (lastMapping === null) {
+ // We add the generated code until the first mapping
+ // to the SourceNode without any mapping.
+ // Each line is added as separate string.
+ while (lastGeneratedLine < mapping.generatedLine) {
+ node.add(remainingLines.shift() + "\n");
+ lastGeneratedLine++;
+ }
+ if (lastGeneratedColumn < mapping.generatedColumn) {
+ var nextLine = remainingLines[0];
+ node.add(nextLine.substr(0, mapping.generatedColumn));
+ remainingLines[0] = nextLine.substr(mapping.generatedColumn);
+ lastGeneratedColumn = mapping.generatedColumn;
+ }
+ } else {
+ // We add the code from "lastMapping" to "mapping":
+ // First check if there is a new line in between.
+ if (lastGeneratedLine < mapping.generatedLine) {
+ var code = "";
+ // Associate full lines with "lastMapping"
+ do {
+ code += remainingLines.shift() + "\n";
+ lastGeneratedLine++;
+ lastGeneratedColumn = 0;
+ } while (lastGeneratedLine < mapping.generatedLine);
+ // When we reached the correct line, we add code until we
+ // reach the correct column too.
+ if (lastGeneratedColumn < mapping.generatedColumn) {
+ var nextLine = remainingLines[0];
+ code += nextLine.substr(0, mapping.generatedColumn);
+ remainingLines[0] = nextLine.substr(mapping.generatedColumn);
+ lastGeneratedColumn = mapping.generatedColumn;
+ }
+ // Create the SourceNode.
+ addMappingWithCode(lastMapping, code);
+ } else {
+ // There is no new line in between.
+ // Associate the code between "lastGeneratedColumn" and
+ // "mapping.generatedColumn" with "lastMapping"
+ var nextLine = remainingLines[0];
+ var code = nextLine.substr(0, mapping.generatedColumn -
+ lastGeneratedColumn);
+ remainingLines[0] = nextLine.substr(mapping.generatedColumn -
+ lastGeneratedColumn);
+ lastGeneratedColumn = mapping.generatedColumn;
+ addMappingWithCode(lastMapping, code);
+ }
+ }
+ lastMapping = mapping;
+ }, this);
+ // We have processed all mappings.
+ // Associate the remaining code in the current line with "lastMapping"
+ // and add the remaining lines without any mapping
+ addMappingWithCode(lastMapping, remainingLines.join("\n"));
+
+ // Copy sourcesContent into SourceNode
+ aSourceMapConsumer.sources.forEach(function (sourceFile) {
+ var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+ if (content) {
+ node.setSourceContent(sourceFile, content);
+ }
+ });
+
+ return node;
+
+ function addMappingWithCode(mapping, code) {
+ if (mapping.source === undefined) {
+ node.add(code);
+ } else {
+ node.add(new SourceNode(mapping.originalLine,
+ mapping.originalColumn,
+ mapping.source,
+ code,
+ mapping.name));
+ }
+ }
+ };
+
+ /**
+ * Add a chunk of generated JS to this source node.
+ *
+ * @param aChunk A string snippet of generated JS code, another instance of
+ * SourceNode, or an array where each member is one of those things.
+ */
+ SourceNode.prototype.add = function SourceNode_add(aChunk) {
+ if (Array.isArray(aChunk)) {
+ aChunk.forEach(function (chunk) {
+ this.add(chunk);
+ }, this);
+ }
+ else if (aChunk instanceof SourceNode || typeof aChunk === "string") {
+ if (aChunk) {
+ this.children.push(aChunk);
+ }
+ }
+ else {
+ throw new TypeError(
+ "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+ );
+ }
+ return this;
+ };
+
+ /**
+ * Add a chunk of generated JS to the beginning of this source node.
+ *
+ * @param aChunk A string snippet of generated JS code, another instance of
+ * SourceNode, or an array where each member is one of those things.
+ */
+ SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
+ if (Array.isArray(aChunk)) {
+ for (var i = aChunk.length-1; i >= 0; i--) {
+ this.prepend(aChunk[i]);
+ }
+ }
+ else if (aChunk instanceof SourceNode || typeof aChunk === "string") {
+ this.children.unshift(aChunk);
+ }
+ else {
+ throw new TypeError(
+ "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+ );
+ }
+ return this;
+ };
+
+ /**
+ * Walk over the tree of JS snippets in this node and its children. The
+ * walking function is called once for each snippet of JS and is passed that
+ * snippet and the its original associated source's line/column location.
+ *
+ * @param aFn The traversal function.
+ */
+ SourceNode.prototype.walk = function SourceNode_walk(aFn) {
+ this.children.forEach(function (chunk) {
+ if (chunk instanceof SourceNode) {
+ chunk.walk(aFn);
+ }
+ else {
+ if (chunk !== '') {
+ aFn(chunk, { source: this.source,
+ line: this.line,
+ column: this.column,
+ name: this.name });
+ }
+ }
+ }, this);
+ };
+
+ /**
+ * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
+ * each of `this.children`.
+ *
+ * @param aSep The separator.
+ */
+ SourceNode.prototype.join = function SourceNode_join(aSep) {
+ var newChildren;
+ var i;
+ var len = this.children.length;
+ if (len > 0) {
+ newChildren = [];
+ for (i = 0; i < len-1; i++) {
+ newChildren.push(this.children[i]);
+ newChildren.push(aSep);
+ }
+ newChildren.push(this.children[i]);
+ this.children = newChildren;
+ }
+ return this;
+ };
+
+ /**
+ * Call String.prototype.replace on the very right-most source snippet. Useful
+ * for trimming whitespace from the end of a source node, etc.
+ *
+ * @param aPattern The pattern to replace.
+ * @param aReplacement The thing to replace the pattern with.
+ */
+ SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
+ var lastChild = this.children[this.children.length - 1];
+ if (lastChild instanceof SourceNode) {
+ lastChild.replaceRight(aPattern, aReplacement);
+ }
+ else if (typeof lastChild === 'string') {
+ this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
+ }
+ else {
+ this.children.push(''.replace(aPattern, aReplacement));
+ }
+ return this;
+ };
+
+ /**
+ * Set the source content for a source file. This will be added to the SourceMapGenerator
+ * in the sourcesContent field.
+ *
+ * @param aSourceFile The filename of the source file
+ * @param aSourceContent The content of the source file
+ */
+ SourceNode.prototype.setSourceContent =
+ function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
+ this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
+ };
+
+ /**
+ * Walk over the tree of SourceNodes. The walking function is called for each
+ * source file content and is passed the filename and source content.
+ *
+ * @param aFn The traversal function.
+ */
+ SourceNode.prototype.walkSourceContents =
+ function SourceNode_walkSourceContents(aFn) {
+ this.children.forEach(function (chunk) {
+ if (chunk instanceof SourceNode) {
+ chunk.walkSourceContents(aFn);
+ }
+ }, this);
+ Object.keys(this.sourceContents).forEach(function (sourceFileKey) {
+ aFn(util.fromSetString(sourceFileKey), this.sourceContents[sourceFileKey]);
+ }, this);
+ };
+
+ /**
+ * Return the string representation of this source node. Walks over the tree
+ * and concatenates all the various snippets together to one string.
+ */
+ SourceNode.prototype.toString = function SourceNode_toString() {
+ var str = "";
+ this.walk(function (chunk) {
+ str += chunk;
+ });
+ return str;
+ };
+
+ /**
+ * Returns the string representation of this source node along with a source
+ * map.
+ */
+ SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
+ var generated = {
+ code: "",
+ line: 1,
+ column: 0
+ };
+ var map = new SourceMapGenerator(aArgs);
+ var sourceMappingActive = false;
+ this.walk(function (chunk, original) {
+ generated.code += chunk;
+ if (original.source !== null
+ && original.line !== null
+ && original.column !== null) {
+ map.addMapping({
+ source: original.source,
+ original: {
+ line: original.line,
+ column: original.column
+ },
+ generated: {
+ line: generated.line,
+ column: generated.column
+ },
+ name: original.name
+ });
+ sourceMappingActive = true;
+ } else if (sourceMappingActive) {
+ map.addMapping({
+ generated: {
+ line: generated.line,
+ column: generated.column
+ }
+ });
+ sourceMappingActive = false;
+ }
+ chunk.split('').forEach(function (ch) {
+ if (ch === '\n') {
+ generated.line++;
+ generated.column = 0;
+ } else {
+ generated.column++;
+ }
+ });
+ });
+ this.walkSourceContents(function (sourceFile, sourceContent) {
+ map.setSourceContent(sourceFile, sourceContent);
+ });
+
+ return { code: generated.code, map: map };
+ };
+
+ exports.SourceNode = SourceNode;
+
+});
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+define('source-map/util', function (require, exports, module) {
+
+ /**
+ * This is a helper function for getting values from parameter/options
+ * objects.
+ *
+ * @param args The object we are extracting values from
+ * @param name The name of the property we are getting.
+ * @param defaultValue An optional value to return if the property is missing
+ * from the object. If this is not specified and the property is missing, an
+ * error will be thrown.
+ */
+ function getArg(aArgs, aName, aDefaultValue) {
+ if (aName in aArgs) {
+ return aArgs[aName];
+ } else if (arguments.length === 3) {
+ return aDefaultValue;
+ } else {
+ throw new Error('"' + aName + '" is a required argument.');
+ }
+ }
+ exports.getArg = getArg;
+
+ var urlRegexp = /([\w+\-.]+):\/\/((\w+:\w+)@)?([\w.]+)?(:(\d+))?(\S+)?/;
+
+ function urlParse(aUrl) {
+ var match = aUrl.match(urlRegexp);
+ if (!match) {
+ return null;
+ }
+ return {
+ scheme: match[1],
+ auth: match[3],
+ host: match[4],
+ port: match[6],
+ path: match[7]
+ };
+ }
+ exports.urlParse = urlParse;
+
+ function urlGenerate(aParsedUrl) {
+ var url = aParsedUrl.scheme + "://";
+ if (aParsedUrl.auth) {
+ url += aParsedUrl.auth + "@"
+ }
+ if (aParsedUrl.host) {
+ url += aParsedUrl.host;
+ }
+ if (aParsedUrl.port) {
+ url += ":" + aParsedUrl.port
+ }
+ if (aParsedUrl.path) {
+ url += aParsedUrl.path;
+ }
+ return url;
+ }
+ exports.urlGenerate = urlGenerate;
+
+ function join(aRoot, aPath) {
+ var url;
+
+ if (aPath.match(urlRegexp)) {
+ return aPath;
+ }
+
+ if (aPath.charAt(0) === '/' && (url = urlParse(aRoot))) {
+ url.path = aPath;
+ return urlGenerate(url);
+ }
+
+ return aRoot.replace(/\/$/, '') + '/' + aPath;
+ }
+ exports.join = join;
+
+ /**
+ * Because behavior goes wacky when you set `__proto__` on objects, we
+ * have to prefix all the strings in our set with an arbitrary character.
+ *
+ * See https://github.com/mozilla/source-map/pull/31 and
+ * https://github.com/mozilla/source-map/issues/30
+ *
+ * @param String aStr
+ */
+ function toSetString(aStr) {
+ return '$' + aStr;
+ }
+ exports.toSetString = toSetString;
+
+ function fromSetString(aStr) {
+ return aStr.substr(1);
+ }
+ exports.fromSetString = fromSetString;
+
+ function relative(aRoot, aPath) {
+ aRoot = aRoot.replace(/\/$/, '');
+
+ var url = urlParse(aRoot);
+ if (aPath.charAt(0) == "/" && url && url.path == "/") {
+ return aPath.slice(1);
+ }
+
+ return aPath.indexOf(aRoot + '/') === 0
+ ? aPath.substr(aRoot.length + 1)
+ : aPath;
+ }
+ exports.relative = relative;
+
+});
+define('source-map', function (require, exports, module) {
+
+/*
+ * Copyright 2009-2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE.txt or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+exports.SourceMapGenerator = require('./source-map/source-map-generator').SourceMapGenerator;
+exports.SourceMapConsumer = require('./source-map/source-map-consumer').SourceMapConsumer;
+exports.SourceNode = require('./source-map/source-node').SourceNode;
+
+});
+
+//Distributed under the BSD license:
+//Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>
+define('uglifyjs2', ['exports', 'source-map', 'logger', 'env!env/file'], function (exports, MOZ_SourceMap, logger, rjsFile) {
+(function(exports, global) {
+ global["UglifyJS"] = exports;
+ "use strict";
+ function array_to_hash(a) {
+ var ret = Object.create(null);
+ for (var i = 0; i < a.length; ++i) ret[a[i]] = true;
+ return ret;
+ }
+ function slice(a, start) {
+ return Array.prototype.slice.call(a, start || 0);
+ }
+ function characters(str) {
+ return str.split("");
+ }
+ function member(name, array) {
+ for (var i = array.length; --i >= 0; ) if (array[i] == name) return true;
+ return false;
+ }
+ function find_if(func, array) {
+ for (var i = 0, n = array.length; i < n; ++i) {
+ if (func(array[i])) return array[i];
+ }
+ }
+ function repeat_string(str, i) {
+ if (i <= 0) return "";
+ if (i == 1) return str;
+ var d = repeat_string(str, i >> 1);
+ d += d;
+ if (i & 1) d += str;
+ return d;
+ }
+ function DefaultsError(msg, defs) {
+ this.msg = msg;
+ this.defs = defs;
+ }
+ function defaults(args, defs, croak) {
+ if (args === true) args = {};
+ var ret = args || {};
+ if (croak) for (var i in ret) if (ret.hasOwnProperty(i) && !defs.hasOwnProperty(i)) throw new DefaultsError("`" + i + "` is not a supported option", defs);
+ for (var i in defs) if (defs.hasOwnProperty(i)) {
+ ret[i] = args && args.hasOwnProperty(i) ? args[i] : defs[i];
+ }
+ return ret;
+ }
+ function merge(obj, ext) {
+ for (var i in ext) if (ext.hasOwnProperty(i)) {
+ obj[i] = ext[i];
+ }
+ return obj;
+ }
+ function noop() {}
+ var MAP = function() {
+ function MAP(a, f, backwards) {
+ var ret = [], top = [], i;
+ function doit() {
+ var val = f(a[i], i);
+ var is_last = val instanceof Last;
+ if (is_last) val = val.v;
+ if (val instanceof AtTop) {
+ val = val.v;
+ if (val instanceof Splice) {
+ top.push.apply(top, backwards ? val.v.slice().reverse() : val.v);
+ } else {
+ top.push(val);
+ }
+ } else if (val !== skip) {
+ if (val instanceof Splice) {
+ ret.push.apply(ret, backwards ? val.v.slice().reverse() : val.v);
+ } else {
+ ret.push(val);
+ }
+ }
+ return is_last;
+ }
+ if (a instanceof Array) {
+ if (backwards) {
+ for (i = a.length; --i >= 0; ) if (doit()) break;
+ ret.reverse();
+ top.reverse();
+ } else {
+ for (i = 0; i < a.length; ++i) if (doit()) break;
+ }
+ } else {
+ for (i in a) if (a.hasOwnProperty(i)) if (doit()) break;
+ }
+ return top.concat(ret);
+ }
+ MAP.at_top = function(val) {
+ return new AtTop(val);
+ };
+ MAP.splice = function(val) {
+ return new Splice(val);
+ };
+ MAP.last = function(val) {
+ return new Last(val);
+ };
+ var skip = MAP.skip = {};
+ function AtTop(val) {
+ this.v = val;
+ }
+ function Splice(val) {
+ this.v = val;
+ }
+ function Last(val) {
+ this.v = val;
+ }
+ return MAP;
+ }();
+ function push_uniq(array, el) {
+ if (array.indexOf(el) < 0) array.push(el);
+ }
+ function string_template(text, props) {
+ return text.replace(/\{(.+?)\}/g, function(str, p) {
+ return props[p];
+ });
+ }
+ function remove(array, el) {
+ for (var i = array.length; --i >= 0; ) {
+ if (array[i] === el) array.splice(i, 1);
+ }
+ }
+ function mergeSort(array, cmp) {
+ if (array.length < 2) return array.slice();
+ function merge(a, b) {
+ var r = [], ai = 0, bi = 0, i = 0;
+ while (ai < a.length && bi < b.length) {
+ cmp(a[ai], b[bi]) <= 0 ? r[i++] = a[ai++] : r[i++] = b[bi++];
+ }
+ if (ai < a.length) r.push.apply(r, a.slice(ai));
+ if (bi < b.length) r.push.apply(r, b.slice(bi));
+ return r;
+ }
+ function _ms(a) {
+ if (a.length <= 1) return a;
+ var m = Math.floor(a.length / 2), left = a.slice(0, m), right = a.slice(m);
+ left = _ms(left);
+ right = _ms(right);
+ return merge(left, right);
+ }
+ return _ms(array);
+ }
+ function set_difference(a, b) {
+ return a.filter(function(el) {
+ return b.indexOf(el) < 0;
+ });
+ }
+ function set_intersection(a, b) {
+ return a.filter(function(el) {
+ return b.indexOf(el) >= 0;
+ });
+ }
+ function makePredicate(words) {
+ if (!(words instanceof Array)) words = words.split(" ");
+ var f = "", cats = [];
+ out: for (var i = 0; i < words.length; ++i) {
+ for (var j = 0; j < cats.length; ++j) if (cats[j][0].length == words[i].length) {
+ cats[j].push(words[i]);
+ continue out;
+ }
+ cats.push([ words[i] ]);
+ }
+ function compareTo(arr) {
+ if (arr.length == 1) return f += "return str === " + JSON.stringify(arr[0]) + ";";
+ f += "switch(str){";
+ for (var i = 0; i < arr.length; ++i) f += "case " + JSON.stringify(arr[i]) + ":";
+ f += "return true}return false;";
+ }
+ if (cats.length > 3) {
+ cats.sort(function(a, b) {
+ return b.length - a.length;
+ });
+ f += "switch(str.length){";
+ for (var i = 0; i < cats.length; ++i) {
+ var cat = cats[i];
+ f += "case " + cat[0].length + ":";
+ compareTo(cat);
+ }
+ f += "}";
+ } else {
+ compareTo(words);
+ }
+ return new Function("str", f);
+ }
+ function all(array, predicate) {
+ for (var i = array.length; --i >= 0; ) if (!predicate(array[i])) return false;
+ return true;
+ }
+ function Dictionary() {
+ this._values = Object.create(null);
+ this._size = 0;
+ }
+ Dictionary.prototype = {
+ set: function(key, val) {
+ if (!this.has(key)) ++this._size;
+ this._values["$" + key] = val;
+ return this;
+ },
+ add: function(key, val) {
+ if (this.has(key)) {
+ this.get(key).push(val);
+ } else {
+ this.set(key, [ val ]);
+ }
+ return this;
+ },
+ get: function(key) {
+ return this._values["$" + key];
+ },
+ del: function(key) {
+ if (this.has(key)) {
+ --this._size;
+ delete this._values["$" + key];
+ }
+ return this;
+ },
+ has: function(key) {
+ return "$" + key in this._values;
+ },
+ each: function(f) {
+ for (var i in this._values) f(this._values[i], i.substr(1));
+ },
+ size: function() {
+ return this._size;
+ },
+ map: function(f) {
+ var ret = [];
+ for (var i in this._values) ret.push(f(this._values[i], i.substr(1)));
+ return ret;
+ }
+ };
+ "use strict";
+ function DEFNODE(type, props, methods, base) {
+ if (arguments.length < 4) base = AST_Node;
+ if (!props) props = []; else props = props.split(/\s+/);
+ var self_props = props;
+ if (base && base.PROPS) props = props.concat(base.PROPS);
+ var code = "return function AST_" + type + "(props){ if (props) { ";
+ for (var i = props.length; --i >= 0; ) {
+ code += "this." + props[i] + " = props." + props[i] + ";";
+ }
+ var proto = base && new base();
+ if (proto && proto.initialize || methods && methods.initialize) code += "this.initialize();";
+ code += "}}";
+ var ctor = new Function(code)();
+ if (proto) {
+ ctor.prototype = proto;
+ ctor.BASE = base;
+ }
+ if (base) base.SUBCLASSES.push(ctor);
+ ctor.prototype.CTOR = ctor;
+ ctor.PROPS = props || null;
+ ctor.SELF_PROPS = self_props;
+ ctor.SUBCLASSES = [];
+ if (type) {
+ ctor.prototype.TYPE = ctor.TYPE = type;
+ }
+ if (methods) for (i in methods) if (methods.hasOwnProperty(i)) {
+ if (/^\$/.test(i)) {
+ ctor[i.substr(1)] = methods[i];
+ } else {
+ ctor.prototype[i] = methods[i];
+ }
+ }
+ ctor.DEFMETHOD = function(name, method) {
+ this.prototype[name] = method;
+ };
+ return ctor;
+ }
+ var AST_Token = DEFNODE("Token", "type value line col pos endpos nlb comments_before file", {}, null);
+ var AST_Node = DEFNODE("Node", "start end", {
+ clone: function() {
+ return new this.CTOR(this);
+ },
+ $documentation: "Base class of all AST nodes",
+ $propdoc: {
+ start: "[AST_Token] The first token of this node",
+ end: "[AST_Token] The last token of this node"
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this);
+ },
+ walk: function(visitor) {
+ return this._walk(visitor);
+ }
+ }, null);
+ AST_Node.warn_function = null;
+ AST_Node.warn = function(txt, props) {
+ if (AST_Node.warn_function) AST_Node.warn_function(string_template(txt, props));
+ };
+ var AST_Statement = DEFNODE("Statement", null, {
+ $documentation: "Base class of all statements"
+ });
+ var AST_Debugger = DEFNODE("Debugger", null, {
+ $documentation: "Represents a debugger statement"
+ }, AST_Statement);
+ var AST_Directive = DEFNODE("Directive", "value scope", {
+ $documentation: 'Represents a directive, like "use strict";',
+ $propdoc: {
+ value: "[string] The value of this directive as a plain string (it's not an AST_String!)",
+ scope: "[AST_Scope/S] The scope that this directive affects"
+ }
+ }, AST_Statement);
+ var AST_SimpleStatement = DEFNODE("SimpleStatement", "body", {
+ $documentation: "A statement consisting of an expression, i.e. a = 1 + 2",
+ $propdoc: {
+ body: "[AST_Node] an expression node (should not be instanceof AST_Statement)"
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this, function() {
+ this.body._walk(visitor);
+ });
+ }
+ }, AST_Statement);
+ function walk_body(node, visitor) {
+ if (node.body instanceof AST_Statement) {
+ node.body._walk(visitor);
+ } else node.body.forEach(function(stat) {
+ stat._walk(visitor);
+ });
+ }
+ var AST_Block = DEFNODE("Block", "body", {
+ $documentation: "A body of statements (usually bracketed)",
+ $propdoc: {
+ body: "[AST_Statement*] an array of statements"
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this, function() {
+ walk_body(this, visitor);
+ });
+ }
+ }, AST_Statement);
+ var AST_BlockStatement = DEFNODE("BlockStatement", null, {
+ $documentation: "A block statement"
+ }, AST_Block);
+ var AST_EmptyStatement = DEFNODE("EmptyStatement", null, {
+ $documentation: "The empty statement (empty block or simply a semicolon)",
+ _walk: function(visitor) {
+ return visitor._visit(this);
+ }
+ }, AST_Statement);
+ var AST_StatementWithBody = DEFNODE("StatementWithBody", "body", {
+ $documentation: "Base class for all statements that contain one nested body: `For`, `ForIn`, `Do`, `While`, `With`",
+ $propdoc: {
+ body: "[AST_Statement] the body; this should always be present, even if it's an AST_EmptyStatement"
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this, function() {
+ this.body._walk(visitor);
+ });
+ }
+ }, AST_Statement);
+ var AST_LabeledStatement = DEFNODE("LabeledStatement", "label", {
+ $documentation: "Statement with a label",
+ $propdoc: {
+ label: "[AST_Label] a label definition"
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this, function() {
+ this.label._walk(visitor);
+ this.body._walk(visitor);
+ });
+ }
+ }, AST_StatementWithBody);
+ var AST_DWLoop = DEFNODE("DWLoop", "condition", {
+ $documentation: "Base class for do/while statements",
+ $propdoc: {
+ condition: "[AST_Node] the loop condition. Should not be instanceof AST_Statement"
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this, function() {
+ this.condition._walk(visitor);
+ this.body._walk(visitor);
+ });
+ }
+ }, AST_StatementWithBody);
+ var AST_Do = DEFNODE("Do", null, {
+ $documentation: "A `do` statement"
+ }, AST_DWLoop);
+ var AST_While = DEFNODE("While", null, {
+ $documentation: "A `while` statement"
+ }, AST_DWLoop);
+ var AST_For = DEFNODE("For", "init condition step", {
+ $documentation: "A `for` statement",
+ $propdoc: {
+ init: "[AST_Node?] the `for` initialization code, or null if empty",
+ condition: "[AST_Node?] the `for` termination clause, or null if empty",
+ step: "[AST_Node?] the `for` update clause, or null if empty"
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this, function() {
+ if (this.init) this.init._walk(visitor);
+ if (this.condition) this.condition._walk(visitor);
+ if (this.step) this.step._walk(visitor);
+ this.body._walk(visitor);
+ });
+ }
+ }, AST_StatementWithBody);
+ var AST_ForIn = DEFNODE("ForIn", "init name object", {
+ $documentation: "A `for ... in` statement",
+ $propdoc: {
+ init: "[AST_Node] the `for/in` initialization code",
+ name: "[AST_SymbolRef?] the loop variable, only if `init` is AST_Var",
+ object: "[AST_Node] the object that we're looping through"
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this, function() {
+ this.init._walk(visitor);
+ this.object._walk(visitor);
+ this.body._walk(visitor);
+ });
+ }
+ }, AST_StatementWithBody);
+ var AST_With = DEFNODE("With", "expression", {
+ $documentation: "A `with` statement",
+ $propdoc: {
+ expression: "[AST_Node] the `with` expression"
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this, function() {
+ this.expression._walk(visitor);
+ this.body._walk(visitor);
+ });
+ }
+ }, AST_StatementWithBody);
+ var AST_Scope = DEFNODE("Scope", "directives variables functions uses_with uses_eval parent_scope enclosed cname", {
+ $documentation: "Base class for all statements introducing a lexical scope",
+ $propdoc: {
+ directives: "[string*/S] an array of directives declared in this scope",
+ variables: "[Object/S] a map of name -> SymbolDef for all variables/functions defined in this scope",
+ functions: "[Object/S] like `variables`, but only lists function declarations",
+ uses_with: "[boolean/S] tells whether this scope uses the `with` statement",
+ uses_eval: "[boolean/S] tells whether this scope contains a direct call to the global `eval`",
+ parent_scope: "[AST_Scope?/S] link to the parent scope",
+ enclosed: "[SymbolDef*/S] a list of all symbol definitions that are accessed from this scope or any subscopes",
+ cname: "[integer/S] current index for mangling variables (used internally by the mangler)"
+ }
+ }, AST_Block);
+ var AST_Toplevel = DEFNODE("Toplevel", "globals", {
+ $documentation: "The toplevel scope",
+ $propdoc: {
+ globals: "[Object/S] a map of name -> SymbolDef for all undeclared names"
+ },
+ wrap_enclose: function(arg_parameter_pairs) {
+ var self = this;
+ var args = [];
+ var parameters = [];
+ arg_parameter_pairs.forEach(function(pair) {
+ var split = pair.split(":");
+ args.push(split[0]);
+ parameters.push(split[1]);
+ });
+ var wrapped_tl = "(function(" + parameters.join(",") + "){ '$ORIG'; })(" + args.join(",") + ")";
+ wrapped_tl = parse(wrapped_tl);
+ wrapped_tl = wrapped_tl.transform(new TreeTransformer(function before(node) {
+ if (node instanceof AST_Directive && node.value == "$ORIG") {
+ return MAP.splice(self.body);
+ }
+ }));
+ return wrapped_tl;
+ },
+ wrap_commonjs: function(name, export_all) {
+ var self = this;
+ var to_export = [];
+ if (export_all) {
+ self.figure_out_scope();
+ self.walk(new TreeWalker(function(node) {
+ if (node instanceof AST_SymbolDeclaration && node.definition().global) {
+ if (!find_if(function(n) {
+ return n.name == node.name;
+ }, to_export)) to_export.push(node);
+ }
+ }));
+ }
+ var wrapped_tl = "(function(exports, global){ global['" + name + "'] = exports; '$ORIG'; '$EXPORTS'; }({}, (function(){return this}())))";
+ wrapped_tl = parse(wrapped_tl);
+ wrapped_tl = wrapped_tl.transform(new TreeTransformer(function before(node) {
+ if (node instanceof AST_SimpleStatement) {
+ node = node.body;
+ if (node instanceof AST_String) switch (node.getValue()) {
+ case "$ORIG":
+ return MAP.splice(self.body);
+
+ case "$EXPORTS":
+ var body = [];
+ to_export.forEach(function(sym) {
+ body.push(new AST_SimpleStatement({
+ body: new AST_Assign({
+ left: new AST_Sub({
+ expression: new AST_SymbolRef({
+ name: "exports"
+ }),
+ property: new AST_String({
+ value: sym.name
+ })
+ }),
+ operator: "=",
+ right: new AST_SymbolRef(sym)
+ })
+ }));
+ });
+ return MAP.splice(body);
+ }
+ }
+ }));
+ return wrapped_tl;
+ }
+ }, AST_Scope);
+ var AST_Lambda = DEFNODE("Lambda", "name argnames uses_arguments", {
+ $documentation: "Base class for functions",
+ $propdoc: {
+ name: "[AST_SymbolDeclaration?] the name of this function",
+ argnames: "[AST_SymbolFunarg*] array of function arguments",
+ uses_arguments: "[boolean/S] tells whether this function accesses the arguments array"
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this, function() {
+ if (this.name) this.name._walk(visitor);
+ this.argnames.forEach(function(arg) {
+ arg._walk(visitor);
+ });
+ walk_body(this, visitor);
+ });
+ }
+ }, AST_Scope);
+ var AST_Accessor = DEFNODE("Accessor", null, {
+ $documentation: "A setter/getter function"
+ }, AST_Lambda);
+ var AST_Function = DEFNODE("Function", null, {
+ $documentation: "A function expression"
+ }, AST_Lambda);
+ var AST_Defun = DEFNODE("Defun", null, {
+ $documentation: "A function definition"
+ }, AST_Lambda);
+ var AST_Jump = DEFNODE("Jump", null, {
+ $documentation: "Base class for “jumps” (for now that's `return`, `throw`, `break` and `continue`)"
+ }, AST_Statement);
+ var AST_Exit = DEFNODE("Exit", "value", {
+ $documentation: "Base class for “exits” (`return` and `throw`)",
+ $propdoc: {
+ value: "[AST_Node?] the value returned or thrown by this statement; could be null for AST_Return"
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this, this.value && function() {
+ this.value._walk(visitor);
+ });
+ }
+ }, AST_Jump);
+ var AST_Return = DEFNODE("Return", null, {
+ $documentation: "A `return` statement"
+ }, AST_Exit);
+ var AST_Throw = DEFNODE("Throw", null, {
+ $documentation: "A `throw` statement"
+ }, AST_Exit);
+ var AST_LoopControl = DEFNODE("LoopControl", "label", {
+ $documentation: "Base class for loop control statements (`break` and `continue`)",
+ $propdoc: {
+ label: "[AST_LabelRef?] the label, or null if none"
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this, this.label && function() {
+ this.label._walk(visitor);
+ });
+ }
+ }, AST_Jump);
+ var AST_Break = DEFNODE("Break", null, {
+ $documentation: "A `break` statement"
+ }, AST_LoopControl);
+ var AST_Continue = DEFNODE("Continue", null, {
+ $documentation: "A `continue` statement"
+ }, AST_LoopControl);
+ var AST_If = DEFNODE("If", "condition alternative", {
+ $documentation: "A `if` statement",
+ $propdoc: {
+ condition: "[AST_Node] the `if` condition",
+ alternative: "[AST_Statement?] the `else` part, or null if not present"
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this, function() {
+ this.condition._walk(visitor);
+ this.body._walk(visitor);
+ if (this.alternative) this.alternative._walk(visitor);
+ });
+ }
+ }, AST_StatementWithBody);
+ var AST_Switch = DEFNODE("Switch", "expression", {
+ $documentation: "A `switch` statement",
+ $propdoc: {
+ expression: "[AST_Node] the `switch` “discriminant”"
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this, function() {
+ this.expression._walk(visitor);
+ walk_body(this, visitor);
+ });
+ }
+ }, AST_Block);
+ var AST_SwitchBranch = DEFNODE("SwitchBranch", null, {
+ $documentation: "Base class for `switch` branches"
+ }, AST_Block);
+ var AST_Default = DEFNODE("Default", null, {
+ $documentation: "A `default` switch branch"
+ }, AST_SwitchBranch);
+ var AST_Case = DEFNODE("Case", "expression", {
+ $documentation: "A `case` switch branch",
+ $propdoc: {
+ expression: "[AST_Node] the `case` expression"
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this, function() {
+ this.expression._walk(visitor);
+ walk_body(this, visitor);
+ });
+ }
+ }, AST_SwitchBranch);
+ var AST_Try = DEFNODE("Try", "bcatch bfinally", {
+ $documentation: "A `try` statement",
+ $propdoc: {
+ bcatch: "[AST_Catch?] the catch block, or null if not present",
+ bfinally: "[AST_Finally?] the finally block, or null if not present"
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this, function() {
+ walk_body(this, visitor);
+ if (this.bcatch) this.bcatch._walk(visitor);
+ if (this.bfinally) this.bfinally._walk(visitor);
+ });
+ }
+ }, AST_Block);
+ var AST_Catch = DEFNODE("Catch", "argname", {
+ $documentation: "A `catch` node; only makes sense as part of a `try` statement",
+ $propdoc: {
+ argname: "[AST_SymbolCatch] symbol for the exception"
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this, function() {
+ this.argname._walk(visitor);
+ walk_body(this, visitor);
+ });
+ }
+ }, AST_Block);
+ var AST_Finally = DEFNODE("Finally", null, {
+ $documentation: "A `finally` node; only makes sense as part of a `try` statement"
+ }, AST_Block);
+ var AST_Definitions = DEFNODE("Definitions", "definitions", {
+ $documentation: "Base class for `var` or `const` nodes (variable declarations/initializations)",
+ $propdoc: {
+ definitions: "[AST_VarDef*] array of variable definitions"
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this, function() {
+ this.definitions.forEach(function(def) {
+ def._walk(visitor);
+ });
+ });
+ }
+ }, AST_Statement);
+ var AST_Var = DEFNODE("Var", null, {
+ $documentation: "A `var` statement"
+ }, AST_Definitions);
+ var AST_Const = DEFNODE("Const", null, {
+ $documentation: "A `const` statement"
+ }, AST_Definitions);
+ var AST_VarDef = DEFNODE("VarDef", "name value", {
+ $documentation: "A variable declaration; only appears in a AST_Definitions node",
+ $propdoc: {
+ name: "[AST_SymbolVar|AST_SymbolConst] name of the variable",
+ value: "[AST_Node?] initializer, or null of there's no initializer"
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this, function() {
+ this.name._walk(visitor);
+ if (this.value) this.value._walk(visitor);
+ });
+ }
+ });
+ var AST_Call = DEFNODE("Call", "expression args", {
+ $documentation: "A function call expression",
+ $propdoc: {
+ expression: "[AST_Node] expression to invoke as function",
+ args: "[AST_Node*] array of arguments"
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this, function() {
+ this.expression._walk(visitor);
+ this.args.forEach(function(arg) {
+ arg._walk(visitor);
+ });
+ });
+ }
+ });
+ var AST_New = DEFNODE("New", null, {
+ $documentation: "An object instantiation. Derives from a function call since it has exactly the same properties"
+ }, AST_Call);
+ var AST_Seq = DEFNODE("Seq", "car cdr", {
+ $documentation: "A sequence expression (two comma-separated expressions)",
+ $propdoc: {
+ car: "[AST_Node] first element in sequence",
+ cdr: "[AST_Node] second element in sequence"
+ },
+ $cons: function(x, y) {
+ var seq = new AST_Seq(x);
+ seq.car = x;
+ seq.cdr = y;
+ return seq;
+ },
+ $from_array: function(array) {
+ if (array.length == 0) return null;
+ if (array.length == 1) return array[0].clone();
+ var list = null;
+ for (var i = array.length; --i >= 0; ) {
+ list = AST_Seq.cons(array[i], list);
+ }
+ var p = list;
+ while (p) {
+ if (p.cdr && !p.cdr.cdr) {
+ p.cdr = p.cdr.car;
+ break;
+ }
+ p = p.cdr;
+ }
+ return list;
+ },
+ to_array: function() {
+ var p = this, a = [];
+ while (p) {
+ a.push(p.car);
+ if (p.cdr && !(p.cdr instanceof AST_Seq)) {
+ a.push(p.cdr);
+ break;
+ }
+ p = p.cdr;
+ }
+ return a;
+ },
+ add: function(node) {
+ var p = this;
+ while (p) {
+ if (!(p.cdr instanceof AST_Seq)) {
+ var cell = AST_Seq.cons(p.cdr, node);
+ return p.cdr = cell;
+ }
+ p = p.cdr;
+ }
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this, function() {
+ this.car._walk(visitor);
+ if (this.cdr) this.cdr._walk(visitor);
+ });
+ }
+ });
+ var AST_PropAccess = DEFNODE("PropAccess", "expression property", {
+ $documentation: 'Base class for property access expressions, i.e. `a.foo` or `a["foo"]`',
+ $propdoc: {
+ expression: "[AST_Node] the “container” expression",
+ property: "[AST_Node|string] the property to access. For AST_Dot this is always a plain string, while for AST_Sub it's an arbitrary AST_Node"
+ }
+ });
+ var AST_Dot = DEFNODE("Dot", null, {
+ $documentation: "A dotted property access expression",
+ _walk: function(visitor) {
+ return visitor._visit(this, function() {
+ this.expression._walk(visitor);
+ });
+ }
+ }, AST_PropAccess);
+ var AST_Sub = DEFNODE("Sub", null, {
+ $documentation: 'Index-style property access, i.e. `a["foo"]`',
+ _walk: function(visitor) {
+ return visitor._visit(this, function() {
+ this.expression._walk(visitor);
+ this.property._walk(visitor);
+ });
+ }
+ }, AST_PropAccess);
+ var AST_Unary = DEFNODE("Unary", "operator expression", {
+ $documentation: "Base class for unary expressions",
+ $propdoc: {
+ operator: "[string] the operator",
+ expression: "[AST_Node] expression that this unary operator applies to"
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this, function() {
+ this.expression._walk(visitor);
+ });
+ }
+ });
+ var AST_UnaryPrefix = DEFNODE("UnaryPrefix", null, {
+ $documentation: "Unary prefix expression, i.e. `typeof i` or `++i`"
+ }, AST_Unary);
+ var AST_UnaryPostfix = DEFNODE("UnaryPostfix", null, {
+ $documentation: "Unary postfix expression, i.e. `i++`"
+ }, AST_Unary);
+ var AST_Binary = DEFNODE("Binary", "left operator right", {
+ $documentation: "Binary expression, i.e. `a + b`",
+ $propdoc: {
+ left: "[AST_Node] left-hand side expression",
+ operator: "[string] the operator",
+ right: "[AST_Node] right-hand side expression"
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this, function() {
+ this.left._walk(visitor);
+ this.right._walk(visitor);
+ });
+ }
+ });
+ var AST_Conditional = DEFNODE("Conditional", "condition consequent alternative", {
+ $documentation: "Conditional expression using the ternary operator, i.e. `a ? b : c`",
+ $propdoc: {
+ condition: "[AST_Node]",
+ consequent: "[AST_Node]",
+ alternative: "[AST_Node]"
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this, function() {
+ this.condition._walk(visitor);
+ this.consequent._walk(visitor);
+ this.alternative._walk(visitor);
+ });
+ }
+ });
+ var AST_Assign = DEFNODE("Assign", null, {
+ $documentation: "An assignment expression — `a = b + 5`"
+ }, AST_Binary);
+ var AST_Array = DEFNODE("Array", "elements", {
+ $documentation: "An array literal",
+ $propdoc: {
+ elements: "[AST_Node*] array of elements"
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this, function() {
+ this.elements.forEach(function(el) {
+ el._walk(visitor);
+ });
+ });
+ }
+ });
+ var AST_Object = DEFNODE("Object", "properties", {
+ $documentation: "An object literal",
+ $propdoc: {
+ properties: "[AST_ObjectProperty*] array of properties"
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this, function() {
+ this.properties.forEach(function(prop) {
+ prop._walk(visitor);
+ });
+ });
+ }
+ });
+ var AST_ObjectProperty = DEFNODE("ObjectProperty", "key value", {
+ $documentation: "Base class for literal object properties",
+ $propdoc: {
+ key: "[string] the property name; it's always a plain string in our AST, no matter if it was a string, number or identifier in original code",
+ value: "[AST_Node] property value. For setters and getters this is an AST_Function."
+ },
+ _walk: function(visitor) {
+ return visitor._visit(this, function() {
+ this.value._walk(visitor);
+ });
+ }
+ });
+ var AST_ObjectKeyVal = DEFNODE("ObjectKeyVal", null, {
+ $documentation: "A key: value object property"
+ }, AST_ObjectProperty);
+ var AST_ObjectSetter = DEFNODE("ObjectSetter", null, {
+ $documentation: "An object setter property"
+ }, AST_ObjectProperty);
+ var AST_ObjectGetter = DEFNODE("ObjectGetter", null, {
+ $documentation: "An object getter property"
+ }, AST_ObjectProperty);
+ var AST_Symbol = DEFNODE("Symbol", "scope name thedef", {
+ $propdoc: {
+ name: "[string] name of this symbol",
+ scope: "[AST_Scope/S] the current scope (not necessarily the definition scope)",
+ thedef: "[SymbolDef/S] the definition of this symbol"
+ },
+ $documentation: "Base class for all symbols"
+ });
+ var AST_SymbolAccessor = DEFNODE("SymbolAccessor", null, {
+ $documentation: "The name of a property accessor (setter/getter function)"
+ }, AST_Symbol);
+ var AST_SymbolDeclaration = DEFNODE("SymbolDeclaration", "init", {
+ $documentation: "A declaration symbol (symbol in var/const, function name or argument, symbol in catch)",
+ $propdoc: {
+ init: "[AST_Node*/S] array of initializers for this declaration."
+ }
+ }, AST_Symbol);
+ var AST_SymbolVar = DEFNODE("SymbolVar", null, {
+ $documentation: "Symbol defining a variable"
+ }, AST_SymbolDeclaration);
+ var AST_SymbolConst = DEFNODE("SymbolConst", null, {
+ $documentation: "A constant declaration"
+ }, AST_SymbolDeclaration);
+ var AST_SymbolFunarg = DEFNODE("SymbolFunarg", null, {
+ $documentation: "Symbol naming a function argument"
+ }, AST_SymbolVar);
+ var AST_SymbolDefun = DEFNODE("SymbolDefun", null, {
+ $documentation: "Symbol defining a function"
+ }, AST_SymbolDeclaration);
+ var AST_SymbolLambda = DEFNODE("SymbolLambda", null, {
+ $documentation: "Symbol naming a function expression"
+ }, AST_SymbolDeclaration);
+ var AST_SymbolCatch = DEFNODE("SymbolCatch", null, {
+ $documentation: "Symbol naming the exception in catch"
+ }, AST_SymbolDeclaration);
+ var AST_Label = DEFNODE("Label", "references", {
+ $documentation: "Symbol naming a label (declaration)",
+ $propdoc: {
+ references: "[AST_LabelRef*] a list of nodes referring to this label"
+ }
+ }, AST_Symbol);
+ var AST_SymbolRef = DEFNODE("SymbolRef", null, {
+ $documentation: "Reference to some symbol (not definition/declaration)"
+ }, AST_Symbol);
+ var AST_LabelRef = DEFNODE("LabelRef", null, {
+ $documentation: "Reference to a label symbol"
+ }, AST_Symbol);
+ var AST_This = DEFNODE("This", null, {
+ $documentation: "The `this` symbol"
+ }, AST_Symbol);
+ var AST_Constant = DEFNODE("Constant", null, {
+ $documentation: "Base class for all constants",
+ getValue: function() {
+ return this.value;
+ }
+ });
+ var AST_String = DEFNODE("String", "value", {
+ $documentation: "A string literal",
+ $propdoc: {
+ value: "[string] the contents of this string"
+ }
+ }, AST_Constant);
+ var AST_Number = DEFNODE("Number", "value", {
+ $documentation: "A number literal",
+ $propdoc: {
+ value: "[number] the numeric value"
+ }
+ }, AST_Constant);
+ var AST_RegExp = DEFNODE("RegExp", "value", {
+ $documentation: "A regexp literal",
+ $propdoc: {
+ value: "[RegExp] the actual regexp"
+ }
+ }, AST_Constant);
+ var AST_Atom = DEFNODE("Atom", null, {
+ $documentation: "Base class for atoms"
+ }, AST_Constant);
+ var AST_Null = DEFNODE("Null", null, {
+ $documentation: "The `null` atom",
+ value: null
+ }, AST_Atom);
+ var AST_NaN = DEFNODE("NaN", null, {
+ $documentation: "The impossible value",
+ value: 0 / 0
+ }, AST_Atom);
+ var AST_Undefined = DEFNODE("Undefined", null, {
+ $documentation: "The `undefined` value",
+ value: function() {}()
+ }, AST_Atom);
+ var AST_Hole = DEFNODE("Hole", null, {
+ $documentation: "A hole in an array",
+ value: function() {}()
+ }, AST_Atom);
+ var AST_Infinity = DEFNODE("Infinity", null, {
+ $documentation: "The `Infinity` value",
+ value: 1 / 0
+ }, AST_Atom);
+ var AST_Boolean = DEFNODE("Boolean", null, {
+ $documentation: "Base class for booleans"
+ }, AST_Atom);
+ var AST_False = DEFNODE("False", null, {
+ $documentation: "The `false` atom",
+ value: false
+ }, AST_Boolean);
+ var AST_True = DEFNODE("True", null, {
+ $documentation: "The `true` atom",
+ value: true
+ }, AST_Boolean);
+ function TreeWalker(callback) {
+ this.visit = callback;
+ this.stack = [];
+ }
+ TreeWalker.prototype = {
+ _visit: function(node, descend) {
+ this.stack.push(node);
+ var ret = this.visit(node, descend ? function() {
+ descend.call(node);
+ } : noop);
+ if (!ret && descend) {
+ descend.call(node);
+ }
+ this.stack.pop();
+ return ret;
+ },
+ parent: function(n) {
+ return this.stack[this.stack.length - 2 - (n || 0)];
+ },
+ push: function(node) {
+ this.stack.push(node);
+ },
+ pop: function() {
+ return this.stack.pop();
+ },
+ self: function() {
+ return this.stack[this.stack.length - 1];
+ },
+ find_parent: function(type) {
+ var stack = this.stack;
+ for (var i = stack.length; --i >= 0; ) {
+ var x = stack[i];
+ if (x instanceof type) return x;
+ }
+ },
+ in_boolean_context: function() {
+ var stack = this.stack;
+ var i = stack.length, self = stack[--i];
+ while (i > 0) {
+ var p = stack[--i];
+ if (p instanceof AST_If && p.condition === self || p instanceof AST_Conditional && p.condition === self || p instanceof AST_DWLoop && p.condition === self || p instanceof AST_For && p.condition === self || p instanceof AST_UnaryPrefix && p.operator == "!" && p.expression === self) {
+ return true;
+ }
+ if (!(p instanceof AST_Binary && (p.operator == "&&" || p.operator == "||"))) return false;
+ self = p;
+ }
+ },
+ loopcontrol_target: function(label) {
+ var stack = this.stack;
+ if (label) {
+ for (var i = stack.length; --i >= 0; ) {
+ var x = stack[i];
+ if (x instanceof AST_LabeledStatement && x.label.name == label.name) {
+ return x.body;
+ }
+ }
+ } else {
+ for (var i = stack.length; --i >= 0; ) {
+ var x = stack[i];
+ if (x instanceof AST_Switch || x instanceof AST_For || x instanceof AST_ForIn || x instanceof AST_DWLoop) return x;
+ }
+ }
+ }
+ };
+ "use strict";
+ var KEYWORDS = "break case catch const continue debugger default delete do else finally for function if in instanceof new return switch throw try typeof var void while with";
+ var KEYWORDS_ATOM = "false null true";
+ var RESERVED_WORDS = "abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized this throws transient volatile" + " " + KEYWORDS_ATOM + " " + KEYWORDS;
+ var KEYWORDS_BEFORE_EXPRESSION = "return new delete throw else case";
+ KEYWORDS = makePredicate(KEYWORDS);
+ RESERVED_WORDS = makePredicate(RESERVED_WORDS);
+ KEYWORDS_BEFORE_EXPRESSION = makePredicate(KEYWORDS_BEFORE_EXPRESSION);
+ KEYWORDS_ATOM = makePredicate(KEYWORDS_ATOM);
+ var OPERATOR_CHARS = makePredicate(characters("+-*&%=<>!?|~^"));
+ var RE_HEX_NUMBER = /^0x[0-9a-f]+$/i;
+ var RE_OCT_NUMBER = /^0[0-7]+$/;
+ var RE_DEC_NUMBER = /^\d*\.?\d*(?:e[+-]?\d*(?:\d\.?|\.?\d)\d*)?$/i;
+ var OPERATORS = makePredicate([ "in", "instanceof", "typeof", "new", "void", "delete", "++", "--", "+", "-", "!", "~", "&", "|", "^", "*", "/", "%", ">>", "<<", ">>>", "<", ">", "<=", ">=", "==", "===", "!=", "!==", "?", "=", "+=", "-=", "/=", "*=", "%=", ">>=", "<<=", ">>>=", "|=", "^=", "&=", "&&", "||" ]);
+ var WHITESPACE_CHARS = makePredicate(characters(" \u00a0\n\r\t\f\u000b\u200b\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000"));
+ var PUNC_BEFORE_EXPRESSION = makePredicate(characters("[{(,.;:"));
+ var PUNC_CHARS = makePredicate(characters("[]{}(),;:"));
+ var REGEXP_MODIFIERS = makePredicate(characters("gmsiy"));
+ 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_letter(code) {
+ return code >= 97 && code <= 122 || code >= 65 && code <= 90 || code >= 170 && UNICODE.letter.test(String.fromCharCode(code));
+ }
+ function is_digit(code) {
+ return code >= 48 && code <= 57;
+ }
+ function is_alphanumeric_char(code) {
+ return is_digit(code) || is_letter(code);
+ }
+ function is_unicode_combining_mark(ch) {
+ return UNICODE.non_spacing_mark.test(ch) || UNICODE.space_combining_mark.test(ch);
+ }
+ function is_unicode_connector_punctuation(ch) {
+ return UNICODE.connector_punctuation.test(ch);
+ }
+ function is_identifier(name) {
+ return !RESERVED_WORDS(name) && /^[a-z_$][a-z0-9_$]*$/i.test(name);
+ }
+ function is_identifier_start(code) {
+ return code == 36 || code == 95 || is_letter(code);
+ }
+ function is_identifier_char(ch) {
+ var code = ch.charCodeAt(0);
+ return is_identifier_start(code) || is_digit(code) || code == 8204 || code == 8205 || is_unicode_combining_mark(ch) || is_unicode_connector_punctuation(ch);
+ }
+ function is_identifier_string(str) {
+ var i = str.length;
+ if (i == 0) return false;
+ if (is_digit(str.charCodeAt(0))) return false;
+ while (--i >= 0) {
+ if (!is_identifier_char(str.charAt(i))) return false;
+ }
+ return true;
+ }
+ function parse_js_number(num) {
+ if (RE_HEX_NUMBER.test(num)) {
+ return parseInt(num.substr(2), 16);
+ } else if (RE_OCT_NUMBER.test(num)) {
+ return parseInt(num.substr(1), 8);
+ } else if (RE_DEC_NUMBER.test(num)) {
+ return parseFloat(num);
+ }
+ }
+ function JS_Parse_Error(message, line, col, pos) {
+ this.message = message;
+ this.line = line;
+ this.col = col;
+ this.pos = pos;
+ this.stack = new Error().stack;
+ }
+ JS_Parse_Error.prototype.toString = function() {
+ return this.message + " (line: " + this.line + ", col: " + this.col + ", pos: " + this.pos + ")" + "\n\n" + this.stack;
+ };
+ function js_error(message, filename, line, col, pos) {
+ throw new JS_Parse_Error(message, line, col, pos);
+ }
+ function is_token(token, type, val) {
+ return token.type == type && (val == null || token.value == val);
+ }
+ var EX_EOF = {};
+ function tokenizer($TEXT, filename) {
+ var S = {
+ text: $TEXT.replace(/\r\n?|[\n\u2028\u2029]/g, "\n").replace(/\uFEFF/g, ""),
+ filename: filename,
+ pos: 0,
+ tokpos: 0,
+ line: 1,
+ tokline: 0,
+ col: 0,
+ tokcol: 0,
+ newline_before: false,
+ regex_allowed: false,
+ comments_before: []
+ };
+ function peek() {
+ return S.text.charAt(S.pos);
+ }
+ function next(signal_eof, in_string) {
+ var ch = S.text.charAt(S.pos++);
+ if (signal_eof && !ch) throw EX_EOF;
+ if (ch == "\n") {
+ S.newline_before = S.newline_before || !in_string;
+ ++S.line;
+ S.col = 0;
+ } else {
+ ++S.col;
+ }
+ return ch;
+ }
+ function find(what, signal_eof) {
+ var pos = S.text.indexOf(what, S.pos);
+ if (signal_eof && pos == -1) throw EX_EOF;
+ return pos;
+ }
+ function start_token() {
+ S.tokline = S.line;
+ S.tokcol = S.col;
+ S.tokpos = S.pos;
+ }
+ function token(type, value, is_comment) {
+ S.regex_allowed = type == "operator" && !UNARY_POSTFIX[value] || type == "keyword" && KEYWORDS_BEFORE_EXPRESSION(value) || type == "punc" && PUNC_BEFORE_EXPRESSION(value);
+ var ret = {
+ type: type,
+ value: value,
+ line: S.tokline,
+ col: S.tokcol,
+ pos: S.tokpos,
+ endpos: S.pos,
+ nlb: S.newline_before,
+ file: filename
+ };
+ if (!is_comment) {
+ ret.comments_before = S.comments_before;
+ S.comments_before = [];
+ for (var i = 0, len = ret.comments_before.length; i < len; i++) {
+ ret.nlb = ret.nlb || ret.comments_before[i].nlb;
+ }
+ }
+ S.newline_before = false;
+ return new AST_Token(ret);
+ }
+ function skip_whitespace() {
+ while (WHITESPACE_CHARS(peek())) next();
+ }
+ function read_while(pred) {
+ var ret = "", ch, i = 0;
+ while ((ch = peek()) && pred(ch, i++)) ret += next();
+ return ret;
+ }
+ function parse_error(err) {
+ js_error(err, filename, S.tokline, S.tokcol, S.tokpos);
+ }
+ function read_num(prefix) {
+ var has_e = false, after_e = false, has_x = false, has_dot = prefix == ".";
+ var num = read_while(function(ch, i) {
+ var code = ch.charCodeAt(0);
+ switch (code) {
+ case 120:
+ case 88:
+ return has_x ? false : has_x = true;
+
+ case 101:
+ case 69:
+ return has_x ? true : has_e ? false : has_e = after_e = true;
+
+ case 45:
+ return after_e || i == 0 && !prefix;
+
+ case 43:
+ return after_e;
+
+ case after_e = false, 46:
+ return !has_dot && !has_x && !has_e ? has_dot = true : false;
+ }
+ return is_alphanumeric_char(code);
+ });
+ if (prefix) num = prefix + num;
+ var valid = parse_js_number(num);
+ if (!isNaN(valid)) {
+ return token("num", valid);
+ } else {
+ parse_error("Invalid syntax: " + num);
+ }
+ }
+ function read_escaped_char(in_string) {
+ var ch = next(true, in_string);
+ switch (ch.charCodeAt(0)) {
+ case 110:
+ return "\n";
+
+ case 114:
+ return "\r";
+
+ case 116:
+ return " ";
+
+ case 98:
+ return "\b";
+
+ case 118:
+ return " ";
+
+ case 102:
+ return "\f";
+
+ case 48:
+ return "\0";
+
+ case 120:
+ return String.fromCharCode(hex_bytes(2));
+
+ case 117:
+ return String.fromCharCode(hex_bytes(4));
+
+ case 10:
+ return "";
+
+ default:
+ return ch;
+ }
+ }
+ function hex_bytes(n) {
+ var num = 0;
+ for (;n > 0; --n) {
+ var digit = parseInt(next(true), 16);
+ if (isNaN(digit)) parse_error("Invalid hex-character pattern in string");
+ num = num << 4 | digit;
+ }
+ return num;
+ }
+ var read_string = with_eof_error("Unterminated string constant", function() {
+ var quote = next(), ret = "";
+ for (;;) {
+ var ch = next(true);
+ if (ch == "\\") {
+ var octal_len = 0, first = null;
+ ch = read_while(function(ch) {
+ if (ch >= "0" && ch <= "7") {
+ if (!first) {
+ first = ch;
+ return ++octal_len;
+ } else if (first <= "3" && octal_len <= 2) return ++octal_len; else if (first >= "4" && octal_len <= 1) return ++octal_len;
+ }
+ return false;
+ });
+ if (octal_len > 0) ch = String.fromCharCode(parseInt(ch, 8)); else ch = read_escaped_char(true);
+ } else if (ch == quote) break;
+ ret += ch;
+ }
+ return token("string", ret);
+ });
+ function read_line_comment() {
+ next();
+ var i = find("\n"), ret;
+ if (i == -1) {
+ ret = S.text.substr(S.pos);
+ S.pos = S.text.length;
+ } else {
+ ret = S.text.substring(S.pos, i);
+ S.pos = i;
+ }
+ return token("comment1", ret, true);
+ }
+ var read_multiline_comment = with_eof_error("Unterminated multiline comment", function() {
+ next();
+ var i = find("*/", true);
+ var text = S.text.substring(S.pos, i);
+ var a = text.split("\n"), n = a.length;
+ S.pos = i + 2;
+ S.line += n - 1;
+ if (n > 1) S.col = a[n - 1].length; else S.col += a[n - 1].length;
+ S.col += 2;
+ S.newline_before = S.newline_before || text.indexOf("\n") >= 0;
+ return token("comment2", text, true);
+ });
+ function read_name() {
+ var backslash = false, name = "", ch, escaped = false, hex;
+ while ((ch = peek()) != null) {
+ if (!backslash) {
+ if (ch == "\\") escaped = backslash = true, next(); else if (is_identifier_char(ch)) name += next(); else break;
+ } else {
+ if (ch != "u") parse_error("Expecting UnicodeEscapeSequence -- uXXXX");
+ ch = read_escaped_char();
+ if (!is_identifier_char(ch)) parse_error("Unicode char: " + ch.charCodeAt(0) + " is not valid in identifier");
+ name += ch;
+ backslash = false;
+ }
+ }
+ if (KEYWORDS(name) && escaped) {
+ hex = name.charCodeAt(0).toString(16).toUpperCase();
+ name = "\\u" + "0000".substr(hex.length) + hex + name.slice(1);
+ }
+ return name;
+ }
+ var read_regexp = with_eof_error("Unterminated regular expression", function(regexp) {
+ var prev_backslash = false, ch, in_class = false;
+ while (ch = next(true)) if (prev_backslash) {
+ regexp += "\\" + ch;
+ prev_backslash = false;
+ } else if (ch == "[") {
+ in_class = true;
+ regexp += ch;
+ } else if (ch == "]" && in_class) {
+ in_class = false;
+ regexp += ch;
+ } else if (ch == "/" && !in_class) {
+ break;
+ } else if (ch == "\\") {
+ prev_backslash = true;
+ } else {
+ regexp += ch;
+ }
+ var mods = read_name();
+ return token("regexp", new RegExp(regexp, mods));
+ });
+ function read_operator(prefix) {
+ function grow(op) {
+ if (!peek()) return op;
+ var bigger = op + peek();
+ if (OPERATORS(bigger)) {
+ next();
+ return grow(bigger);
+ } else {
+ return op;
+ }
+ }
+ return token("operator", grow(prefix || next()));
+ }
+ function handle_slash() {
+ next();
+ var regex_allowed = S.regex_allowed;
+ switch (peek()) {
+ case "/":
+ S.comments_before.push(read_line_comment());
+ S.regex_allowed = regex_allowed;
+ return next_token();
+
+ case "*":
+ S.comments_before.push(read_multiline_comment());
+ S.regex_allowed = regex_allowed;
+ return next_token();
+ }
+ return S.regex_allowed ? read_regexp("") : read_operator("/");
+ }
+ function handle_dot() {
+ next();
+ return is_digit(peek().charCodeAt(0)) ? read_num(".") : token("punc", ".");
+ }
+ function read_word() {
+ var word = read_name();
+ return KEYWORDS_ATOM(word) ? token("atom", word) : !KEYWORDS(word) ? token("name", word) : OPERATORS(word) ? token("operator", word) : token("keyword", word);
+ }
+ function with_eof_error(eof_error, cont) {
+ return function(x) {
+ try {
+ return cont(x);
+ } catch (ex) {
+ if (ex === EX_EOF) parse_error(eof_error); else throw ex;
+ }
+ };
+ }
+ function next_token(force_regexp) {
+ if (force_regexp != null) return read_regexp(force_regexp);
+ skip_whitespace();
+ start_token();
+ var ch = peek();
+ if (!ch) return token("eof");
+ var code = ch.charCodeAt(0);
+ switch (code) {
+ case 34:
+ case 39:
+ return read_string();
+
+ case 46:
+ return handle_dot();
+
+ case 47:
+ return handle_slash();
+ }
+ if (is_digit(code)) return read_num();
+ if (PUNC_CHARS(ch)) return token("punc", next());
+ if (OPERATOR_CHARS(ch)) return read_operator();
+ if (code == 92 || is_identifier_start(code)) return read_word();
+ parse_error("Unexpected character '" + ch + "'");
+ }
+ next_token.context = function(nc) {
+ if (nc) S = nc;
+ return S;
+ };
+ return next_token;
+ }
+ var UNARY_PREFIX = makePredicate([ "typeof", "void", "delete", "--", "++", "!", "~", "-", "+" ]);
+ var UNARY_POSTFIX = makePredicate([ "--", "++" ]);
+ var ASSIGNMENT = makePredicate([ "=", "+=", "-=", "/=", "*=", "%=", ">>=", "<<=", ">>>=", "|=", "^=", "&=" ]);
+ var PRECEDENCE = function(a, ret) {
+ for (var i = 0, n = 1; i < a.length; ++i, ++n) {
+ var b = a[i];
+ for (var j = 0; j < b.length; ++j) {
+ ret[b[j]] = n;
+ }
+ }
+ return ret;
+ }([ [ "||" ], [ "&&" ], [ "|" ], [ "^" ], [ "&" ], [ "==", "===", "!=", "!==" ], [ "<", ">", "<=", ">=", "in", "instanceof" ], [ ">>", "<<", ">>>" ], [ "+", "-" ], [ "*", "/", "%" ] ], {});
+ var STATEMENTS_WITH_LABELS = array_to_hash([ "for", "do", "while", "switch" ]);
+ var ATOMIC_START_TOKEN = array_to_hash([ "atom", "num", "string", "regexp", "name" ]);
+ function parse($TEXT, options) {
+ options = defaults(options, {
+ strict: false,
+ filename: null,
+ toplevel: null,
+ expression: false
+ });
+ var S = {
+ input: typeof $TEXT == "string" ? tokenizer($TEXT, options.filename) : $TEXT,
+ token: null,
+ prev: null,
+ peeked: null,
+ in_function: 0,
+ in_directives: true,
+ in_loop: 0,
+ labels: []
+ };
+ S.token = next();
+ function is(type, value) {
+ return is_token(S.token, type, value);
+ }
+ function peek() {
+ return S.peeked || (S.peeked = S.input());
+ }
+ function next() {
+ S.prev = S.token;
+ if (S.peeked) {
+ S.token = S.peeked;
+ S.peeked = null;
+ } else {
+ S.token = S.input();
+ }
+ S.in_directives = S.in_directives && (S.token.type == "string" || is("punc", ";"));
+ return S.token;
+ }
+ function prev() {
+ return S.prev;
+ }
+ function croak(msg, line, col, pos) {
+ var ctx = S.input.context();
+ js_error(msg, ctx.filename, line != null ? line : ctx.tokline, col != null ? col : ctx.tokcol, pos != null ? pos : ctx.tokpos);
+ }
+ function token_error(token, msg) {
+ croak(msg, token.line, token.col);
+ }
+ function unexpected(token) {
+ if (token == null) token = S.token;
+ token_error(token, "Unexpected token: " + token.type + " (" + token.value + ")");
+ }
+ function expect_token(type, val) {
+ if (is(type, val)) {
+ return next();
+ }
+ token_error(S.token, "Unexpected token " + S.token.type + " «" + S.token.value + "»" + ", expected " + type + " «" + val + "»");
+ }
+ function expect(punc) {
+ return expect_token("punc", punc);
+ }
+ function can_insert_semicolon() {
+ return !options.strict && (S.token.nlb || is("eof") || is("punc", "}"));
+ }
+ function semicolon() {
+ if (is("punc", ";")) next(); else if (!can_insert_semicolon()) unexpected();
+ }
+ function parenthesised() {
+ expect("(");
+ var exp = expression(true);
+ expect(")");
+ return exp;
+ }
+ function embed_tokens(parser) {
+ return function() {
+ var start = S.token;
+ var expr = parser();
+ var end = prev();
+ expr.start = start;
+ expr.end = end;
+ return expr;
+ };
+ }
+ var statement = embed_tokens(function() {
+ var tmp;
+ if (is("operator", "/") || is("operator", "/=")) {
+ S.peeked = null;
+ S.token = S.input(S.token.value.substr(1));
+ }
+ switch (S.token.type) {
+ case "string":
+ var dir = S.in_directives, stat = simple_statement();
+ if (dir && stat.body instanceof AST_String && !is("punc", ",")) return new AST_Directive({
+ value: stat.body.value
+ });
+ return stat;
+
+ case "num":
+ case "regexp":
+ case "operator":
+ case "atom":
+ return simple_statement();
+
+ case "name":
+ return is_token(peek(), "punc", ":") ? labeled_statement() : simple_statement();
+
+ case "punc":
+ switch (S.token.value) {
+ case "{":
+ return new AST_BlockStatement({
+ start: S.token,
+ body: block_(),
+ end: prev()
+ });
+
+ case "[":
+ case "(":
+ return simple_statement();
+
+ case ";":
+ next();
+ return new AST_EmptyStatement();
+
+ default:
+ unexpected();
+ }
+
+ case "keyword":
+ switch (tmp = S.token.value, next(), tmp) {
+ case "break":
+ return break_cont(AST_Break);
+
+ case "continue":
+ return break_cont(AST_Continue);
+
+ case "debugger":
+ semicolon();
+ return new AST_Debugger();
+
+ case "do":
+ return new AST_Do({
+ body: in_loop(statement),
+ condition: (expect_token("keyword", "while"), tmp = parenthesised(), semicolon(),
+ tmp)
+ });
+
+ case "while":
+ return new AST_While({
+ condition: parenthesised(),
+ body: in_loop(statement)
+ });
+
+ 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 new AST_Return({
+ value: is("punc", ";") ? (next(), null) : can_insert_semicolon() ? null : (tmp = expression(true),
+ semicolon(), tmp)
+ });
+
+ case "switch":
+ return new AST_Switch({
+ expression: parenthesised(),
+ body: in_loop(switch_body_)
+ });
+
+ case "throw":
+ if (S.token.nlb) croak("Illegal newline after 'throw'");
+ return new AST_Throw({
+ value: (tmp = expression(true), semicolon(), tmp)
+ });
+
+ case "try":
+ return try_();
+
+ case "var":
+ return tmp = var_(), semicolon(), tmp;
+
+ case "const":
+ return tmp = const_(), semicolon(), tmp;
+
+ case "with":
+ return new AST_With({
+ expression: parenthesised(),
+ body: statement()
+ });
+
+ default:
+ unexpected();
+ }
+ }
+ });
+ function labeled_statement() {
+ var label = as_symbol(AST_Label);
+ if (find_if(function(l) {
+ return l.name == label.name;
+ }, S.labels)) {
+ croak("Label " + label.name + " defined twice");
+ }
+ expect(":");
+ S.labels.push(label);
+ var stat = statement();
+ S.labels.pop();
+ return new AST_LabeledStatement({
+ body: stat,
+ label: label
+ });
+ }
+ function simple_statement(tmp) {
+ return new AST_SimpleStatement({
+ body: (tmp = expression(true), semicolon(), tmp)
+ });
+ }
+ function break_cont(type) {
+ var label = null;
+ if (!can_insert_semicolon()) {
+ label = as_symbol(AST_LabelRef, true);
+ }
+ if (label != null) {
+ if (!find_if(function(l) {
+ return l.name == label.name;
+ }, S.labels)) croak("Undefined label " + label.name);
+ } else if (S.in_loop == 0) croak(type.TYPE + " not inside a loop or switch");
+ semicolon();
+ return new type({
+ label: label
+ });
+ }
+ function for_() {
+ expect("(");
+ var init = null;
+ if (!is("punc", ";")) {
+ init = is("keyword", "var") ? (next(), var_(true)) : expression(true, true);
+ if (is("operator", "in")) {
+ if (init instanceof AST_Var && init.definitions.length > 1) croak("Only one variable declaration allowed in for..in loop");
+ next();
+ return for_in(init);
+ }
+ }
+ return regular_for(init);
+ }
+ function regular_for(init) {
+ expect(";");
+ var test = is("punc", ";") ? null : expression(true);
+ expect(";");
+ var step = is("punc", ")") ? null : expression(true);
+ expect(")");
+ return new AST_For({
+ init: init,
+ condition: test,
+ step: step,
+ body: in_loop(statement)
+ });
+ }
+ function for_in(init) {
+ var lhs = init instanceof AST_Var ? init.definitions[0].name : null;
+ var obj = expression(true);
+ expect(")");
+ return new AST_ForIn({
+ init: init,
+ name: lhs,
+ object: obj,
+ body: in_loop(statement)
+ });
+ }
+ var function_ = function(in_statement, ctor) {
+ var is_accessor = ctor === AST_Accessor;
+ var name = is("name") ? as_symbol(in_statement ? AST_SymbolDefun : is_accessor ? AST_SymbolAccessor : AST_SymbolLambda) : is_accessor && (is("string") || is("num")) ? as_atom_node() : null;
+ if (in_statement && !name) unexpected();
+ expect("(");
+ if (!ctor) ctor = in_statement ? AST_Defun : AST_Function;
+ return new ctor({
+ name: name,
+ argnames: function(first, a) {
+ while (!is("punc", ")")) {
+ if (first) first = false; else expect(",");
+ a.push(as_symbol(AST_SymbolFunarg));
+ }
+ next();
+ return a;
+ }(true, []),
+ body: function(loop, labels) {
+ ++S.in_function;
+ S.in_directives = true;
+ S.in_loop = 0;
+ S.labels = [];
+ var a = block_();
+ --S.in_function;
+ S.in_loop = loop;
+ S.labels = labels;
+ return a;
+ }(S.in_loop, S.labels)
+ });
+ };
+ function if_() {
+ var cond = parenthesised(), body = statement(), belse = null;
+ if (is("keyword", "else")) {
+ next();
+ belse = statement();
+ }
+ return new AST_If({
+ condition: cond,
+ body: body,
+ alternative: belse
+ });
+ }
+ function block_() {
+ expect("{");
+ var a = [];
+ while (!is("punc", "}")) {
+ if (is("eof")) unexpected();
+ a.push(statement());
+ }
+ next();
+ return a;
+ }
+ function switch_body_() {
+ expect("{");
+ var a = [], cur = null, branch = null, tmp;
+ while (!is("punc", "}")) {
+ if (is("eof")) unexpected();
+ if (is("keyword", "case")) {
+ if (branch) branch.end = prev();
+ cur = [];
+ branch = new AST_Case({
+ start: (tmp = S.token, next(), tmp),
+ expression: expression(true),
+ body: cur
+ });
+ a.push(branch);
+ expect(":");
+ } else if (is("keyword", "default")) {
+ if (branch) branch.end = prev();
+ cur = [];
+ branch = new AST_Default({
+ start: (tmp = S.token, next(), expect(":"), tmp),
+ body: cur
+ });
+ a.push(branch);
+ } else {
+ if (!cur) unexpected();
+ cur.push(statement());
+ }
+ }
+ if (branch) branch.end = prev();
+ next();
+ return a;
+ }
+ function try_() {
+ var body = block_(), bcatch = null, bfinally = null;
+ if (is("keyword", "catch")) {
+ var start = S.token;
+ next();
+ expect("(");
+ var name = as_symbol(AST_SymbolCatch);
+ expect(")");
+ bcatch = new AST_Catch({
+ start: start,
+ argname: name,
+ body: block_(),
+ end: prev()
+ });
+ }
+ if (is("keyword", "finally")) {
+ var start = S.token;
+ next();
+ bfinally = new AST_Finally({
+ start: start,
+ body: block_(),
+ end: prev()
+ });
+ }
+ if (!bcatch && !bfinally) croak("Missing catch/finally blocks");
+ return new AST_Try({
+ body: body,
+ bcatch: bcatch,
+ bfinally: bfinally
+ });
+ }
+ function vardefs(no_in, in_const) {
+ var a = [];
+ for (;;) {
+ a.push(new AST_VarDef({
+ start: S.token,
+ name: as_symbol(in_const ? AST_SymbolConst : AST_SymbolVar),
+ value: is("operator", "=") ? (next(), expression(false, no_in)) : null,
+ end: prev()
+ }));
+ if (!is("punc", ",")) break;
+ next();
+ }
+ return a;
+ }
+ var var_ = function(no_in) {
+ return new AST_Var({
+ start: prev(),
+ definitions: vardefs(no_in, false),
+ end: prev()
+ });
+ };
+ var const_ = function() {
+ return new AST_Const({
+ start: prev(),
+ definitions: vardefs(false, true),
+ end: prev()
+ });
+ };
+ var new_ = function() {
+ var start = S.token;
+ expect_token("operator", "new");
+ var newexp = expr_atom(false), args;
+ if (is("punc", "(")) {
+ next();
+ args = expr_list(")");
+ } else {
+ args = [];
+ }
+ return subscripts(new AST_New({
+ start: start,
+ expression: newexp,
+ args: args,
+ end: prev()
+ }), true);
+ };
+ function as_atom_node() {
+ var tok = S.token, ret;
+ switch (tok.type) {
+ case "name":
+ return as_symbol(AST_SymbolRef);
+
+ case "num":
+ ret = new AST_Number({
+ start: tok,
+ end: tok,
+ value: tok.value
+ });
+ break;
+
+ case "string":
+ ret = new AST_String({
+ start: tok,
+ end: tok,
+ value: tok.value
+ });
+ break;
+
+ case "regexp":
+ ret = new AST_RegExp({
+ start: tok,
+ end: tok,
+ value: tok.value
+ });
+ break;
+
+ case "atom":
+ switch (tok.value) {
+ case "false":
+ ret = new AST_False({
+ start: tok,
+ end: tok
+ });
+ break;
+
+ case "true":
+ ret = new AST_True({
+ start: tok,
+ end: tok
+ });
+ break;
+
+ case "null":
+ ret = new AST_Null({
+ start: tok,
+ end: tok
+ });
+ break;
+ }
+ break;
+ }
+ next();
+ return ret;
+ }
+ var expr_atom = function(allow_calls) {
+ if (is("operator", "new")) {
+ return new_();
+ }
+ var start = S.token;
+ if (is("punc")) {
+ switch (start.value) {
+ case "(":
+ next();
+ var ex = expression(true);
+ ex.start = start;
+ ex.end = S.token;
+ expect(")");
+ return subscripts(ex, allow_calls);
+
+ case "[":
+ return subscripts(array_(), allow_calls);
+
+ case "{":
+ return subscripts(object_(), allow_calls);
+ }
+ unexpected();
+ }
+ if (is("keyword", "function")) {
+ next();
+ var func = function_(false);
+ func.start = start;
+ func.end = prev();
+ return subscripts(func, allow_calls);
+ }
+ if (ATOMIC_START_TOKEN[S.token.type]) {
+ return subscripts(as_atom_node(), allow_calls);
+ }
+ unexpected();
+ };
+ function expr_list(closing, allow_trailing_comma, allow_empty) {
+ var first = true, a = [];
+ while (!is("punc", closing)) {
+ if (first) first = false; else expect(",");
+ if (allow_trailing_comma && is("punc", closing)) break;
+ if (is("punc", ",") && allow_empty) {
+ a.push(new AST_Hole({
+ start: S.token,
+ end: S.token
+ }));
+ } else {
+ a.push(expression(false));
+ }
+ }
+ next();
+ return a;
+ }
+ var array_ = embed_tokens(function() {
+ expect("[");
+ return new AST_Array({
+ elements: expr_list("]", !options.strict, true)
+ });
+ });
+ var object_ = embed_tokens(function() {
+ expect("{");
+ var first = true, a = [];
+ while (!is("punc", "}")) {
+ if (first) first = false; else expect(",");
+ if (!options.strict && is("punc", "}")) break;
+ var start = S.token;
+ var type = start.type;
+ var name = as_property_name();
+ if (type == "name" && !is("punc", ":")) {
+ if (name == "get") {
+ a.push(new AST_ObjectGetter({
+ start: start,
+ key: name,
+ value: function_(false, AST_Accessor),
+ end: prev()
+ }));
+ continue;
+ }
+ if (name == "set") {
+ a.push(new AST_ObjectSetter({
+ start: start,
+ key: name,
+ value: function_(false, AST_Accessor),
+ end: prev()
+ }));
+ continue;
+ }
+ }
+ expect(":");
+ a.push(new AST_ObjectKeyVal({
+ start: start,
+ key: name,
+ value: expression(false),
+ end: prev()
+ }));
+ }
+ next();
+ return new AST_Object({
+ properties: a
+ });
+ });
+ function as_property_name() {
+ var tmp = S.token;
+ next();
+ switch (tmp.type) {
+ case "num":
+ case "string":
+ case "name":
+ case "operator":
+ case "keyword":
+ case "atom":
+ return tmp.value;
+
+ default:
+ unexpected();
+ }
+ }
+ function as_name() {
+ var tmp = S.token;
+ next();
+ switch (tmp.type) {
+ case "name":
+ case "operator":
+ case "keyword":
+ case "atom":
+ return tmp.value;
+
+ default:
+ unexpected();
+ }
+ }
+ function as_symbol(type, noerror) {
+ if (!is("name")) {
+ if (!noerror) croak("Name expected");
+ return null;
+ }
+ var name = S.token.value;
+ var sym = new (name == "this" ? AST_This : type)({
+ name: String(S.token.value),
+ start: S.token,
+ end: S.token
+ });
+ next();
+ return sym;
+ }
+ var subscripts = function(expr, allow_calls) {
+ var start = expr.start;
+ if (is("punc", ".")) {
+ next();
+ return subscripts(new AST_Dot({
+ start: start,
+ expression: expr,
+ property: as_name(),
+ end: prev()
+ }), allow_calls);
+ }
+ if (is("punc", "[")) {
+ next();
+ var prop = expression(true);
+ expect("]");
+ return subscripts(new AST_Sub({
+ start: start,
+ expression: expr,
+ property: prop,
+ end: prev()
+ }), allow_calls);
+ }
+ if (allow_calls && is("punc", "(")) {
+ next();
+ return subscripts(new AST_Call({
+ start: start,
+ expression: expr,
+ args: expr_list(")"),
+ end: prev()
+ }), true);
+ }
+ return expr;
+ };
+ var maybe_unary = function(allow_calls) {
+ var start = S.token;
+ if (is("operator") && UNARY_PREFIX(start.value)) {
+ next();
+ var ex = make_unary(AST_UnaryPrefix, start.value, maybe_unary(allow_calls));
+ ex.start = start;
+ ex.end = prev();
+ return ex;
+ }
+ var val = expr_atom(allow_calls);
+ while (is("operator") && UNARY_POSTFIX(S.token.value) && !S.token.nlb) {
+ val = make_unary(AST_UnaryPostfix, S.token.value, val);
+ val.start = start;
+ val.end = S.token;
+ next();
+ }
+ return val;
+ };
+ function make_unary(ctor, op, expr) {
+ if ((op == "++" || op == "--") && !is_assignable(expr)) croak("Invalid use of " + op + " operator");
+ return new ctor({
+ operator: op,
+ expression: expr
+ });
+ }
+ var expr_op = function(left, min_prec, no_in) {
+ var op = is("operator") ? S.token.value : null;
+ if (op == "in" && no_in) op = null;
+ var prec = op != null ? PRECEDENCE[op] : null;
+ if (prec != null && prec > min_prec) {
+ next();
+ var right = expr_op(maybe_unary(true), prec, no_in);
+ return expr_op(new AST_Binary({
+ start: left.start,
+ left: left,
+ operator: op,
+ right: right,
+ end: right.end
+ }), min_prec, no_in);
+ }
+ return left;
+ };
+ function expr_ops(no_in) {
+ return expr_op(maybe_unary(true), 0, no_in);
+ }
+ var maybe_conditional = function(no_in) {
+ var start = S.token;
+ var expr = expr_ops(no_in);
+ if (is("operator", "?")) {
+ next();
+ var yes = expression(false);
+ expect(":");
+ return new AST_Conditional({
+ start: start,
+ condition: expr,
+ consequent: yes,
+ alternative: expression(false, no_in),
+ end: peek()
+ });
+ }
+ return expr;
+ };
+ function is_assignable(expr) {
+ if (!options.strict) return true;
+ if (expr instanceof AST_This) return false;
+ return expr instanceof AST_PropAccess || expr instanceof AST_Symbol;
+ }
+ var maybe_assign = function(no_in) {
+ var start = S.token;
+ var left = maybe_conditional(no_in), val = S.token.value;
+ if (is("operator") && ASSIGNMENT(val)) {
+ if (is_assignable(left)) {
+ next();
+ return new AST_Assign({
+ start: start,
+ left: left,
+ operator: val,
+ right: maybe_assign(no_in),
+ end: prev()
+ });
+ }
+ croak("Invalid assignment");
+ }
+ return left;
+ };
+ var expression = function(commas, no_in) {
+ var start = S.token;
+ var expr = maybe_assign(no_in);
+ if (commas && is("punc", ",")) {
+ next();
+ return new AST_Seq({
+ start: start,
+ car: expr,
+ cdr: expression(true, no_in),
+ end: peek()
+ });
+ }
+ return expr;
+ };
+ function in_loop(cont) {
+ ++S.in_loop;
+ var ret = cont();
+ --S.in_loop;
+ return ret;
+ }
+ if (options.expression) {
+ return expression(true);
+ }
+ return function() {
+ var start = S.token;
+ var body = [];
+ while (!is("eof")) body.push(statement());
+ var end = prev();
+ var toplevel = options.toplevel;
+ if (toplevel) {
+ toplevel.body = toplevel.body.concat(body);
+ toplevel.end = end;
+ } else {
+ toplevel = new AST_Toplevel({
+ start: start,
+ body: body,
+ end: end
+ });
+ }
+ return toplevel;
+ }();
+ }
+ "use strict";
+ function TreeTransformer(before, after) {
+ TreeWalker.call(this);
+ this.before = before;
+ this.after = after;
+ }
+ TreeTransformer.prototype = new TreeWalker();
+ (function(undefined) {
+ function _(node, descend) {
+ node.DEFMETHOD("transform", function(tw, in_list) {
+ var x, y;
+ tw.push(this);
+ if (tw.before) x = tw.before(this, descend, in_list);
+ if (x === undefined) {
+ if (!tw.after) {
+ x = this;
+ descend(x, tw);
+ } else {
+ tw.stack[tw.stack.length - 1] = x = this.clone();
+ descend(x, tw);
+ y = tw.after(x, in_list);
+ if (y !== undefined) x = y;
+ }
+ }
+ tw.pop();
+ return x;
+ });
+ }
+ function do_list(list, tw) {
+ return MAP(list, function(node) {
+ return node.transform(tw, true);
+ });
+ }
+ _(AST_Node, noop);
+ _(AST_LabeledStatement, function(self, tw) {
+ self.label = self.label.transform(tw);
+ self.body = self.body.transform(tw);
+ });
+ _(AST_SimpleStatement, function(self, tw) {
+ self.body = self.body.transform(tw);
+ });
+ _(AST_Block, function(self, tw) {
+ self.body = do_list(self.body, tw);
+ });
+ _(AST_DWLoop, function(self, tw) {
+ self.condition = self.condition.transform(tw);
+ self.body = self.body.transform(tw);
+ });
+ _(AST_For, function(self, tw) {
+ if (self.init) self.init = self.init.transform(tw);
+ if (self.condition) self.condition = self.condition.transform(tw);
+ if (self.step) self.step = self.step.transform(tw);
+ self.body = self.body.transform(tw);
+ });
+ _(AST_ForIn, function(self, tw) {
+ self.init = self.init.transform(tw);
+ self.object = self.object.transform(tw);
+ self.body = self.body.transform(tw);
+ });
+ _(AST_With, function(self, tw) {
+ self.expression = self.expression.transform(tw);
+ self.body = self.body.transform(tw);
+ });
+ _(AST_Exit, function(self, tw) {
+ if (self.value) self.value = self.value.transform(tw);
+ });
+ _(AST_LoopControl, function(self, tw) {
+ if (self.label) self.label = self.label.transform(tw);
+ });
+ _(AST_If, function(self, tw) {
+ self.condition = self.condition.transform(tw);
+ self.body = self.body.transform(tw);
+ if (self.alternative) self.alternative = self.alternative.transform(tw);
+ });
+ _(AST_Switch, function(self, tw) {
+ self.expression = self.expression.transform(tw);
+ self.body = do_list(self.body, tw);
+ });
+ _(AST_Case, function(self, tw) {
+ self.expression = self.expression.transform(tw);
+ self.body = do_list(self.body, tw);
+ });
+ _(AST_Try, function(self, tw) {
+ self.body = do_list(self.body, tw);
+ if (self.bcatch) self.bcatch = self.bcatch.transform(tw);
+ if (self.bfinally) self.bfinally = self.bfinally.transform(tw);
+ });
+ _(AST_Catch, function(self, tw) {
+ self.argname = self.argname.transform(tw);
+ self.body = do_list(self.body, tw);
+ });
+ _(AST_Definitions, function(self, tw) {
+ self.definitions = do_list(self.definitions, tw);
+ });
+ _(AST_VarDef, function(self, tw) {
+ if (self.value) self.value = self.value.transform(tw);
+ });
+ _(AST_Lambda, function(self, tw) {
+ if (self.name) self.name = self.name.transform(tw);
+ self.argnames = do_list(self.argnames, tw);
+ self.body = do_list(self.body, tw);
+ });
+ _(AST_Call, function(self, tw) {
+ self.expression = self.expression.transform(tw);
+ self.args = do_list(self.args, tw);
+ });
+ _(AST_Seq, function(self, tw) {
+ self.car = self.car.transform(tw);
+ self.cdr = self.cdr.transform(tw);
+ });
+ _(AST_Dot, function(self, tw) {
+ self.expression = self.expression.transform(tw);
+ });
+ _(AST_Sub, function(self, tw) {
+ self.expression = self.expression.transform(tw);
+ self.property = self.property.transform(tw);
+ });
+ _(AST_Unary, function(self, tw) {
+ self.expression = self.expression.transform(tw);
+ });
+ _(AST_Binary, function(self, tw) {
+ self.left = self.left.transform(tw);
+ self.right = self.right.transform(tw);
+ });
+ _(AST_Conditional, function(self, tw) {
+ self.condition = self.condition.transform(tw);
+ self.consequent = self.consequent.transform(tw);
+ self.alternative = self.alternative.transform(tw);
+ });
+ _(AST_Array, function(self, tw) {
+ self.elements = do_list(self.elements, tw);
+ });
+ _(AST_Object, function(self, tw) {
+ self.properties = do_list(self.properties, tw);
+ });
+ _(AST_ObjectProperty, function(self, tw) {
+ self.value = self.value.transform(tw);
+ });
+ })();
+ "use strict";
+ function SymbolDef(scope, index, orig) {
+ this.name = orig.name;
+ this.orig = [ orig ];
+ this.scope = scope;
+ this.references = [];
+ this.global = false;
+ this.mangled_name = null;
+ this.undeclared = false;
+ this.constant = false;
+ this.index = index;
+ }
+ SymbolDef.prototype = {
+ unmangleable: function(options) {
+ return this.global && !(options && options.toplevel) || this.undeclared || !(options && options.eval) && (this.scope.uses_eval || this.scope.uses_with);
+ },
+ mangle: function(options) {
+ if (!this.mangled_name && !this.unmangleable(options)) {
+ var s = this.scope;
+ if (this.orig[0] instanceof AST_SymbolLambda && !options.screw_ie8) s = s.parent_scope;
+ this.mangled_name = s.next_mangled(options);
+ }
+ }
+ };
+ AST_Toplevel.DEFMETHOD("figure_out_scope", function() {
+ var self = this;
+ var scope = self.parent_scope = null;
+ var labels = new Dictionary();
+ var nesting = 0;
+ var tw = new TreeWalker(function(node, descend) {
+ if (node instanceof AST_Scope) {
+ node.init_scope_vars(nesting);
+ var save_scope = node.parent_scope = scope;
+ var save_labels = labels;
+ ++nesting;
+ scope = node;
+ labels = new Dictionary();
+ descend();
+ labels = save_labels;
+ scope = save_scope;
+ --nesting;
+ return true;
+ }
+ if (node instanceof AST_Directive) {
+ node.scope = scope;
+ push_uniq(scope.directives, node.value);
+ return true;
+ }
+ if (node instanceof AST_With) {
+ for (var s = scope; s; s = s.parent_scope) s.uses_with = true;
+ return;
+ }
+ if (node instanceof AST_LabeledStatement) {
+ var l = node.label;
+ if (labels.has(l.name)) throw new Error(string_template("Label {name} defined twice", l));
+ labels.set(l.name, l);
+ descend();
+ labels.del(l.name);
+ return true;
+ }
+ if (node instanceof AST_Symbol) {
+ node.scope = scope;
+ }
+ if (node instanceof AST_Label) {
+ node.thedef = node;
+ node.init_scope_vars();
+ }
+ if (node instanceof AST_SymbolLambda) {
+ scope.def_function(node);
+ } else if (node instanceof AST_SymbolDefun) {
+ (node.scope = scope.parent_scope).def_function(node);
+ } else if (node instanceof AST_SymbolVar || node instanceof AST_SymbolConst) {
+ var def = scope.def_variable(node);
+ def.constant = node instanceof AST_SymbolConst;
+ def.init = tw.parent().value;
+ } else if (node instanceof AST_SymbolCatch) {
+ scope.def_variable(node);
+ }
+ if (node instanceof AST_LabelRef) {
+ var sym = labels.get(node.name);
+ if (!sym) throw new Error(string_template("Undefined label {name} [{line},{col}]", {
+ name: node.name,
+ line: node.start.line,
+ col: node.start.col
+ }));
+ node.thedef = sym;
+ }
+ });
+ self.walk(tw);
+ var func = null;
+ var globals = self.globals = new Dictionary();
+ var tw = new TreeWalker(function(node, descend) {
+ if (node instanceof AST_Lambda) {
+ var prev_func = func;
+ func = node;
+ descend();
+ func = prev_func;
+ return true;
+ }
+ if (node instanceof AST_LabelRef) {
+ node.reference();
+ return true;
+ }
+ if (node instanceof AST_SymbolRef) {
+ var name = node.name;
+ var sym = node.scope.find_variable(name);
+ if (!sym) {
+ var g;
+ if (globals.has(name)) {
+ g = globals.get(name);
+ } else {
+ g = new SymbolDef(self, globals.size(), node);
+ g.undeclared = true;
+ g.global = true;
+ globals.set(name, g);
+ }
+ node.thedef = g;
+ if (name == "eval" && tw.parent() instanceof AST_Call) {
+ for (var s = node.scope; s && !s.uses_eval; s = s.parent_scope) s.uses_eval = true;
+ }
+ if (name == "arguments") {
+ func.uses_arguments = true;
+ }
+ } else {
+ node.thedef = sym;
+ }
+ node.reference();
+ return true;
+ }
+ });
+ self.walk(tw);
+ });
+ AST_Scope.DEFMETHOD("init_scope_vars", function(nesting) {
+ this.directives = [];
+ this.variables = new Dictionary();
+ this.functions = new Dictionary();
+ this.uses_with = false;
+ this.uses_eval = false;
+ this.parent_scope = null;
+ this.enclosed = [];
+ this.cname = -1;
+ this.nesting = nesting;
+ });
+ AST_Scope.DEFMETHOD("strict", function() {
+ return this.has_directive("use strict");
+ });
+ AST_Lambda.DEFMETHOD("init_scope_vars", function() {
+ AST_Scope.prototype.init_scope_vars.apply(this, arguments);
+ this.uses_arguments = false;
+ });
+ AST_SymbolRef.DEFMETHOD("reference", function() {
+ var def = this.definition();
+ def.references.push(this);
+ var s = this.scope;
+ while (s) {
+ push_uniq(s.enclosed, def);
+ if (s === def.scope) break;
+ s = s.parent_scope;
+ }
+ this.frame = this.scope.nesting - def.scope.nesting;
+ });
+ AST_Label.DEFMETHOD("init_scope_vars", function() {
+ this.references = [];
+ });
+ AST_LabelRef.DEFMETHOD("reference", function() {
+ this.thedef.references.push(this);
+ });
+ AST_Scope.DEFMETHOD("find_variable", function(name) {
+ if (name instanceof AST_Symbol) name = name.name;
+ return this.variables.get(name) || this.parent_scope && this.parent_scope.find_variable(name);
+ });
+ AST_Scope.DEFMETHOD("has_directive", function(value) {
+ return this.parent_scope && this.parent_scope.has_directive(value) || (this.directives.indexOf(value) >= 0 ? this : null);
+ });
+ AST_Scope.DEFMETHOD("def_function", function(symbol) {
+ this.functions.set(symbol.name, this.def_variable(symbol));
+ });
+ AST_Scope.DEFMETHOD("def_variable", function(symbol) {
+ var def;
+ if (!this.variables.has(symbol.name)) {
+ def = new SymbolDef(this, this.variables.size(), symbol);
+ this.variables.set(symbol.name, def);
+ def.global = !this.parent_scope;
+ } else {
+ def = this.variables.get(symbol.name);
+ def.orig.push(symbol);
+ }
+ return symbol.thedef = def;
+ });
+ AST_Scope.DEFMETHOD("next_mangled", function(options) {
+ var ext = this.enclosed;
+ out: while (true) {
+ var m = base54(++this.cname);
+ if (!is_identifier(m)) continue;
+ for (var i = ext.length; --i >= 0; ) {
+ var sym = ext[i];
+ var name = sym.mangled_name || sym.unmangleable(options) && sym.name;
+ if (m == name) continue out;
+ }
+ return m;
+ }
+ });
+ AST_Scope.DEFMETHOD("references", function(sym) {
+ if (sym instanceof AST_Symbol) sym = sym.definition();
+ return this.enclosed.indexOf(sym) < 0 ? null : sym;
+ });
+ AST_Symbol.DEFMETHOD("unmangleable", function(options) {
+ return this.definition().unmangleable(options);
+ });
+ AST_SymbolAccessor.DEFMETHOD("unmangleable", function() {
+ return true;
+ });
+ AST_Label.DEFMETHOD("unmangleable", function() {
+ return false;
+ });
+ AST_Symbol.DEFMETHOD("unreferenced", function() {
+ return this.definition().references.length == 0 && !(this.scope.uses_eval || this.scope.uses_with);
+ });
+ AST_Symbol.DEFMETHOD("undeclared", function() {
+ return this.definition().undeclared;
+ });
+ AST_LabelRef.DEFMETHOD("undeclared", function() {
+ return false;
+ });
+ AST_Label.DEFMETHOD("undeclared", function() {
+ return false;
+ });
+ AST_Symbol.DEFMETHOD("definition", function() {
+ return this.thedef;
+ });
+ AST_Symbol.DEFMETHOD("global", function() {
+ return this.definition().global;
+ });
+ AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options) {
+ return defaults(options, {
+ except: [],
+ eval: false,
+ sort: false,
+ toplevel: false,
+ screw_ie8: false
+ });
+ });
+ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
+ options = this._default_mangler_options(options);
+ var lname = -1;
+ var to_mangle = [];
+ var tw = new TreeWalker(function(node, descend) {
+ if (node instanceof AST_LabeledStatement) {
+ var save_nesting = lname;
+ descend();
+ lname = save_nesting;
+ return true;
+ }
+ if (node instanceof AST_Scope) {
+ var p = tw.parent(), a = [];
+ node.variables.each(function(symbol) {
+ if (options.except.indexOf(symbol.name) < 0) {
+ a.push(symbol);
+ }
+ });
+ if (options.sort) a.sort(function(a, b) {
+ return b.references.length - a.references.length;
+ });
+ to_mangle.push.apply(to_mangle, a);
+ return;
+ }
+ if (node instanceof AST_Label) {
+ var name;
+ do name = base54(++lname); while (!is_identifier(name));
+ node.mangled_name = name;
+ return true;
+ }
+ });
+ this.walk(tw);
+ to_mangle.forEach(function(def) {
+ def.mangle(options);
+ });
+ });
+ AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options) {
+ options = this._default_mangler_options(options);
+ var tw = new TreeWalker(function(node) {
+ if (node instanceof AST_Constant) base54.consider(node.print_to_string()); else if (node instanceof AST_Return) base54.consider("return"); else if (node instanceof AST_Throw) base54.consider("throw"); else if (node instanceof AST_Continue) base54.consider("continue"); else if (node instanceof AST_Break) base54.consider("break"); else if (node instanceof AST_Debugger) base54.consider("debugger"); else if (node instanceof AST_Directive) base54.consider(node.value); else if (node instanceof AST_While) base54.consider("while"); else if (node instanceof AST_Do) base54.consider("do while"); else if (node instanceof AST_If) {
+ base54.consider("if");
+ if (node.alternative) base54.consider("else");
+ } else if (node instanceof AST_Var) base54.consider("var"); else if (node instanceof AST_Const) base54.consider("const"); else if (node instanceof AST_Lambda) base54.consider("function"); else if (node instanceof AST_For) base54.consider("for"); else if (node instanceof AST_ForIn) base54.consider("for in"); else if (node instanceof AST_Switch) base54.consider("switch"); else if (node instanceof AST_Case) base54.consider("case"); else if (node instanceof AST_Default) base54.consider("default"); else if (node instanceof AST_With) base54.consider("with"); else if (node instanceof AST_ObjectSetter) base54.consider("set" + node.key); else if (node instanceof AST_ObjectGetter) base54.consider("get" + node.key); else if (node instanceof AST_ObjectKeyVal) base54.consider(node.key); else if (node instanceof AST_New) base54.consider("new"); else if (node instanceof AST_This) base54.consider("this"); else if (node instanceof AST_Try) base54.consider("try"); else if (node instanceof AST_Catch) base54.consider("catch"); else if (node instanceof AST_Finally) base54.consider("finally"); else if (node instanceof AST_Symbol && node.unmangleable(options)) base54.consider(node.name); else if (node instanceof AST_Unary || node instanceof AST_Binary) base54.consider(node.operator); else if (node instanceof AST_Dot) base54.consider(node.property);
+ });
+ this.walk(tw);
+ base54.sort();
+ });
+ var base54 = function() {
+ var string = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_0123456789";
+ var chars, frequency;
+ function reset() {
+ frequency = Object.create(null);
+ chars = string.split("").map(function(ch) {
+ return ch.charCodeAt(0);
+ });
+ chars.forEach(function(ch) {
+ frequency[ch] = 0;
+ });
+ }
+ base54.consider = function(str) {
+ for (var i = str.length; --i >= 0; ) {
+ var code = str.charCodeAt(i);
+ if (code in frequency) ++frequency[code];
+ }
+ };
+ base54.sort = function() {
+ chars = mergeSort(chars, function(a, b) {
+ if (is_digit(a) && !is_digit(b)) return 1;
+ if (is_digit(b) && !is_digit(a)) return -1;
+ return frequency[b] - frequency[a];
+ });
+ };
+ base54.reset = reset;
+ reset();
+ base54.get = function() {
+ return chars;
+ };
+ base54.freq = function() {
+ return frequency;
+ };
+ function base54(num) {
+ var ret = "", base = 54;
+ do {
+ ret += String.fromCharCode(chars[num % base]);
+ num = Math.floor(num / base);
+ base = 64;
+ } while (num > 0);
+ return ret;
+ }
+ return base54;
+ }();
+ AST_Toplevel.DEFMETHOD("scope_warnings", function(options) {
+ options = defaults(options, {
+ undeclared: false,
+ unreferenced: true,
+ assign_to_global: true,
+ func_arguments: true,
+ nested_defuns: true,
+ eval: true
+ });
+ var tw = new TreeWalker(function(node) {
+ if (options.undeclared && node instanceof AST_SymbolRef && node.undeclared()) {
+ AST_Node.warn("Undeclared symbol: {name} [{file}:{line},{col}]", {
+ name: node.name,
+ file: node.start.file,
+ line: node.start.line,
+ col: node.start.col
+ });
+ }
+ if (options.assign_to_global) {
+ var sym = null;
+ if (node instanceof AST_Assign && node.left instanceof AST_SymbolRef) sym = node.left; else if (node instanceof AST_ForIn && node.init instanceof AST_SymbolRef) sym = node.init;
+ if (sym && (sym.undeclared() || sym.global() && sym.scope !== sym.definition().scope)) {
+ AST_Node.warn("{msg}: {name} [{file}:{line},{col}]", {
+ msg: sym.undeclared() ? "Accidental global?" : "Assignment to global",
+ name: sym.name,
+ file: sym.start.file,
+ line: sym.start.line,
+ col: sym.start.col
+ });
+ }
+ }
+ if (options.eval && node instanceof AST_SymbolRef && node.undeclared() && node.name == "eval") {
+ AST_Node.warn("Eval is used [{file}:{line},{col}]", node.start);
+ }
+ if (options.unreferenced && (node instanceof AST_SymbolDeclaration || node instanceof AST_Label) && node.unreferenced()) {
+ AST_Node.warn("{type} {name} is declared but not referenced [{file}:{line},{col}]", {
+ type: node instanceof AST_Label ? "Label" : "Symbol",
+ name: node.name,
+ file: node.start.file,
+ line: node.start.line,
+ col: node.start.col
+ });
+ }
+ if (options.func_arguments && node instanceof AST_Lambda && node.uses_arguments) {
+ AST_Node.warn("arguments used in function {name} [{file}:{line},{col}]", {
+ name: node.name ? node.name.name : "anonymous",
+ file: node.start.file,
+ line: node.start.line,
+ col: node.start.col
+ });
+ }
+ if (options.nested_defuns && node instanceof AST_Defun && !(tw.parent() instanceof AST_Scope)) {
+ AST_Node.warn('Function {name} declared in nested statement "{type}" [{file}:{line},{col}]', {
+ name: node.name.name,
+ type: tw.parent().TYPE,
+ file: node.start.file,
+ line: node.start.line,
+ col: node.start.col
+ });
+ }
+ });
+ this.walk(tw);
+ });
+ "use strict";
+ function OutputStream(options) {
+ options = defaults(options, {
+ indent_start: 0,
+ indent_level: 4,
+ quote_keys: false,
+ space_colon: true,
+ ascii_only: false,
+ inline_script: false,
+ width: 80,
+ max_line_len: 32e3,
+ ie_proof: true,
+ beautify: false,
+ source_map: null,
+ bracketize: false,
+ semicolons: true,
+ comments: false,
+ preserve_line: false,
+ negate_iife: !(options && options.beautify)
+ }, true);
+ var indentation = 0;
+ var current_col = 0;
+ var current_line = 1;
+ var current_pos = 0;
+ var OUTPUT = "";
+ function to_ascii(str, identifier) {
+ return str.replace(/[\u0080-\uffff]/g, function(ch) {
+ var code = ch.charCodeAt(0).toString(16);
+ if (code.length <= 2 && !identifier) {
+ while (code.length < 2) code = "0" + code;
+ return "\\x" + code;
+ } else {
+ while (code.length < 4) code = "0" + code;
+ return "\\u" + code;
+ }
+ });
+ }
+ function make_string(str) {
+ var dq = 0, sq = 0;
+ str = str.replace(/[\\\b\f\n\r\t\x22\x27\u2028\u2029\0]/g, function(s) {
+ switch (s) {
+ case "\\":
+ return "\\\\";
+
+ case "\b":
+ return "\\b";
+
+ case "\f":
+ return "\\f";
+
+ case "\n":
+ return "\\n";
+
+ case "\r":
+ return "\\r";
+
+ case "\u2028":
+ return "\\u2028";
+
+ case "\u2029":
+ return "\\u2029";
+
+ case '"':
+ ++dq;
+ return '"';
+
+ case "'":
+ ++sq;
+ return "'";
+
+ case "\0":
+ return "\\0";
+ }
+ return s;
+ });
+ if (options.ascii_only) str = to_ascii(str);
+ if (dq > sq) return "'" + str.replace(/\x27/g, "\\'") + "'"; else return '"' + str.replace(/\x22/g, '\\"') + '"';
+ }
+ function encode_string(str) {
+ var ret = make_string(str);
+ if (options.inline_script) ret = ret.replace(/<\x2fscript([>\/\t\n\f\r ])/gi, "<\\/script$1");
+ return ret;
+ }
+ function make_name(name) {
+ name = name.toString();
+ if (options.ascii_only) name = to_ascii(name, true);
+ return name;
+ }
+ function make_indent(back) {
+ return repeat_string(" ", options.indent_start + indentation - back * options.indent_level);
+ }
+ var might_need_space = false;
+ var might_need_semicolon = false;
+ var last = null;
+ function last_char() {
+ return last.charAt(last.length - 1);
+ }
+ function maybe_newline() {
+ if (options.max_line_len && current_col > options.max_line_len) print("\n");
+ }
+ var requireSemicolonChars = makePredicate("( [ + * / - , .");
+ function print(str) {
+ str = String(str);
+ var ch = str.charAt(0);
+ if (might_need_semicolon) {
+ if ((!ch || ";}".indexOf(ch) < 0) && !/[;]$/.test(last)) {
+ if (options.semicolons || requireSemicolonChars(ch)) {
+ OUTPUT += ";";
+ current_col++;
+ current_pos++;
+ } else {
+ OUTPUT += "\n";
+ current_pos++;
+ current_line++;
+ current_col = 0;
+ }
+ if (!options.beautify) might_need_space = false;
+ }
+ might_need_semicolon = false;
+ maybe_newline();
+ }
+ if (!options.beautify && options.preserve_line && stack[stack.length - 1]) {
+ var target_line = stack[stack.length - 1].start.line;
+ while (current_line < target_line) {
+ OUTPUT += "\n";
+ current_pos++;
+ current_line++;
+ current_col = 0;
+ might_need_space = false;
+ }
+ }
+ if (might_need_space) {
+ var prev = last_char();
+ if (is_identifier_char(prev) && (is_identifier_char(ch) || ch == "\\") || /^[\+\-\/]$/.test(ch) && ch == prev) {
+ OUTPUT += " ";
+ current_col++;
+ current_pos++;
+ }
+ might_need_space = false;
+ }
+ var a = str.split(/\r?\n/), n = a.length - 1;
+ current_line += n;
+ if (n == 0) {
+ current_col += a[n].length;
+ } else {
+ current_col = a[n].length;
+ }
+ current_pos += str.length;
+ last = str;
+ OUTPUT += str;
+ }
+ var space = options.beautify ? function() {
+ print(" ");
+ } : function() {
+ might_need_space = true;
+ };
+ var indent = options.beautify ? function(half) {
+ if (options.beautify) {
+ print(make_indent(half ? .5 : 0));
+ }
+ } : noop;
+ var with_indent = options.beautify ? function(col, cont) {
+ if (col === true) col = next_indent();
+ var save_indentation = indentation;
+ indentation = col;
+ var ret = cont();
+ indentation = save_indentation;
+ return ret;
+ } : function(col, cont) {
+ return cont();
+ };
+ var newline = options.beautify ? function() {
+ print("\n");
+ } : noop;
+ var semicolon = options.beautify ? function() {
+ print(";");
+ } : function() {
+ might_need_semicolon = true;
+ };
+ function force_semicolon() {
+ might_need_semicolon = false;
+ print(";");
+ }
+ function next_indent() {
+ return indentation + options.indent_level;
+ }
+ function with_block(cont) {
+ var ret;
+ print("{");
+ newline();
+ with_indent(next_indent(), function() {
+ ret = cont();
+ });
+ indent();
+ print("}");
+ return ret;
+ }
+ function with_parens(cont) {
+ print("(");
+ var ret = cont();
+ print(")");
+ return ret;
+ }
+ function with_square(cont) {
+ print("[");
+ var ret = cont();
+ print("]");
+ return ret;
+ }
+ function comma() {
+ print(",");
+ space();
+ }
+ function colon() {
+ print(":");
+ if (options.space_colon) space();
+ }
+ var add_mapping = options.source_map ? function(token, name) {
+ try {
+ if (token) options.source_map.add(token.file || "?", current_line, current_col, token.line, token.col, !name && token.type == "name" ? token.value : name);
+ } catch (ex) {
+ AST_Node.warn("Couldn't figure out mapping for {file}:{line},{col} → {cline},{ccol} [{name}]", {
+ file: token.file,
+ line: token.line,
+ col: token.col,
+ cline: current_line,
+ ccol: current_col,
+ name: name || ""
+ });
+ }
+ } : noop;
+ function get() {
+ return OUTPUT;
+ }
+ var stack = [];
+ return {
+ get: get,
+ toString: get,
+ indent: indent,
+ indentation: function() {
+ return indentation;
+ },
+ current_width: function() {
+ return current_col - indentation;
+ },
+ should_break: function() {
+ return options.width && this.current_width() >= options.width;
+ },
+ newline: newline,
+ print: print,
+ space: space,
+ comma: comma,
+ colon: colon,
+ last: function() {
+ return last;
+ },
+ semicolon: semicolon,
+ force_semicolon: force_semicolon,
+ to_ascii: to_ascii,
+ print_name: function(name) {
+ print(make_name(name));
+ },
+ print_string: function(str) {
+ print(encode_string(str));
+ },
+ next_indent: next_indent,
+ with_indent: with_indent,
+ with_block: with_block,
+ with_parens: with_parens,
+ with_square: with_square,
+ add_mapping: add_mapping,
+ option: function(opt) {
+ return options[opt];
+ },
+ line: function() {
+ return current_line;
+ },
+ col: function() {
+ return current_col;
+ },
+ pos: function() {
+ return current_pos;
+ },
+ push_node: function(node) {
+ stack.push(node);
+ },
+ pop_node: function() {
+ return stack.pop();
+ },
+ stack: function() {
+ return stack;
+ },
+ parent: function(n) {
+ return stack[stack.length - 2 - (n || 0)];
+ }
+ };
+ }
+ (function() {
+ function DEFPRINT(nodetype, generator) {
+ nodetype.DEFMETHOD("_codegen", generator);
+ }
+ AST_Node.DEFMETHOD("print", function(stream, force_parens) {
+ var self = this, generator = self._codegen;
+ stream.push_node(self);
+ var needs_parens = self.needs_parens(stream);
+ var fc = self instanceof AST_Function && stream.option("negate_iife");
+ if (force_parens || needs_parens && !fc) {
+ stream.with_parens(function() {
+ self.add_comments(stream);
+ self.add_source_map(stream);
+ generator(self, stream);
+ });
+ } else {
+ self.add_comments(stream);
+ if (needs_parens && fc) stream.print("!");
+ self.add_source_map(stream);
+ generator(self, stream);
+ }
+ stream.pop_node();
+ });
+ AST_Node.DEFMETHOD("print_to_string", function(options) {
+ var s = OutputStream(options);
+ this.print(s);
+ return s.get();
+ });
+ AST_Node.DEFMETHOD("add_comments", function(output) {
+ var c = output.option("comments"), self = this;
+ if (c) {
+ var start = self.start;
+ if (start && !start._comments_dumped) {
+ start._comments_dumped = true;
+ var comments = start.comments_before;
+ if (self instanceof AST_Exit && self.value && self.value.start.comments_before.length > 0) {
+ comments = (comments || []).concat(self.value.start.comments_before);
+ self.value.start.comments_before = [];
+ }
+ if (c.test) {
+ comments = comments.filter(function(comment) {
+ return c.test(comment.value);
+ });
+ } else if (typeof c == "function") {
+ comments = comments.filter(function(comment) {
+ return c(self, comment);
+ });
+ }
+ comments.forEach(function(c) {
+ if (c.type == "comment1") {
+ output.print("//" + c.value + "\n");
+ output.indent();
+ } else if (c.type == "comment2") {
+ output.print("/*" + c.value + "*/");
+ if (start.nlb) {
+ output.print("\n");
+ output.indent();
+ } else {
+ output.space();
+ }
+ }
+ });
+ }
+ }
+ });
+ function PARENS(nodetype, func) {
+ nodetype.DEFMETHOD("needs_parens", func);
+ }
+ PARENS(AST_Node, function() {
+ return false;
+ });
+ PARENS(AST_Function, function(output) {
+ return first_in_statement(output);
+ });
+ PARENS(AST_Object, function(output) {
+ return first_in_statement(output);
+ });
+ PARENS(AST_Unary, function(output) {
+ var p = output.parent();
+ return p instanceof AST_PropAccess && p.expression === this;
+ });
+ PARENS(AST_Seq, function(output) {
+ var p = output.parent();
+ return p instanceof AST_Call || p instanceof AST_Unary || p instanceof AST_Binary || p instanceof AST_VarDef || p instanceof AST_Dot || p instanceof AST_Array || p instanceof AST_ObjectProperty || p instanceof AST_Conditional;
+ });
+ PARENS(AST_Binary, function(output) {
+ var p = output.parent();
+ if (p instanceof AST_Call && p.expression === this) return true;
+ if (p instanceof AST_Unary) return true;
+ if (p instanceof AST_PropAccess && p.expression === this) return true;
+ if (p instanceof AST_Binary) {
+ var po = p.operator, pp = PRECEDENCE[po];
+ var so = this.operator, sp = PRECEDENCE[so];
+ if (pp > sp || pp == sp && this === p.right && !(so == po && (so == "*" || so == "&&" || so == "||"))) {
+ return true;
+ }
+ }
+ });
+ PARENS(AST_PropAccess, function(output) {
+ var p = output.parent();
+ if (p instanceof AST_New && p.expression === this) {
+ try {
+ this.walk(new TreeWalker(function(node) {
+ if (node instanceof AST_Call) throw p;
+ }));
+ } catch (ex) {
+ if (ex !== p) throw ex;
+ return true;
+ }
+ }
+ });
+ PARENS(AST_Call, function(output) {
+ var p = output.parent();
+ return p instanceof AST_New && p.expression === this;
+ });
+ PARENS(AST_New, function(output) {
+ var p = output.parent();
+ if (no_constructor_parens(this, output) && (p instanceof AST_PropAccess || p instanceof AST_Call && p.expression === this)) return true;
+ });
+ PARENS(AST_Number, function(output) {
+ var p = output.parent();
+ if (this.getValue() < 0 && p instanceof AST_PropAccess && p.expression === this) return true;
+ });
+ PARENS(AST_NaN, function(output) {
+ var p = output.parent();
+ if (p instanceof AST_PropAccess && p.expression === this) return true;
+ });
+ function assign_and_conditional_paren_rules(output) {
+ var p = output.parent();
+ if (p instanceof AST_Unary) return true;
+ if (p instanceof AST_Binary && !(p instanceof AST_Assign)) return true;
+ if (p instanceof AST_Call && p.expression === this) return true;
+ if (p instanceof AST_Conditional && p.condition === this) return true;
+ if (p instanceof AST_PropAccess && p.expression === this) return true;
+ }
+ PARENS(AST_Assign, assign_and_conditional_paren_rules);
+ PARENS(AST_Conditional, assign_and_conditional_paren_rules);
+ DEFPRINT(AST_Directive, function(self, output) {
+ output.print_string(self.value);
+ output.semicolon();
+ });
+ DEFPRINT(AST_Debugger, function(self, output) {
+ output.print("debugger");
+ output.semicolon();
+ });
+ function display_body(body, is_toplevel, output) {
+ var last = body.length - 1;
+ body.forEach(function(stmt, i) {
+ if (!(stmt instanceof AST_EmptyStatement)) {
+ output.indent();
+ stmt.print(output);
+ if (!(i == last && is_toplevel)) {
+ output.newline();
+ if (is_toplevel) output.newline();
+ }
+ }
+ });
+ }
+ AST_StatementWithBody.DEFMETHOD("_do_print_body", function(output) {
+ force_statement(this.body, output);
+ });
+ DEFPRINT(AST_Statement, function(self, output) {
+ self.body.print(output);
+ output.semicolon();
+ });
+ DEFPRINT(AST_Toplevel, function(self, output) {
+ display_body(self.body, true, output);
+ output.print("");
+ });
+ DEFPRINT(AST_LabeledStatement, function(self, output) {
+ self.label.print(output);
+ output.colon();
+ self.body.print(output);
+ });
+ DEFPRINT(AST_SimpleStatement, function(self, output) {
+ self.body.print(output);
+ output.semicolon();
+ });
+ function print_bracketed(body, output) {
+ if (body.length > 0) output.with_block(function() {
+ display_body(body, false, output);
+ }); else output.print("{}");
+ }
+ DEFPRINT(AST_BlockStatement, function(self, output) {
+ print_bracketed(self.body, output);
+ });
+ DEFPRINT(AST_EmptyStatement, function(self, output) {
+ output.semicolon();
+ });
+ DEFPRINT(AST_Do, function(self, output) {
+ output.print("do");
+ output.space();
+ self._do_print_body(output);
+ output.space();
+ output.print("while");
+ output.space();
+ output.with_parens(function() {
+ self.condition.print(output);
+ });
+ output.semicolon();
+ });
+ DEFPRINT(AST_While, function(self, output) {
+ output.print("while");
+ output.space();
+ output.with_parens(function() {
+ self.condition.print(output);
+ });
+ output.space();
+ self._do_print_body(output);
+ });
+ DEFPRINT(AST_For, function(self, output) {
+ output.print("for");
+ output.space();
+ output.with_parens(function() {
+ if (self.init) {
+ if (self.init instanceof AST_Definitions) {
+ self.init.print(output);
+ } else {
+ parenthesize_for_noin(self.init, output, true);
+ }
+ output.print(";");
+ output.space();
+ } else {
+ output.print(";");
+ }
+ if (self.condition) {
+ self.condition.print(output);
+ output.print(";");
+ output.space();
+ } else {
+ output.print(";");
+ }
+ if (self.step) {
+ self.step.print(output);
+ }
+ });
+ output.space();
+ self._do_print_body(output);
+ });
+ DEFPRINT(AST_ForIn, function(self, output) {
+ output.print("for");
+ output.space();
+ output.with_parens(function() {
+ self.init.print(output);
+ output.space();
+ output.print("in");
+ output.space();
+ self.object.print(output);
+ });
+ output.space();
+ self._do_print_body(output);
+ });
+ DEFPRINT(AST_With, function(self, output) {
+ output.print("with");
+ output.space();
+ output.with_parens(function() {
+ self.expression.print(output);
+ });
+ output.space();
+ self._do_print_body(output);
+ });
+ AST_Lambda.DEFMETHOD("_do_print", function(output, nokeyword) {
+ var self = this;
+ if (!nokeyword) {
+ output.print("function");
+ }
+ if (self.name) {
+ output.space();
+ self.name.print(output);
+ }
+ output.with_parens(function() {
+ self.argnames.forEach(function(arg, i) {
+ if (i) output.comma();
+ arg.print(output);
+ });
+ });
+ output.space();
+ print_bracketed(self.body, output);
+ });
+ DEFPRINT(AST_Lambda, function(self, output) {
+ self._do_print(output);
+ });
+ AST_Exit.DEFMETHOD("_do_print", function(output, kind) {
+ output.print(kind);
+ if (this.value) {
+ output.space();
+ this.value.print(output);
+ }
+ output.semicolon();
+ });
+ DEFPRINT(AST_Return, function(self, output) {
+ self._do_print(output, "return");
+ });
+ DEFPRINT(AST_Throw, function(self, output) {
+ self._do_print(output, "throw");
+ });
+ AST_LoopControl.DEFMETHOD("_do_print", function(output, kind) {
+ output.print(kind);
+ if (this.label) {
+ output.space();
+ this.label.print(output);
+ }
+ output.semicolon();
+ });
+ DEFPRINT(AST_Break, function(self, output) {
+ self._do_print(output, "break");
+ });
+ DEFPRINT(AST_Continue, function(self, output) {
+ self._do_print(output, "continue");
+ });
+ function make_then(self, output) {
+ if (output.option("bracketize")) {
+ make_block(self.body, output);
+ return;
+ }
+ if (!self.body) return output.force_semicolon();
+ if (self.body instanceof AST_Do && output.option("ie_proof")) {
+ make_block(self.body, output);
+ return;
+ }
+ var b = self.body;
+ while (true) {
+ if (b instanceof AST_If) {
+ if (!b.alternative) {
+ make_block(self.body, output);
+ return;
+ }
+ b = b.alternative;
+ } else if (b instanceof AST_StatementWithBody) {
+ b = b.body;
+ } else break;
+ }
+ force_statement(self.body, output);
+ }
+ DEFPRINT(AST_If, function(self, output) {
+ output.print("if");
+ output.space();
+ output.with_parens(function() {
+ self.condition.print(output);
+ });
+ output.space();
+ if (self.alternative) {
+ make_then(self, output);
+ output.space();
+ output.print("else");
+ output.space();
+ force_statement(self.alternative, output);
+ } else {
+ self._do_print_body(output);
+ }
+ });
+ DEFPRINT(AST_Switch, function(self, output) {
+ output.print("switch");
+ output.space();
+ output.with_parens(function() {
+ self.expression.print(output);
+ });
+ output.space();
+ if (self.body.length > 0) output.with_block(function() {
+ self.body.forEach(function(stmt, i) {
+ if (i) output.newline();
+ output.indent(true);
+ stmt.print(output);
+ });
+ }); else output.print("{}");
+ });
+ AST_SwitchBranch.DEFMETHOD("_do_print_body", function(output) {
+ if (this.body.length > 0) {
+ output.newline();
+ this.body.forEach(function(stmt) {
+ output.indent();
+ stmt.print(output);
+ output.newline();
+ });
+ }
+ });
+ DEFPRINT(AST_Default, function(self, output) {
+ output.print("default:");
+ self._do_print_body(output);
+ });
+ DEFPRINT(AST_Case, function(self, output) {
+ output.print("case");
+ output.space();
+ self.expression.print(output);
+ output.print(":");
+ self._do_print_body(output);
+ });
+ DEFPRINT(AST_Try, function(self, output) {
+ output.print("try");
+ output.space();
+ print_bracketed(self.body, output);
+ if (self.bcatch) {
+ output.space();
+ self.bcatch.print(output);
+ }
+ if (self.bfinally) {
+ output.space();
+ self.bfinally.print(output);
+ }
+ });
+ DEFPRINT(AST_Catch, function(self, output) {
+ output.print("catch");
+ output.space();
+ output.with_parens(function() {
+ self.argname.print(output);
+ });
+ output.space();
+ print_bracketed(self.body, output);
+ });
+ DEFPRINT(AST_Finally, function(self, output) {
+ output.print("finally");
+ output.space();
+ print_bracketed(self.body, output);
+ });
+ AST_Definitions.DEFMETHOD("_do_print", function(output, kind) {
+ output.print(kind);
+ output.space();
+ this.definitions.forEach(function(def, i) {
+ if (i) output.comma();
+ def.print(output);
+ });
+ var p = output.parent();
+ var in_for = p instanceof AST_For || p instanceof AST_ForIn;
+ var avoid_semicolon = in_for && p.init === this;
+ if (!avoid_semicolon) output.semicolon();
+ });
+ DEFPRINT(AST_Var, function(self, output) {
+ self._do_print(output, "var");
+ });
+ DEFPRINT(AST_Const, function(self, output) {
+ self._do_print(output, "const");
+ });
+ function parenthesize_for_noin(node, output, noin) {
+ if (!noin) node.print(output); else try {
+ node.walk(new TreeWalker(function(node) {
+ if (node instanceof AST_Binary && node.operator == "in") throw output;
+ }));
+ node.print(output);
+ } catch (ex) {
+ if (ex !== output) throw ex;
+ node.print(output, true);
+ }
+ }
+ DEFPRINT(AST_VarDef, function(self, output) {
+ self.name.print(output);
+ if (self.value) {
+ output.space();
+ output.print("=");
+ output.space();
+ var p = output.parent(1);
+ var noin = p instanceof AST_For || p instanceof AST_ForIn;
+ parenthesize_for_noin(self.value, output, noin);
+ }
+ });
+ DEFPRINT(AST_Call, function(self, output) {
+ self.expression.print(output);
+ if (self instanceof AST_New && no_constructor_parens(self, output)) return;
+ output.with_parens(function() {
+ self.args.forEach(function(expr, i) {
+ if (i) output.comma();
+ expr.print(output);
+ });
+ });
+ });
+ DEFPRINT(AST_New, function(self, output) {
+ output.print("new");
+ output.space();
+ AST_Call.prototype._codegen(self, output);
+ });
+ AST_Seq.DEFMETHOD("_do_print", function(output) {
+ this.car.print(output);
+ if (this.cdr) {
+ output.comma();
+ if (output.should_break()) {
+ output.newline();
+ output.indent();
+ }
+ this.cdr.print(output);
+ }
+ });
+ DEFPRINT(AST_Seq, function(self, output) {
+ self._do_print(output);
+ });
+ DEFPRINT(AST_Dot, function(self, output) {
+ var expr = self.expression;
+ expr.print(output);
+ if (expr instanceof AST_Number && expr.getValue() >= 0) {
+ if (!/[xa-f.]/i.test(output.last())) {
+ output.print(".");
+ }
+ }
+ output.print(".");
+ output.add_mapping(self.end);
+ output.print_name(self.property);
+ });
+ DEFPRINT(AST_Sub, function(self, output) {
+ self.expression.print(output);
+ output.print("[");
+ self.property.print(output);
+ output.print("]");
+ });
+ DEFPRINT(AST_UnaryPrefix, function(self, output) {
+ var op = self.operator;
+ output.print(op);
+ if (/^[a-z]/i.test(op)) output.space();
+ self.expression.print(output);
+ });
+ DEFPRINT(AST_UnaryPostfix, function(self, output) {
+ self.expression.print(output);
+ output.print(self.operator);
+ });
+ DEFPRINT(AST_Binary, function(self, output) {
+ self.left.print(output);
+ output.space();
+ output.print(self.operator);
+ output.space();
+ self.right.print(output);
+ });
+ DEFPRINT(AST_Conditional, function(self, output) {
+ self.condition.print(output);
+ output.space();
+ output.print("?");
+ output.space();
+ self.consequent.print(output);
+ output.space();
+ output.colon();
+ self.alternative.print(output);
+ });
+ DEFPRINT(AST_Array, function(self, output) {
+ output.with_square(function() {
+ var a = self.elements, len = a.length;
+ if (len > 0) output.space();
+ a.forEach(function(exp, i) {
+ if (i) output.comma();
+ exp.print(output);
+ });
+ if (len > 0) output.space();
+ });
+ });
+ DEFPRINT(AST_Object, function(self, output) {
+ if (self.properties.length > 0) output.with_block(function() {
+ self.properties.forEach(function(prop, i) {
+ if (i) {
+ output.print(",");
+ output.newline();
+ }
+ output.indent();
+ prop.print(output);
+ });
+ output.newline();
+ }); else output.print("{}");
+ });
+ DEFPRINT(AST_ObjectKeyVal, function(self, output) {
+ var key = self.key;
+ if (output.option("quote_keys")) {
+ output.print_string(key + "");
+ } else if ((typeof key == "number" || !output.option("beautify") && +key + "" == key) && parseFloat(key) >= 0) {
+ output.print(make_num(key));
+ } else if (!is_identifier(key)) {
+ output.print_string(key);
+ } else {
+ output.print_name(key);
+ }
+ output.colon();
+ self.value.print(output);
+ });
+ DEFPRINT(AST_ObjectSetter, function(self, output) {
+ output.print("set");
+ self.value._do_print(output, true);
+ });
+ DEFPRINT(AST_ObjectGetter, function(self, output) {
+ output.print("get");
+ self.value._do_print(output, true);
+ });
+ DEFPRINT(AST_Symbol, function(self, output) {
+ var def = self.definition();
+ output.print_name(def ? def.mangled_name || def.name : self.name);
+ });
+ DEFPRINT(AST_Undefined, function(self, output) {
+ output.print("void 0");
+ });
+ DEFPRINT(AST_Hole, noop);
+ DEFPRINT(AST_Infinity, function(self, output) {
+ output.print("1/0");
+ });
+ DEFPRINT(AST_NaN, function(self, output) {
+ output.print("0/0");
+ });
+ DEFPRINT(AST_This, function(self, output) {
+ output.print("this");
+ });
+ DEFPRINT(AST_Constant, function(self, output) {
+ output.print(self.getValue());
+ });
+ DEFPRINT(AST_String, function(self, output) {
+ output.print_string(self.getValue());
+ });
+ DEFPRINT(AST_Number, function(self, output) {
+ output.print(make_num(self.getValue()));
+ });
+ DEFPRINT(AST_RegExp, function(self, output) {
+ var str = self.getValue().toString();
+ if (output.option("ascii_only")) str = output.to_ascii(str);
+ output.print(str);
+ var p = output.parent();
+ if (p instanceof AST_Binary && /^in/.test(p.operator) && p.left === self) output.print(" ");
+ });
+ function force_statement(stat, output) {
+ if (output.option("bracketize")) {
+ if (!stat || stat instanceof AST_EmptyStatement) output.print("{}"); else if (stat instanceof AST_BlockStatement) stat.print(output); else output.with_block(function() {
+ output.indent();
+ stat.print(output);
+ output.newline();
+ });
+ } else {
+ if (!stat || stat instanceof AST_EmptyStatement) output.force_semicolon(); else stat.print(output);
+ }
+ }
+ function first_in_statement(output) {
+ var a = output.stack(), i = a.length, node = a[--i], p = a[--i];
+ while (i > 0) {
+ if (p instanceof AST_Statement && p.body === node) return true;
+ if (p instanceof AST_Seq && p.car === node || p instanceof AST_Call && p.expression === node && !(p instanceof AST_New) || p instanceof AST_Dot && p.expression === node || p instanceof AST_Sub && p.expression === node || p instanceof AST_Conditional && p.condition === node || p instanceof AST_Binary && p.left === node || p instanceof AST_UnaryPostfix && p.expression === node) {
+ node = p;
+ p = a[--i];
+ } else {
+ return false;
+ }
+ }
+ }
+ function no_constructor_parens(self, output) {
+ return self.args.length == 0 && !output.option("beautify");
+ }
+ function best_of(a) {
+ var best = a[0], len = best.length;
+ for (var i = 1; i < a.length; ++i) {
+ if (a[i].length < len) {
+ best = a[i];
+ len = best.length;
+ }
+ }
+ return best;
+ }
+ function make_num(num) {
+ var str = num.toString(10), a = [ str.replace(/^0\./, ".").replace("e+", "e") ], m;
+ if (Math.floor(num) === num) {
+ if (num >= 0) {
+ a.push("0x" + num.toString(16).toLowerCase(), "0" + num.toString(8));
+ } else {
+ a.push("-0x" + (-num).toString(16).toLowerCase(), "-0" + (-num).toString(8));
+ }
+ if (m = /^(.*?)(0+)$/.exec(num)) {
+ a.push(m[1] + "e" + m[2].length);
+ }
+ } else if (m = /^0?\.(0+)(.*)$/.exec(num)) {
+ a.push(m[2] + "e-" + (m[1].length + m[2].length), str.substr(str.indexOf(".")));
+ }
+ return best_of(a);
+ }
+ function make_block(stmt, output) {
+ if (stmt instanceof AST_BlockStatement) {
+ stmt.print(output);
+ return;
+ }
+ output.with_block(function() {
+ output.indent();
+ stmt.print(output);
+ output.newline();
+ });
+ }
+ function DEFMAP(nodetype, generator) {
+ nodetype.DEFMETHOD("add_source_map", function(stream) {
+ generator(this, stream);
+ });
+ }
+ DEFMAP(AST_Node, noop);
+ function basic_sourcemap_gen(self, output) {
+ output.add_mapping(self.start);
+ }
+ DEFMAP(AST_Directive, basic_sourcemap_gen);
+ DEFMAP(AST_Debugger, basic_sourcemap_gen);
+ DEFMAP(AST_Symbol, basic_sourcemap_gen);
+ DEFMAP(AST_Jump, basic_sourcemap_gen);
+ DEFMAP(AST_StatementWithBody, basic_sourcemap_gen);
+ DEFMAP(AST_LabeledStatement, noop);
+ DEFMAP(AST_Lambda, basic_sourcemap_gen);
+ DEFMAP(AST_Switch, basic_sourcemap_gen);
+ DEFMAP(AST_SwitchBranch, basic_sourcemap_gen);
+ DEFMAP(AST_BlockStatement, basic_sourcemap_gen);
+ DEFMAP(AST_Toplevel, noop);
+ DEFMAP(AST_New, basic_sourcemap_gen);
+ DEFMAP(AST_Try, basic_sourcemap_gen);
+ DEFMAP(AST_Catch, basic_sourcemap_gen);
+ DEFMAP(AST_Finally, basic_sourcemap_gen);
+ DEFMAP(AST_Definitions, basic_sourcemap_gen);
+ DEFMAP(AST_Constant, basic_sourcemap_gen);
+ DEFMAP(AST_ObjectProperty, function(self, output) {
+ output.add_mapping(self.start, self.key);
+ });
+ })();
+ "use strict";
+ function Compressor(options, false_by_default) {
+ if (!(this instanceof Compressor)) return new Compressor(options, false_by_default);
+ TreeTransformer.call(this, this.before, this.after);
+ this.options = defaults(options, {
+ sequences: !false_by_default,
+ properties: !false_by_default,
+ dead_code: !false_by_default,
+ drop_debugger: !false_by_default,
+ unsafe: false,
+ unsafe_comps: false,
+ conditionals: !false_by_default,
+ comparisons: !false_by_default,
+ evaluate: !false_by_default,
+ booleans: !false_by_default,
+ loops: !false_by_default,
+ unused: !false_by_default,
+ hoist_funs: !false_by_default,
+ hoist_vars: false,
+ if_return: !false_by_default,
+ join_vars: !false_by_default,
+ cascade: !false_by_default,
+ side_effects: !false_by_default,
+ screw_ie8: false,
+ warnings: true,
+ global_defs: {}
+ }, true);
+ }
+ Compressor.prototype = new TreeTransformer();
+ merge(Compressor.prototype, {
+ option: function(key) {
+ return this.options[key];
+ },
+ warn: function() {
+ if (this.options.warnings) AST_Node.warn.apply(AST_Node, arguments);
+ },
+ before: function(node, descend, in_list) {
+ if (node._squeezed) return node;
+ if (node instanceof AST_Scope) {
+ node.drop_unused(this);
+ node = node.hoist_declarations(this);
+ }
+ descend(node, this);
+ node = node.optimize(this);
+ if (node instanceof AST_Scope) {
+ var save_warnings = this.options.warnings;
+ this.options.warnings = false;
+ node.drop_unused(this);
+ this.options.warnings = save_warnings;
+ }
+ node._squeezed = true;
+ return node;
+ }
+ });
+ (function() {
+ function OPT(node, optimizer) {
+ node.DEFMETHOD("optimize", function(compressor) {
+ var self = this;
+ if (self._optimized) return self;
+ var opt = optimizer(self, compressor);
+ opt._optimized = true;
+ if (opt === self) return opt;
+ return opt.transform(compressor);
+ });
+ }
+ OPT(AST_Node, function(self, compressor) {
+ return self;
+ });
+ AST_Node.DEFMETHOD("equivalent_to", function(node) {
+ return this.print_to_string() == node.print_to_string();
+ });
+ function make_node(ctor, orig, props) {
+ if (!props) props = {};
+ if (orig) {
+ if (!props.start) props.start = orig.start;
+ if (!props.end) props.end = orig.end;
+ }
+ return new ctor(props);
+ }
+ function make_node_from_constant(compressor, val, orig) {
+ if (val instanceof AST_Node) return val.transform(compressor);
+ switch (typeof val) {
+ case "string":
+ return make_node(AST_String, orig, {
+ value: val
+ }).optimize(compressor);
+
+ case "number":
+ return make_node(isNaN(val) ? AST_NaN : AST_Number, orig, {
+ value: val
+ }).optimize(compressor);
+
+ case "boolean":
+ return make_node(val ? AST_True : AST_False, orig).optimize(compressor);
+
+ case "undefined":
+ return make_node(AST_Undefined, orig).optimize(compressor);
+
+ default:
+ if (val === null) {
+ return make_node(AST_Null, orig).optimize(compressor);
+ }
+ if (val instanceof RegExp) {
+ return make_node(AST_RegExp, orig).optimize(compressor);
+ }
+ throw new Error(string_template("Can't handle constant of type: {type}", {
+ type: typeof val
+ }));
+ }
+ }
+ function as_statement_array(thing) {
+ if (thing === null) return [];
+ if (thing instanceof AST_BlockStatement) return thing.body;
+ if (thing instanceof AST_EmptyStatement) return [];
+ if (thing instanceof AST_Statement) return [ thing ];
+ throw new Error("Can't convert thing to statement array");
+ }
+ function is_empty(thing) {
+ if (thing === null) return true;
+ if (thing instanceof AST_EmptyStatement) return true;
+ if (thing instanceof AST_BlockStatement) return thing.body.length == 0;
+ return false;
+ }
+ function loop_body(x) {
+ if (x instanceof AST_Switch) return x;
+ if (x instanceof AST_For || x instanceof AST_ForIn || x instanceof AST_DWLoop) {
+ return x.body instanceof AST_BlockStatement ? x.body : x;
+ }
+ return x;
+ }
+ function tighten_body(statements, compressor) {
+ var CHANGED;
+ do {
+ CHANGED = false;
+ statements = eliminate_spurious_blocks(statements);
+ if (compressor.option("dead_code")) {
+ statements = eliminate_dead_code(statements, compressor);
+ }
+ if (compressor.option("if_return")) {
+ statements = handle_if_return(statements, compressor);
+ }
+ if (compressor.option("sequences")) {
+ statements = sequencesize(statements, compressor);
+ }
+ if (compressor.option("join_vars")) {
+ statements = join_consecutive_vars(statements, compressor);
+ }
+ } while (CHANGED);
+ return statements;
+ function eliminate_spurious_blocks(statements) {
+ var seen_dirs = [];
+ return statements.reduce(function(a, stat) {
+ if (stat instanceof AST_BlockStatement) {
+ CHANGED = true;
+ a.push.apply(a, eliminate_spurious_blocks(stat.body));
+ } else if (stat instanceof AST_EmptyStatement) {
+ CHANGED = true;
+ } else if (stat instanceof AST_Directive) {
+ if (seen_dirs.indexOf(stat.value) < 0) {
+ a.push(stat);
+ seen_dirs.push(stat.value);
+ } else {
+ CHANGED = true;
+ }
+ } else {
+ a.push(stat);
+ }
+ return a;
+ }, []);
+ }
+ function handle_if_return(statements, compressor) {
+ var self = compressor.self();
+ var in_lambda = self instanceof AST_Lambda;
+ var ret = [];
+ loop: for (var i = statements.length; --i >= 0; ) {
+ var stat = statements[i];
+ switch (true) {
+ case in_lambda && stat instanceof AST_Return && !stat.value && ret.length == 0:
+ CHANGED = true;
+ continue loop;
+
+ case stat instanceof AST_If:
+ if (stat.body instanceof AST_Return) {
+ if ((in_lambda && ret.length == 0 || ret[0] instanceof AST_Return && !ret[0].value) && !stat.body.value && !stat.alternative) {
+ CHANGED = true;
+ var cond = make_node(AST_SimpleStatement, stat.condition, {
+ body: stat.condition
+ });
+ ret.unshift(cond);
+ continue loop;
+ }
+ if (ret[0] instanceof AST_Return && stat.body.value && ret[0].value && !stat.alternative) {
+ CHANGED = true;
+ stat = stat.clone();
+ stat.alternative = ret[0];
+ ret[0] = stat.transform(compressor);
+ continue loop;
+ }
+ if ((ret.length == 0 || ret[0] instanceof AST_Return) && stat.body.value && !stat.alternative && in_lambda) {
+ CHANGED = true;
+ stat = stat.clone();
+ stat.alternative = ret[0] || make_node(AST_Return, stat, {
+ value: make_node(AST_Undefined, stat)
+ });
+ ret[0] = stat.transform(compressor);
+ continue loop;
+ }
+ if (!stat.body.value && in_lambda) {
+ CHANGED = true;
+ stat = stat.clone();
+ stat.condition = stat.condition.negate(compressor);
+ stat.body = make_node(AST_BlockStatement, stat, {
+ body: as_statement_array(stat.alternative).concat(ret)
+ });
+ stat.alternative = null;
+ ret = [ stat.transform(compressor) ];
+ continue loop;
+ }
+ if (ret.length == 1 && in_lambda && ret[0] instanceof AST_SimpleStatement && (!stat.alternative || stat.alternative instanceof AST_SimpleStatement)) {
+ CHANGED = true;
+ ret.push(make_node(AST_Return, ret[0], {
+ value: make_node(AST_Undefined, ret[0])
+ }).transform(compressor));
+ ret = as_statement_array(stat.alternative).concat(ret);
+ ret.unshift(stat);
+ continue loop;
+ }
+ }
+ var ab = aborts(stat.body);
+ var lct = ab instanceof AST_LoopControl ? compressor.loopcontrol_target(ab.label) : null;
+ if (ab && (ab instanceof AST_Return && !ab.value && in_lambda || ab instanceof AST_Continue && self === loop_body(lct) || ab instanceof AST_Break && lct instanceof AST_BlockStatement && self === lct)) {
+ if (ab.label) {
+ remove(ab.label.thedef.references, ab.label);
+ }
+ CHANGED = true;
+ var body = as_statement_array(stat.body).slice(0, -1);
+ stat = stat.clone();
+ stat.condition = stat.condition.negate(compressor);
+ stat.body = make_node(AST_BlockStatement, stat, {
+ body: ret
+ });
+ stat.alternative = make_node(AST_BlockStatement, stat, {
+ body: body
+ });
+ ret = [ stat.transform(compressor) ];
+ continue loop;
+ }
+ var ab = aborts(stat.alternative);
+ var lct = ab instanceof AST_LoopControl ? compressor.loopcontrol_target(ab.label) : null;
+ if (ab && (ab instanceof AST_Return && !ab.value && in_lambda || ab instanceof AST_Continue && self === loop_body(lct) || ab instanceof AST_Break && lct instanceof AST_BlockStatement && self === lct)) {
+ if (ab.label) {
+ remove(ab.label.thedef.references, ab.label);
+ }
+ CHANGED = true;
+ stat = stat.clone();
+ stat.body = make_node(AST_BlockStatement, stat.body, {
+ body: as_statement_array(stat.body).concat(ret)
+ });
+ stat.alternative = make_node(AST_BlockStatement, stat.alternative, {
+ body: as_statement_array(stat.alternative).slice(0, -1)
+ });
+ ret = [ stat.transform(compressor) ];
+ continue loop;
+ }
+ ret.unshift(stat);
+ break;
+
+ default:
+ ret.unshift(stat);
+ break;
+ }
+ }
+ return ret;
+ }
+ function eliminate_dead_code(statements, compressor) {
+ var has_quit = false;
+ var orig = statements.length;
+ var self = compressor.self();
+ statements = statements.reduce(function(a, stat) {
+ if (has_quit) {
+ extract_declarations_from_unreachable_code(compressor, stat, a);
+ } else {
+ if (stat instanceof AST_LoopControl) {
+ var lct = compressor.loopcontrol_target(stat.label);
+ if (stat instanceof AST_Break && lct instanceof AST_BlockStatement && loop_body(lct) === self || stat instanceof AST_Continue && loop_body(lct) === self) {
+ if (stat.label) {
+ remove(stat.label.thedef.references, stat.label);
+ }
+ } else {
+ a.push(stat);
+ }
+ } else {
+ a.push(stat);
+ }
+ if (aborts(stat)) has_quit = true;
+ }
+ return a;
+ }, []);
+ CHANGED = statements.length != orig;
+ return statements;
+ }
+ function sequencesize(statements, compressor) {
+ if (statements.length < 2) return statements;
+ var seq = [], ret = [];
+ function push_seq() {
+ seq = AST_Seq.from_array(seq);
+ if (seq) ret.push(make_node(AST_SimpleStatement, seq, {
+ body: seq
+ }));
+ seq = [];
+ }
+ statements.forEach(function(stat) {
+ if (stat instanceof AST_SimpleStatement) seq.push(stat.body); else push_seq(), ret.push(stat);
+ });
+ push_seq();
+ ret = sequencesize_2(ret, compressor);
+ CHANGED = ret.length != statements.length;
+ return ret;
+ }
+ function sequencesize_2(statements, compressor) {
+ function cons_seq(right) {
+ ret.pop();
+ var left = prev.body;
+ if (left instanceof AST_Seq) {
+ left.add(right);
+ } else {
+ left = AST_Seq.cons(left, right);
+ }
+ return left.transform(compressor);
+ }
+ var ret = [], prev = null;
+ statements.forEach(function(stat) {
+ if (prev) {
+ if (stat instanceof AST_For) {
+ var opera = {};
+ try {
+ prev.body.walk(new TreeWalker(function(node) {
+ if (node instanceof AST_Binary && node.operator == "in") throw opera;
+ }));
+ if (stat.init && !(stat.init instanceof AST_Definitions)) {
+ stat.init = cons_seq(stat.init);
+ } else if (!stat.init) {
+ stat.init = prev.body;
+ ret.pop();
+ }
+ } catch (ex) {
+ if (ex !== opera) throw ex;
+ }
+ } else if (stat instanceof AST_If) {
+ stat.condition = cons_seq(stat.condition);
+ } else if (stat instanceof AST_With) {
+ stat.expression = cons_seq(stat.expression);
+ } else if (stat instanceof AST_Exit && stat.value) {
+ stat.value = cons_seq(stat.value);
+ } else if (stat instanceof AST_Exit) {
+ stat.value = cons_seq(make_node(AST_Undefined, stat));
+ } else if (stat instanceof AST_Switch) {
+ stat.expression = cons_seq(stat.expression);
+ }
+ }
+ ret.push(stat);
+ prev = stat instanceof AST_SimpleStatement ? stat : null;
+ });
+ return ret;
+ }
+ function join_consecutive_vars(statements, compressor) {
+ var prev = null;
+ return statements.reduce(function(a, stat) {
+ if (stat instanceof AST_Definitions && prev && prev.TYPE == stat.TYPE) {
+ prev.definitions = prev.definitions.concat(stat.definitions);
+ CHANGED = true;
+ } else if (stat instanceof AST_For && prev instanceof AST_Definitions && (!stat.init || stat.init.TYPE == prev.TYPE)) {
+ CHANGED = true;
+ a.pop();
+ if (stat.init) {
+ stat.init.definitions = prev.definitions.concat(stat.init.definitions);
+ } else {
+ stat.init = prev;
+ }
+ a.push(stat);
+ prev = stat;
+ } else {
+ prev = stat;
+ a.push(stat);
+ }
+ return a;
+ }, []);
+ }
+ }
+ function extract_declarations_from_unreachable_code(compressor, stat, target) {
+ compressor.warn("Dropping unreachable code [{file}:{line},{col}]", stat.start);
+ stat.walk(new TreeWalker(function(node) {
+ if (node instanceof AST_Definitions) {
+ compressor.warn("Declarations in unreachable code! [{file}:{line},{col}]", node.start);
+ node.remove_initializers();
+ target.push(node);
+ return true;
+ }
+ if (node instanceof AST_Defun) {
+ target.push(node);
+ return true;
+ }
+ if (node instanceof AST_Scope) {
+ return true;
+ }
+ }));
+ }
+ (function(def) {
+ var unary_bool = [ "!", "delete" ];
+ var binary_bool = [ "in", "instanceof", "==", "!=", "===", "!==", "<", "<=", ">=", ">" ];
+ def(AST_Node, function() {
+ return false;
+ });
+ def(AST_UnaryPrefix, function() {
+ return member(this.operator, unary_bool);
+ });
+ def(AST_Binary, function() {
+ return member(this.operator, binary_bool) || (this.operator == "&&" || this.operator == "||") && this.left.is_boolean() && this.right.is_boolean();
+ });
+ def(AST_Conditional, function() {
+ return this.consequent.is_boolean() && this.alternative.is_boolean();
+ });
+ def(AST_Assign, function() {
+ return this.operator == "=" && this.right.is_boolean();
+ });
+ def(AST_Seq, function() {
+ return this.cdr.is_boolean();
+ });
+ def(AST_True, function() {
+ return true;
+ });
+ def(AST_False, function() {
+ return true;
+ });
+ })(function(node, func) {
+ node.DEFMETHOD("is_boolean", func);
+ });
+ (function(def) {
+ def(AST_Node, function() {
+ return false;
+ });
+ def(AST_String, function() {
+ return true;
+ });
+ def(AST_UnaryPrefix, function() {
+ return this.operator == "typeof";
+ });
+ def(AST_Binary, function(compressor) {
+ return this.operator == "+" && (this.left.is_string(compressor) || this.right.is_string(compressor));
+ });
+ def(AST_Assign, function(compressor) {
+ return (this.operator == "=" || this.operator == "+=") && this.right.is_string(compressor);
+ });
+ def(AST_Seq, function(compressor) {
+ return this.cdr.is_string(compressor);
+ });
+ def(AST_Conditional, function(compressor) {
+ return this.consequent.is_string(compressor) && this.alternative.is_string(compressor);
+ });
+ def(AST_Call, function(compressor) {
+ return compressor.option("unsafe") && this.expression instanceof AST_SymbolRef && this.expression.name == "String" && this.expression.undeclared();
+ });
+ })(function(node, func) {
+ node.DEFMETHOD("is_string", func);
+ });
+ function best_of(ast1, ast2) {
+ return ast1.print_to_string().length > ast2.print_to_string().length ? ast2 : ast1;
+ }
+ (function(def) {
+ AST_Node.DEFMETHOD("evaluate", function(compressor) {
+ if (!compressor.option("evaluate")) return [ this ];
+ try {
+ var val = this._eval(), ast = make_node_from_constant(compressor, val, this);
+ return [ best_of(ast, this), val ];
+ } catch (ex) {
+ if (ex !== def) throw ex;
+ return [ this ];
+ }
+ });
+ def(AST_Statement, function() {
+ throw new Error(string_template("Cannot evaluate a statement [{file}:{line},{col}]", this.start));
+ });
+ def(AST_Function, function() {
+ return [ this ];
+ });
+ function ev(node) {
+ return node._eval();
+ }
+ def(AST_Node, function() {
+ throw def;
+ });
+ def(AST_Constant, function() {
+ return this.getValue();
+ });
+ def(AST_UnaryPrefix, function() {
+ var e = this.expression;
+ switch (this.operator) {
+ case "!":
+ return !ev(e);
+
+ case "typeof":
+ if (e instanceof AST_Function) return typeof function() {};
+ e = ev(e);
+ if (e instanceof RegExp) throw def;
+ return typeof e;
+
+ case "void":
+ return void ev(e);
+
+ case "~":
+ return ~ev(e);
+
+ case "-":
+ e = ev(e);
+ if (e === 0) throw def;
+ return -e;
+
+ case "+":
+ return +ev(e);
+ }
+ throw def;
+ });
+ def(AST_Binary, function() {
+ var left = this.left, right = this.right;
+ switch (this.operator) {
+ case "&&":
+ return ev(left) && ev(right);
+
+ case "||":
+ return ev(left) || ev(right);
+
+ case "|":
+ return ev(left) | ev(right);
+
+ case "&":
+ return ev(left) & ev(right);
+
+ case "^":
+ return ev(left) ^ ev(right);
+
+ case "+":
+ return ev(left) + ev(right);
+
+ case "*":
+ return ev(left) * ev(right);
+
+ case "/":
+ return ev(left) / ev(right);
+
+ case "%":
+ return ev(left) % ev(right);
+
+ case "-":
+ return ev(left) - ev(right);
+
+ case "<<":
+ return ev(left) << ev(right);
+
+ case ">>":
+ return ev(left) >> ev(right);
+
+ case ">>>":
+ return ev(left) >>> ev(right);
+
+ case "==":
+ return ev(left) == ev(right);
+
+ case "===":
+ return ev(left) === ev(right);
+
+ case "!=":
+ return ev(left) != ev(right);
+
+ case "!==":
+ return ev(left) !== ev(right);
+
+ case "<":
+ return ev(left) < ev(right);
+
+ case "<=":
+ return ev(left) <= ev(right);
+
+ case ">":
+ return ev(left) > ev(right);
+
+ case ">=":
+ return ev(left) >= ev(right);
+
+ case "in":
+ return ev(left) in ev(right);
+
+ case "instanceof":
+ return ev(left) instanceof ev(right);
+ }
+ throw def;
+ });
+ def(AST_Conditional, function() {
+ return ev(this.condition) ? ev(this.consequent) : ev(this.alternative);
+ });
+ def(AST_SymbolRef, function() {
+ var d = this.definition();
+ if (d && d.constant && d.init) return ev(d.init);
+ throw def;
+ });
+ })(function(node, func) {
+ node.DEFMETHOD("_eval", func);
+ });
+ (function(def) {
+ function basic_negation(exp) {
+ return make_node(AST_UnaryPrefix, exp, {
+ operator: "!",
+ expression: exp
+ });
+ }
+ def(AST_Node, function() {
+ return basic_negation(this);
+ });
+ def(AST_Statement, function() {
+ throw new Error("Cannot negate a statement");
+ });
+ def(AST_Function, function() {
+ return basic_negation(this);
+ });
+ def(AST_UnaryPrefix, function() {
+ if (this.operator == "!") return this.expression;
+ return basic_negation(this);
+ });
+ def(AST_Seq, function(compressor) {
+ var self = this.clone();
+ self.cdr = self.cdr.negate(compressor);
+ return self;
+ });
+ def(AST_Conditional, function(compressor) {
+ var self = this.clone();
+ self.consequent = self.consequent.negate(compressor);
+ self.alternative = self.alternative.negate(compressor);
+ return best_of(basic_negation(this), self);
+ });
+ def(AST_Binary, function(compressor) {
+ var self = this.clone(), op = this.operator;
+ if (compressor.option("unsafe_comps")) {
+ switch (op) {
+ case "<=":
+ self.operator = ">";
+ return self;
+
+ case "<":
+ self.operator = ">=";
+ return self;
+
+ case ">=":
+ self.operator = "<";
+ return self;
+
+ case ">":
+ self.operator = "<=";
+ return self;
+ }
+ }
+ switch (op) {
+ case "==":
+ self.operator = "!=";
+ return self;
+
+ case "!=":
+ self.operator = "==";
+ return self;
+
+ case "===":
+ self.operator = "!==";
+ return self;
+
+ case "!==":
+ self.operator = "===";
+ return self;
+
+ case "&&":
+ self.operator = "||";
+ self.left = self.left.negate(compressor);
+ self.right = self.right.negate(compressor);
+ return best_of(basic_negation(this), self);
+
+ case "||":
+ self.operator = "&&";
+ self.left = self.left.negate(compressor);
+ self.right = self.right.negate(compressor);
+ return best_of(basic_negation(this), self);
+ }
+ return basic_negation(this);
+ });
+ })(function(node, func) {
+ node.DEFMETHOD("negate", function(compressor) {
+ return func.call(this, compressor);
+ });
+ });
+ (function(def) {
+ def(AST_Node, function() {
+ return true;
+ });
+ def(AST_EmptyStatement, function() {
+ return false;
+ });
+ def(AST_Constant, function() {
+ return false;
+ });
+ def(AST_This, function() {
+ return false;
+ });
+ def(AST_Block, function() {
+ for (var i = this.body.length; --i >= 0; ) {
+ if (this.body[i].has_side_effects()) return true;
+ }
+ return false;
+ });
+ def(AST_SimpleStatement, function() {
+ return this.body.has_side_effects();
+ });
+ def(AST_Defun, function() {
+ return true;
+ });
+ def(AST_Function, function() {
+ return false;
+ });
+ def(AST_Binary, function() {
+ return this.left.has_side_effects() || this.right.has_side_effects();
+ });
+ def(AST_Assign, function() {
+ return true;
+ });
+ def(AST_Conditional, function() {
+ return this.condition.has_side_effects() || this.consequent.has_side_effects() || this.alternative.has_side_effects();
+ });
+ def(AST_Unary, function() {
+ return this.operator == "delete" || this.operator == "++" || this.operator == "--" || this.expression.has_side_effects();
+ });
+ def(AST_SymbolRef, function() {
+ return false;
+ });
+ def(AST_Object, function() {
+ for (var i = this.properties.length; --i >= 0; ) if (this.properties[i].has_side_effects()) return true;
+ return false;
+ });
+ def(AST_ObjectProperty, function() {
+ return this.value.has_side_effects();
+ });
+ def(AST_Array, function() {
+ for (var i = this.elements.length; --i >= 0; ) if (this.elements[i].has_side_effects()) return true;
+ return false;
+ });
+ def(AST_PropAccess, function() {
+ return true;
+ });
+ def(AST_Seq, function() {
+ return this.car.has_side_effects() || this.cdr.has_side_effects();
+ });
+ })(function(node, func) {
+ node.DEFMETHOD("has_side_effects", func);
+ });
+ function aborts(thing) {
+ return thing && thing.aborts();
+ }
+ (function(def) {
+ def(AST_Statement, function() {
+ return null;
+ });
+ def(AST_Jump, function() {
+ return this;
+ });
+ function block_aborts() {
+ var n = this.body.length;
+ return n > 0 && aborts(this.body[n - 1]);
+ }
+ def(AST_BlockStatement, block_aborts);
+ def(AST_SwitchBranch, block_aborts);
+ def(AST_If, function() {
+ return this.alternative && aborts(this.body) && aborts(this.alternative);
+ });
+ })(function(node, func) {
+ node.DEFMETHOD("aborts", func);
+ });
+ OPT(AST_Directive, function(self, compressor) {
+ if (self.scope.has_directive(self.value) !== self.scope) {
+ return make_node(AST_EmptyStatement, self);
+ }
+ return self;
+ });
+ OPT(AST_Debugger, function(self, compressor) {
+ if (compressor.option("drop_debugger")) return make_node(AST_EmptyStatement, self);
+ return self;
+ });
+ OPT(AST_LabeledStatement, function(self, compressor) {
+ if (self.body instanceof AST_Break && compressor.loopcontrol_target(self.body.label) === self.body) {
+ return make_node(AST_EmptyStatement, self);
+ }
+ return self.label.references.length == 0 ? self.body : self;
+ });
+ OPT(AST_Block, function(self, compressor) {
+ self.body = tighten_body(self.body, compressor);
+ return self;
+ });
+ OPT(AST_BlockStatement, function(self, compressor) {
+ self.body = tighten_body(self.body, compressor);
+ switch (self.body.length) {
+ case 1:
+ return self.body[0];
+
+ case 0:
+ return make_node(AST_EmptyStatement, self);
+ }
+ return self;
+ });
+ AST_Scope.DEFMETHOD("drop_unused", function(compressor) {
+ var self = this;
+ if (compressor.option("unused") && !(self instanceof AST_Toplevel) && !self.uses_eval) {
+ var in_use = [];
+ var initializations = new Dictionary();
+ var scope = this;
+ var tw = new TreeWalker(function(node, descend) {
+ if (node !== self) {
+ if (node instanceof AST_Defun) {
+ initializations.add(node.name.name, node);
+ return true;
+ }
+ if (node instanceof AST_Definitions && scope === self) {
+ node.definitions.forEach(function(def) {
+ if (def.value) {
+ initializations.add(def.name.name, def.value);
+ if (def.value.has_side_effects()) {
+ def.value.walk(tw);
+ }
+ }
+ });
+ return true;
+ }
+ if (node instanceof AST_SymbolRef) {
+ push_uniq(in_use, node.definition());
+ return true;
+ }
+ if (node instanceof AST_Scope) {
+ var save_scope = scope;
+ scope = node;
+ descend();
+ scope = save_scope;
+ return true;
+ }
+ }
+ });
+ self.walk(tw);
+ for (var i = 0; i < in_use.length; ++i) {
+ in_use[i].orig.forEach(function(decl) {
+ var init = initializations.get(decl.name);
+ if (init) init.forEach(function(init) {
+ var tw = new TreeWalker(function(node) {
+ if (node instanceof AST_SymbolRef) {
+ push_uniq(in_use, node.definition());
+ }
+ });
+ init.walk(tw);
+ });
+ });
+ }
+ var tt = new TreeTransformer(function before(node, descend, in_list) {
+ if (node instanceof AST_Lambda) {
+ for (var a = node.argnames, i = a.length; --i >= 0; ) {
+ var sym = a[i];
+ if (sym.unreferenced()) {
+ a.pop();
+ compressor.warn("Dropping unused function argument {name} [{file}:{line},{col}]", {
+ name: sym.name,
+ file: sym.start.file,
+ line: sym.start.line,
+ col: sym.start.col
+ });
+ } else break;
+ }
+ }
+ if (node instanceof AST_Defun && node !== self) {
+ if (!member(node.name.definition(), in_use)) {
+ compressor.warn("Dropping unused function {name} [{file}:{line},{col}]", {
+ name: node.name.name,
+ file: node.name.start.file,
+ line: node.name.start.line,
+ col: node.name.start.col
+ });
+ return make_node(AST_EmptyStatement, node);
+ }
+ return node;
+ }
+ if (node instanceof AST_Definitions && !(tt.parent() instanceof AST_ForIn)) {
+ var def = node.definitions.filter(function(def) {
+ if (member(def.name.definition(), in_use)) return true;
+ var w = {
+ name: def.name.name,
+ file: def.name.start.file,
+ line: def.name.start.line,
+ col: def.name.start.col
+ };
+ if (def.value && def.value.has_side_effects()) {
+ def._unused_side_effects = true;
+ compressor.warn("Side effects in initialization of unused variable {name} [{file}:{line},{col}]", w);
+ return true;
+ }
+ compressor.warn("Dropping unused variable {name} [{file}:{line},{col}]", w);
+ return false;
+ });
+ def = mergeSort(def, function(a, b) {
+ if (!a.value && b.value) return -1;
+ if (!b.value && a.value) return 1;
+ return 0;
+ });
+ var side_effects = [];
+ for (var i = 0; i < def.length; ) {
+ var x = def[i];
+ if (x._unused_side_effects) {
+ side_effects.push(x.value);
+ def.splice(i, 1);
+ } else {
+ if (side_effects.length > 0) {
+ side_effects.push(x.value);
+ x.value = AST_Seq.from_array(side_effects);
+ side_effects = [];
+ }
+ ++i;
+ }
+ }
+ if (side_effects.length > 0) {
+ side_effects = make_node(AST_BlockStatement, node, {
+ body: [ make_node(AST_SimpleStatement, node, {
+ body: AST_Seq.from_array(side_effects)
+ }) ]
+ });
+ } else {
+ side_effects = null;
+ }
+ if (def.length == 0 && !side_effects) {
+ return make_node(AST_EmptyStatement, node);
+ }
+ if (def.length == 0) {
+ return side_effects;
+ }
+ node.definitions = def;
+ if (side_effects) {
+ side_effects.body.unshift(node);
+ node = side_effects;
+ }
+ return node;
+ }
+ if (node instanceof AST_For && node.init instanceof AST_BlockStatement) {
+ descend(node, this);
+ var body = node.init.body.slice(0, -1);
+ node.init = node.init.body.slice(-1)[0].body;
+ body.push(node);
+ return in_list ? MAP.splice(body) : make_node(AST_BlockStatement, node, {
+ body: body
+ });
+ }
+ if (node instanceof AST_Scope && node !== self) return node;
+ });
+ self.transform(tt);
+ }
+ });
+ AST_Scope.DEFMETHOD("hoist_declarations", function(compressor) {
+ var hoist_funs = compressor.option("hoist_funs");
+ var hoist_vars = compressor.option("hoist_vars");
+ var self = this;
+ if (hoist_funs || hoist_vars) {
+ var dirs = [];
+ var hoisted = [];
+ var vars = new Dictionary(), vars_found = 0, var_decl = 0;
+ self.walk(new TreeWalker(function(node) {
+ if (node instanceof AST_Scope && node !== self) return true;
+ if (node instanceof AST_Var) {
+ ++var_decl;
+ return true;
+ }
+ }));
+ hoist_vars = hoist_vars && var_decl > 1;
+ var tt = new TreeTransformer(function before(node) {
+ if (node !== self) {
+ if (node instanceof AST_Directive) {
+ dirs.push(node);
+ return make_node(AST_EmptyStatement, node);
+ }
+ if (node instanceof AST_Defun && hoist_funs) {
+ hoisted.push(node);
+ return make_node(AST_EmptyStatement, node);
+ }
+ if (node instanceof AST_Var && hoist_vars) {
+ node.definitions.forEach(function(def) {
+ vars.set(def.name.name, def);
+ ++vars_found;
+ });
+ var seq = node.to_assignments();
+ var p = tt.parent();
+ if (p instanceof AST_ForIn && p.init === node) {
+ if (seq == null) return node.definitions[0].name;
+ return seq;
+ }
+ if (p instanceof AST_For && p.init === node) {
+ return seq;
+ }
+ if (!seq) return make_node(AST_EmptyStatement, node);
+ return make_node(AST_SimpleStatement, node, {
+ body: seq
+ });
+ }
+ if (node instanceof AST_Scope) return node;
+ }
+ });
+ self = self.transform(tt);
+ if (vars_found > 0) {
+ var defs = [];
+ vars.each(function(def, name) {
+ if (self instanceof AST_Lambda && find_if(function(x) {
+ return x.name == def.name.name;
+ }, self.argnames)) {
+ vars.del(name);
+ } else {
+ def = def.clone();
+ def.value = null;
+ defs.push(def);
+ vars.set(name, def);
+ }
+ });
+ if (defs.length > 0) {
+ for (var i = 0; i < self.body.length; ) {
+ if (self.body[i] instanceof AST_SimpleStatement) {
+ var expr = self.body[i].body, sym, assign;
+ if (expr instanceof AST_Assign && expr.operator == "=" && (sym = expr.left) instanceof AST_Symbol && vars.has(sym.name)) {
+ var def = vars.get(sym.name);
+ if (def.value) break;
+ def.value = expr.right;
+ remove(defs, def);
+ defs.push(def);
+ self.body.splice(i, 1);
+ continue;
+ }
+ if (expr instanceof AST_Seq && (assign = expr.car) instanceof AST_Assign && assign.operator == "=" && (sym = assign.left) instanceof AST_Symbol && vars.has(sym.name)) {
+ var def = vars.get(sym.name);
+ if (def.value) break;
+ def.value = assign.right;
+ remove(defs, def);
+ defs.push(def);
+ self.body[i].body = expr.cdr;
+ continue;
+ }
+ }
+ if (self.body[i] instanceof AST_EmptyStatement) {
+ self.body.splice(i, 1);
+ continue;
+ }
+ if (self.body[i] instanceof AST_BlockStatement) {
+ var tmp = [ i, 1 ].concat(self.body[i].body);
+ self.body.splice.apply(self.body, tmp);
+ continue;
+ }
+ break;
+ }
+ defs = make_node(AST_Var, self, {
+ definitions: defs
+ });
+ hoisted.push(defs);
+ }
+ }
+ self.body = dirs.concat(hoisted, self.body);
+ }
+ return self;
+ });
+ OPT(AST_SimpleStatement, function(self, compressor) {
+ if (compressor.option("side_effects")) {
+ if (!self.body.has_side_effects()) {
+ compressor.warn("Dropping side-effect-free statement [{file}:{line},{col}]", self.start);
+ return make_node(AST_EmptyStatement, self);
+ }
+ }
+ return self;
+ });
+ OPT(AST_DWLoop, function(self, compressor) {
+ var cond = self.condition.evaluate(compressor);
+ self.condition = cond[0];
+ if (!compressor.option("loops")) return self;
+ if (cond.length > 1) {
+ if (cond[1]) {
+ return make_node(AST_For, self, {
+ body: self.body
+ });
+ } else if (self instanceof AST_While) {
+ if (compressor.option("dead_code")) {
+ var a = [];
+ extract_declarations_from_unreachable_code(compressor, self.body, a);
+ return make_node(AST_BlockStatement, self, {
+ body: a
+ });
+ }
+ }
+ }
+ return self;
+ });
+ function if_break_in_loop(self, compressor) {
+ function drop_it(rest) {
+ rest = as_statement_array(rest);
+ if (self.body instanceof AST_BlockStatement) {
+ self.body = self.body.clone();
+ self.body.body = rest.concat(self.body.body.slice(1));
+ self.body = self.body.transform(compressor);
+ } else {
+ self.body = make_node(AST_BlockStatement, self.body, {
+ body: rest
+ }).transform(compressor);
+ }
+ if_break_in_loop(self, compressor);
+ }
+ var first = self.body instanceof AST_BlockStatement ? self.body.body[0] : self.body;
+ if (first instanceof AST_If) {
+ if (first.body instanceof AST_Break && compressor.loopcontrol_target(first.body.label) === self) {
+ if (self.condition) {
+ self.condition = make_node(AST_Binary, self.condition, {
+ left: self.condition,
+ operator: "&&",
+ right: first.condition.negate(compressor)
+ });
+ } else {
+ self.condition = first.condition.negate(compressor);
+ }
+ drop_it(first.alternative);
+ } else if (first.alternative instanceof AST_Break && compressor.loopcontrol_target(first.alternative.label) === self) {
+ if (self.condition) {
+ self.condition = make_node(AST_Binary, self.condition, {
+ left: self.condition,
+ operator: "&&",
+ right: first.condition
+ });
+ } else {
+ self.condition = first.condition;
+ }
+ drop_it(first.body);
+ }
+ }
+ }
+ OPT(AST_While, function(self, compressor) {
+ if (!compressor.option("loops")) return self;
+ self = AST_DWLoop.prototype.optimize.call(self, compressor);
+ if (self instanceof AST_While) {
+ if_break_in_loop(self, compressor);
+ self = make_node(AST_For, self, self).transform(compressor);
+ }
+ return self;
+ });
+ OPT(AST_For, function(self, compressor) {
+ var cond = self.condition;
+ if (cond) {
+ cond = cond.evaluate(compressor);
+ self.condition = cond[0];
+ }
+ if (!compressor.option("loops")) return self;
+ if (cond) {
+ if (cond.length > 1 && !cond[1]) {
+ if (compressor.option("dead_code")) {
+ var a = [];
+ if (self.init instanceof AST_Statement) {
+ a.push(self.init);
+ } else if (self.init) {
+ a.push(make_node(AST_SimpleStatement, self.init, {
+ body: self.init
+ }));
+ }
+ extract_declarations_from_unreachable_code(compressor, self.body, a);
+ return make_node(AST_BlockStatement, self, {
+ body: a
+ });
+ }
+ }
+ }
+ if_break_in_loop(self, compressor);
+ return self;
+ });
+ OPT(AST_If, function(self, compressor) {
+ if (!compressor.option("conditionals")) return self;
+ var cond = self.condition.evaluate(compressor);
+ self.condition = cond[0];
+ if (cond.length > 1) {
+ if (cond[1]) {
+ compressor.warn("Condition always true [{file}:{line},{col}]", self.condition.start);
+ if (compressor.option("dead_code")) {
+ var a = [];
+ if (self.alternative) {
+ extract_declarations_from_unreachable_code(compressor, self.alternative, a);
+ }
+ a.push(self.body);
+ return make_node(AST_BlockStatement, self, {
+ body: a
+ }).transform(compressor);
+ }
+ } else {
+ compressor.warn("Condition always false [{file}:{line},{col}]", self.condition.start);
+ if (compressor.option("dead_code")) {
+ var a = [];
+ extract_declarations_from_unreachable_code(compressor, self.body, a);
+ if (self.alternative) a.push(self.alternative);
+ return make_node(AST_BlockStatement, self, {
+ body: a
+ }).transform(compressor);
+ }
+ }
+ }
+ if (is_empty(self.alternative)) self.alternative = null;
+ var negated = self.condition.negate(compressor);
+ var negated_is_best = best_of(self.condition, negated) === negated;
+ if (self.alternative && negated_is_best) {
+ negated_is_best = false;
+ self.condition = negated;
+ var tmp = self.body;
+ self.body = self.alternative || make_node(AST_EmptyStatement);
+ self.alternative = tmp;
+ }
+ if (is_empty(self.body) && is_empty(self.alternative)) {
+ return make_node(AST_SimpleStatement, self.condition, {
+ body: self.condition
+ }).transform(compressor);
+ }
+ if (self.body instanceof AST_SimpleStatement && self.alternative instanceof AST_SimpleStatement) {
+ return make_node(AST_SimpleStatement, self, {
+ body: make_node(AST_Conditional, self, {
+ condition: self.condition,
+ consequent: self.body.body,
+ alternative: self.alternative.body
+ })
+ }).transform(compressor);
+ }
+ if (is_empty(self.alternative) && self.body instanceof AST_SimpleStatement) {
+ if (negated_is_best) return make_node(AST_SimpleStatement, self, {
+ body: make_node(AST_Binary, self, {
+ operator: "||",
+ left: negated,
+ right: self.body.body
+ })
+ }).transform(compressor);
+ return make_node(AST_SimpleStatement, self, {
+ body: make_node(AST_Binary, self, {
+ operator: "&&",
+ left: self.condition,
+ right: self.body.body
+ })
+ }).transform(compressor);
+ }
+ if (self.body instanceof AST_EmptyStatement && self.alternative && self.alternative instanceof AST_SimpleStatement) {
+ return make_node(AST_SimpleStatement, self, {
+ body: make_node(AST_Binary, self, {
+ operator: "||",
+ left: self.condition,
+ right: self.alternative.body
+ })
+ }).transform(compressor);
+ }
+ if (self.body instanceof AST_Exit && self.alternative instanceof AST_Exit && self.body.TYPE == self.alternative.TYPE) {
+ return make_node(self.body.CTOR, self, {
+ value: make_node(AST_Conditional, self, {
+ condition: self.condition,
+ consequent: self.body.value || make_node(AST_Undefined, self.body).optimize(compressor),
+ alternative: self.alternative.value || make_node(AST_Undefined, self.alternative).optimize(compressor)
+ })
+ }).transform(compressor);
+ }
+ if (self.body instanceof AST_If && !self.body.alternative && !self.alternative) {
+ self.condition = make_node(AST_Binary, self.condition, {
+ operator: "&&",
+ left: self.condition,
+ right: self.body.condition
+ }).transform(compressor);
+ self.body = self.body.body;
+ }
+ if (aborts(self.body)) {
+ if (self.alternative) {
+ var alt = self.alternative;
+ self.alternative = null;
+ return make_node(AST_BlockStatement, self, {
+ body: [ self, alt ]
+ }).transform(compressor);
+ }
+ }
+ if (aborts(self.alternative)) {
+ var body = self.body;
+ self.body = self.alternative;
+ self.condition = negated_is_best ? negated : self.condition.negate(compressor);
+ self.alternative = null;
+ return make_node(AST_BlockStatement, self, {
+ body: [ self, body ]
+ }).transform(compressor);
+ }
+ return self;
+ });
+ OPT(AST_Switch, function(self, compressor) {
+ if (self.body.length == 0 && compressor.option("conditionals")) {
+ return make_node(AST_SimpleStatement, self, {
+ body: self.expression
+ }).transform(compressor);
+ }
+ for (;;) {
+ var last_branch = self.body[self.body.length - 1];
+ if (last_branch) {
+ var stat = last_branch.body[last_branch.body.length - 1];
+ if (stat instanceof AST_Break && loop_body(compressor.loopcontrol_target(stat.label)) === self) last_branch.body.pop();
+ if (last_branch instanceof AST_Default && last_branch.body.length == 0) {
+ self.body.pop();
+ continue;
+ }
+ }
+ break;
+ }
+ var exp = self.expression.evaluate(compressor);
+ out: if (exp.length == 2) try {
+ self.expression = exp[0];
+ if (!compressor.option("dead_code")) break out;
+ var value = exp[1];
+ var in_if = false;
+ var in_block = false;
+ var started = false;
+ var stopped = false;
+ var ruined = false;
+ var tt = new TreeTransformer(function(node, descend, in_list) {
+ if (node instanceof AST_Lambda || node instanceof AST_SimpleStatement) {
+ return node;
+ } else if (node instanceof AST_Switch && node === self) {
+ node = node.clone();
+ descend(node, this);
+ return ruined ? node : make_node(AST_BlockStatement, node, {
+ body: node.body.reduce(function(a, branch) {
+ return a.concat(branch.body);
+ }, [])
+ }).transform(compressor);
+ } else if (node instanceof AST_If || node instanceof AST_Try) {
+ var save = in_if;
+ in_if = !in_block;
+ descend(node, this);
+ in_if = save;
+ return node;
+ } else if (node instanceof AST_StatementWithBody || node instanceof AST_Switch) {
+ var save = in_block;
+ in_block = true;
+ descend(node, this);
+ in_block = save;
+ return node;
+ } else if (node instanceof AST_Break && this.loopcontrol_target(node.label) === self) {
+ if (in_if) {
+ ruined = true;
+ return node;
+ }
+ if (in_block) return node;
+ stopped = true;
+ return in_list ? MAP.skip : make_node(AST_EmptyStatement, node);
+ } else if (node instanceof AST_SwitchBranch && this.parent() === self) {
+ if (stopped) return MAP.skip;
+ if (node instanceof AST_Case) {
+ var exp = node.expression.evaluate(compressor);
+ if (exp.length < 2) {
+ throw self;
+ }
+ if (exp[1] === value || started) {
+ started = true;
+ if (aborts(node)) stopped = true;
+ descend(node, this);
+ return node;
+ }
+ return MAP.skip;
+ }
+ descend(node, this);
+ return node;
+ }
+ });
+ tt.stack = compressor.stack.slice();
+ self = self.transform(tt);
+ } catch (ex) {
+ if (ex !== self) throw ex;
+ }
+ return self;
+ });
+ OPT(AST_Case, function(self, compressor) {
+ self.body = tighten_body(self.body, compressor);
+ return self;
+ });
+ OPT(AST_Try, function(self, compressor) {
+ self.body = tighten_body(self.body, compressor);
+ return self;
+ });
+ AST_Definitions.DEFMETHOD("remove_initializers", function() {
+ this.definitions.forEach(function(def) {
+ def.value = null;
+ });
+ });
+ AST_Definitions.DEFMETHOD("to_assignments", function() {
+ var assignments = this.definitions.reduce(function(a, def) {
+ if (def.value) {
+ var name = make_node(AST_SymbolRef, def.name, def.name);
+ a.push(make_node(AST_Assign, def, {
+ operator: "=",
+ left: name,
+ right: def.value
+ }));
+ }
+ return a;
+ }, []);
+ if (assignments.length == 0) return null;
+ return AST_Seq.from_array(assignments);
+ });
+ OPT(AST_Definitions, function(self, compressor) {
+ if (self.definitions.length == 0) return make_node(AST_EmptyStatement, self);
+ return self;
+ });
+ OPT(AST_Function, function(self, compressor) {
+ self = AST_Lambda.prototype.optimize.call(self, compressor);
+ if (compressor.option("unused")) {
+ if (self.name && self.name.unreferenced()) {
+ self.name = null;
+ }
+ }
+ return self;
+ });
+ OPT(AST_Call, function(self, compressor) {
+ if (compressor.option("unsafe")) {
+ var exp = self.expression;
+ if (exp instanceof AST_SymbolRef && exp.undeclared()) {
+ switch (exp.name) {
+ case "Array":
+ if (self.args.length != 1) {
+ return make_node(AST_Array, self, {
+ elements: self.args
+ });
+ }
+ break;
+
+ case "Object":
+ if (self.args.length == 0) {
+ return make_node(AST_Object, self, {
+ properties: []
+ });
+ }
+ break;
+
+ case "String":
+ if (self.args.length == 0) return make_node(AST_String, self, {
+ value: ""
+ });
+ return make_node(AST_Binary, self, {
+ left: self.args[0],
+ operator: "+",
+ right: make_node(AST_String, self, {
+ value: ""
+ })
+ });
+
+ case "Function":
+ if (all(self.args, function(x) {
+ return x instanceof AST_String;
+ })) {
+ try {
+ var code = "(function(" + self.args.slice(0, -1).map(function(arg) {
+ return arg.value;
+ }).join(",") + "){" + self.args[self.args.length - 1].value + "})()";
+ var ast = parse(code);
+ ast.figure_out_scope();
+ var comp = new Compressor(compressor.options);
+ ast = ast.transform(comp);
+ ast.figure_out_scope();
+ ast.mangle_names();
+ var fun = ast.body[0].body.expression;
+ var args = fun.argnames.map(function(arg, i) {
+ return make_node(AST_String, self.args[i], {
+ value: arg.print_to_string()
+ });
+ });
+ var code = OutputStream();
+ AST_BlockStatement.prototype._codegen.call(fun, fun, code);
+ code = code.toString().replace(/^\{|\}$/g, "");
+ args.push(make_node(AST_String, self.args[self.args.length - 1], {
+ value: code
+ }));
+ self.args = args;
+ return self;
+ } catch (ex) {
+ if (ex instanceof JS_Parse_Error) {
+ compressor.warn("Error parsing code passed to new Function [{file}:{line},{col}]", self.args[self.args.length - 1].start);
+ compressor.warn(ex.toString());
+ } else {
+ console.log(ex);
+ }
+ }
+ }
+ break;
+ }
+ } else if (exp instanceof AST_Dot && exp.property == "toString" && self.args.length == 0) {
+ return make_node(AST_Binary, self, {
+ left: make_node(AST_String, self, {
+ value: ""
+ }),
+ operator: "+",
+ right: exp.expression
+ }).transform(compressor);
+ }
+ }
+ if (compressor.option("side_effects")) {
+ if (self.expression instanceof AST_Function && self.args.length == 0 && !AST_Block.prototype.has_side_effects.call(self.expression)) {
+ return make_node(AST_Undefined, self).transform(compressor);
+ }
+ }
+ return self;
+ });
+ OPT(AST_New, function(self, compressor) {
+ if (compressor.option("unsafe")) {
+ var exp = self.expression;
+ if (exp instanceof AST_SymbolRef && exp.undeclared()) {
+ switch (exp.name) {
+ case "Object":
+ case "RegExp":
+ case "Function":
+ case "Error":
+ case "Array":
+ return make_node(AST_Call, self, self).transform(compressor);
+ }
+ }
+ }
+ return self;
+ });
+ OPT(AST_Seq, function(self, compressor) {
+ if (!compressor.option("side_effects")) return self;
+ if (!self.car.has_side_effects()) {
+ var p;
+ if (!(self.cdr instanceof AST_SymbolRef && self.cdr.name == "eval" && self.cdr.undeclared() && (p = compressor.parent()) instanceof AST_Call && p.expression === self)) {
+ return self.cdr;
+ }
+ }
+ if (compressor.option("cascade")) {
+ if (self.car instanceof AST_Assign && !self.car.left.has_side_effects() && self.car.left.equivalent_to(self.cdr)) {
+ return self.car;
+ }
+ if (!self.car.has_side_effects() && !self.cdr.has_side_effects() && self.car.equivalent_to(self.cdr)) {
+ return self.car;
+ }
+ }
+ return self;
+ });
+ AST_Unary.DEFMETHOD("lift_sequences", function(compressor) {
+ if (compressor.option("sequences")) {
+ if (this.expression instanceof AST_Seq) {
+ var seq = this.expression;
+ var x = seq.to_array();
+ this.expression = x.pop();
+ x.push(this);
+ seq = AST_Seq.from_array(x).transform(compressor);
+ return seq;
+ }
+ }
+ return this;
+ });
+ OPT(AST_UnaryPostfix, function(self, compressor) {
+ return self.lift_sequences(compressor);
+ });
+ OPT(AST_UnaryPrefix, function(self, compressor) {
+ self = self.lift_sequences(compressor);
+ var e = self.expression;
+ if (compressor.option("booleans") && compressor.in_boolean_context()) {
+ switch (self.operator) {
+ case "!":
+ if (e instanceof AST_UnaryPrefix && e.operator == "!") {
+ return e.expression;
+ }
+ break;
+
+ case "typeof":
+ compressor.warn("Boolean expression always true [{file}:{line},{col}]", self.start);
+ return make_node(AST_True, self);
+ }
+ if (e instanceof AST_Binary && self.operator == "!") {
+ self = best_of(self, e.negate(compressor));
+ }
+ }
+ return self.evaluate(compressor)[0];
+ });
+ AST_Binary.DEFMETHOD("lift_sequences", function(compressor) {
+ if (compressor.option("sequences")) {
+ if (this.left instanceof AST_Seq) {
+ var seq = this.left;
+ var x = seq.to_array();
+ this.left = x.pop();
+ x.push(this);
+ seq = AST_Seq.from_array(x).transform(compressor);
+ return seq;
+ }
+ if (this.right instanceof AST_Seq && !(this.operator == "||" || this.operator == "&&") && !this.left.has_side_effects()) {
+ var seq = this.right;
+ var x = seq.to_array();
+ this.right = x.pop();
+ x.push(this);
+ seq = AST_Seq.from_array(x).transform(compressor);
+ return seq;
+ }
+ }
+ return this;
+ });
+ var commutativeOperators = makePredicate("== === != !== * & | ^");
+ OPT(AST_Binary, function(self, compressor) {
+ function reverse(op, force) {
+ if (force || !(self.left.has_side_effects() || self.right.has_side_effects())) {
+ if (op) self.operator = op;
+ var tmp = self.left;
+ self.left = self.right;
+ self.right = tmp;
+ }
+ }
+ if (commutativeOperators(self.operator)) {
+ if (self.right instanceof AST_Constant && !(self.left instanceof AST_Constant)) {
+ reverse(null, true);
+ }
+ }
+ self = self.lift_sequences(compressor);
+ if (compressor.option("comparisons")) switch (self.operator) {
+ case "===":
+ case "!==":
+ if (self.left.is_string(compressor) && self.right.is_string(compressor) || self.left.is_boolean() && self.right.is_boolean()) {
+ self.operator = self.operator.substr(0, 2);
+ }
+
+ case "==":
+ case "!=":
+ if (self.left instanceof AST_String && self.left.value == "undefined" && self.right instanceof AST_UnaryPrefix && self.right.operator == "typeof" && compressor.option("unsafe")) {
+ if (!(self.right.expression instanceof AST_SymbolRef) || !self.right.expression.undeclared()) {
+ self.right = self.right.expression;
+ self.left = make_node(AST_Undefined, self.left).optimize(compressor);
+ if (self.operator.length == 2) self.operator += "=";
+ }
+ }
+ break;
+ }
+ if (compressor.option("booleans") && compressor.in_boolean_context()) switch (self.operator) {
+ case "&&":
+ var ll = self.left.evaluate(compressor);
+ var rr = self.right.evaluate(compressor);
+ if (ll.length > 1 && !ll[1] || rr.length > 1 && !rr[1]) {
+ compressor.warn("Boolean && always false [{file}:{line},{col}]", self.start);
+ return make_node(AST_False, self);
+ }
+ if (ll.length > 1 && ll[1]) {
+ return rr[0];
+ }
+ if (rr.length > 1 && rr[1]) {
+ return ll[0];
+ }
+ break;
+
+ case "||":
+ var ll = self.left.evaluate(compressor);
+ var rr = self.right.evaluate(compressor);
+ if (ll.length > 1 && ll[1] || rr.length > 1 && rr[1]) {
+ compressor.warn("Boolean || always true [{file}:{line},{col}]", self.start);
+ return make_node(AST_True, self);
+ }
+ if (ll.length > 1 && !ll[1]) {
+ return rr[0];
+ }
+ if (rr.length > 1 && !rr[1]) {
+ return ll[0];
+ }
+ break;
+
+ case "+":
+ var ll = self.left.evaluate(compressor);
+ var rr = self.right.evaluate(compressor);
+ if (ll.length > 1 && ll[0] instanceof AST_String && ll[1] || rr.length > 1 && rr[0] instanceof AST_String && rr[1]) {
+ compressor.warn("+ in boolean context always true [{file}:{line},{col}]", self.start);
+ return make_node(AST_True, self);
+ }
+ break;
+ }
+ var exp = self.evaluate(compressor);
+ if (exp.length > 1) {
+ if (best_of(exp[0], self) !== self) return exp[0];
+ }
+ if (compressor.option("comparisons")) {
+ if (!(compressor.parent() instanceof AST_Binary) || compressor.parent() instanceof AST_Assign) {
+ var negated = make_node(AST_UnaryPrefix, self, {
+ operator: "!",
+ expression: self.negate(compressor)
+ });
+ self = best_of(self, negated);
+ }
+ switch (self.operator) {
+ case "<":
+ reverse(">");
+ break;
+
+ case "<=":
+ reverse(">=");
+ break;
+ }
+ }
+ if (self.operator == "+" && self.right instanceof AST_String && self.right.getValue() === "" && self.left instanceof AST_Binary && self.left.operator == "+" && self.left.is_string(compressor)) {
+ return self.left;
+ }
+ return self;
+ });
+ OPT(AST_SymbolRef, function(self, compressor) {
+ if (self.undeclared()) {
+ var defines = compressor.option("global_defs");
+ if (defines && defines.hasOwnProperty(self.name)) {
+ return make_node_from_constant(compressor, defines[self.name], self);
+ }
+ switch (self.name) {
+ case "undefined":
+ return make_node(AST_Undefined, self);
+
+ case "NaN":
+ return make_node(AST_NaN, self);
+
+ case "Infinity":
+ return make_node(AST_Infinity, self);
+ }
+ }
+ return self;
+ });
+ OPT(AST_Undefined, function(self, compressor) {
+ if (compressor.option("unsafe")) {
+ var scope = compressor.find_parent(AST_Scope);
+ var undef = scope.find_variable("undefined");
+ if (undef) {
+ var ref = make_node(AST_SymbolRef, self, {
+ name: "undefined",
+ scope: scope,
+ thedef: undef
+ });
+ ref.reference();
+ return ref;
+ }
+ }
+ return self;
+ });
+ var ASSIGN_OPS = [ "+", "-", "/", "*", "%", ">>", "<<", ">>>", "|", "^", "&" ];
+ OPT(AST_Assign, function(self, compressor) {
+ self = self.lift_sequences(compressor);
+ if (self.operator == "=" && self.left instanceof AST_SymbolRef && self.right instanceof AST_Binary && self.right.left instanceof AST_SymbolRef && self.right.left.name == self.left.name && member(self.right.operator, ASSIGN_OPS)) {
+ self.operator = self.right.operator + "=";
+ self.right = self.right.right;
+ }
+ return self;
+ });
+ OPT(AST_Conditional, function(self, compressor) {
+ if (!compressor.option("conditionals")) return self;
+ if (self.condition instanceof AST_Seq) {
+ var car = self.condition.car;
+ self.condition = self.condition.cdr;
+ return AST_Seq.cons(car, self);
+ }
+ var cond = self.condition.evaluate(compressor);
+ if (cond.length > 1) {
+ if (cond[1]) {
+ compressor.warn("Condition always true [{file}:{line},{col}]", self.start);
+ return self.consequent;
+ } else {
+ compressor.warn("Condition always false [{file}:{line},{col}]", self.start);
+ return self.alternative;
+ }
+ }
+ var negated = cond[0].negate(compressor);
+ if (best_of(cond[0], negated) === negated) {
+ self = make_node(AST_Conditional, self, {
+ condition: negated,
+ consequent: self.alternative,
+ alternative: self.consequent
+ });
+ }
+ var consequent = self.consequent;
+ var alternative = self.alternative;
+ if (consequent instanceof AST_Assign && alternative instanceof AST_Assign && consequent.operator == alternative.operator && consequent.left.equivalent_to(alternative.left)) {
+ self = make_node(AST_Assign, self, {
+ operator: consequent.operator,
+ left: consequent.left,
+ right: make_node(AST_Conditional, self, {
+ condition: self.condition,
+ consequent: consequent.right,
+ alternative: alternative.right
+ })
+ });
+ }
+ return self;
+ });
+ OPT(AST_Boolean, function(self, compressor) {
+ if (compressor.option("booleans")) {
+ var p = compressor.parent();
+ if (p instanceof AST_Binary && (p.operator == "==" || p.operator == "!=")) {
+ compressor.warn("Non-strict equality against boolean: {operator} {value} [{file}:{line},{col}]", {
+ operator: p.operator,
+ value: self.value,
+ file: p.start.file,
+ line: p.start.line,
+ col: p.start.col
+ });
+ return make_node(AST_Number, self, {
+ value: +self.value
+ });
+ }
+ return make_node(AST_UnaryPrefix, self, {
+ operator: "!",
+ expression: make_node(AST_Number, self, {
+ value: 1 - self.value
+ })
+ });
+ }
+ return self;
+ });
+ OPT(AST_Sub, function(self, compressor) {
+ var prop = self.property;
+ if (prop instanceof AST_String && compressor.option("properties")) {
+ prop = prop.getValue();
+ if (compressor.option("screw_ie8") && RESERVED_WORDS(prop) || !RESERVED_WORDS(prop) && is_identifier_string(prop)) {
+ return make_node(AST_Dot, self, {
+ expression: self.expression,
+ property: prop
+ });
+ }
+ }
+ return self;
+ });
+ function literals_in_boolean_context(self, compressor) {
+ if (compressor.option("booleans") && compressor.in_boolean_context()) {
+ return make_node(AST_True, self);
+ }
+ return self;
+ }
+ OPT(AST_Array, literals_in_boolean_context);
+ OPT(AST_Object, literals_in_boolean_context);
+ OPT(AST_RegExp, literals_in_boolean_context);
+ })();
+ "use strict";
+ function SourceMap(options) {
+ options = defaults(options, {
+ file: null,
+ root: null,
+ orig: null
+ });
+ var generator = new MOZ_SourceMap.SourceMapGenerator({
+ file: options.file,
+ sourceRoot: options.root
+ });
+ var orig_map = options.orig && new MOZ_SourceMap.SourceMapConsumer(options.orig);
+ function add(source, gen_line, gen_col, orig_line, orig_col, name) {
+ if (orig_map) {
+ var info = orig_map.originalPositionFor({
+ line: orig_line,
+ column: orig_col
+ });
+ source = info.source;
+ orig_line = info.line;
+ orig_col = info.column;
+ name = info.name;
+ }
+ generator.addMapping({
+ generated: {
+ line: gen_line,
+ column: gen_col
+ },
+ original: {
+ line: orig_line,
+ column: orig_col
+ },
+ source: source,
+ name: name
+ });
+ }
+ return {
+ add: add,
+ get: function() {
+ return generator;
+ },
+ toString: function() {
+ return generator.toString();
+ }
+ };
+ }
+ "use strict";
+ (function() {
+ var MOZ_TO_ME = {
+ TryStatement: function(M) {
+ return new AST_Try({
+ start: my_start_token(M),
+ end: my_end_token(M),
+ body: from_moz(M.block).body,
+ bcatch: from_moz(M.handlers[0]),
+ bfinally: M.finalizer ? new AST_Finally(from_moz(M.finalizer)) : null
+ });
+ },
+ CatchClause: function(M) {
+ return new AST_Catch({
+ start: my_start_token(M),
+ end: my_end_token(M),
+ argname: from_moz(M.param),
+ body: from_moz(M.body).body
+ });
+ },
+ ObjectExpression: function(M) {
+ return new AST_Object({
+ start: my_start_token(M),
+ end: my_end_token(M),
+ properties: M.properties.map(function(prop) {
+ var key = prop.key;
+ var name = key.type == "Identifier" ? key.name : key.value;
+ var args = {
+ start: my_start_token(key),
+ end: my_end_token(prop.value),
+ key: name,
+ value: from_moz(prop.value)
+ };
+ switch (prop.kind) {
+ case "init":
+ return new AST_ObjectKeyVal(args);
+
+ case "set":
+ args.value.name = from_moz(key);
+ return new AST_ObjectSetter(args);
+
+ case "get":
+ args.value.name = from_moz(key);
+ return new AST_ObjectGetter(args);
+ }
+ })
+ });
+ },
+ SequenceExpression: function(M) {
+ return AST_Seq.from_array(M.expressions.map(from_moz));
+ },
+ MemberExpression: function(M) {
+ return new (M.computed ? AST_Sub : AST_Dot)({
+ start: my_start_token(M),
+ end: my_end_token(M),
+ property: M.computed ? from_moz(M.property) : M.property.name,
+ expression: from_moz(M.object)
+ });
+ },
+ SwitchCase: function(M) {
+ return new (M.test ? AST_Case : AST_Default)({
+ start: my_start_token(M),
+ end: my_end_token(M),
+ expression: from_moz(M.test),
+ body: M.consequent.map(from_moz)
+ });
+ },
+ Literal: function(M) {
+ var val = M.value, args = {
+ start: my_start_token(M),
+ end: my_end_token(M)
+ };
+ if (val === null) return new AST_Null(args);
+ switch (typeof val) {
+ case "string":
+ args.value = val;
+ return new AST_String(args);
+
+ case "number":
+ args.value = val;
+ return new AST_Number(args);
+
+ case "boolean":
+ return new (val ? AST_True : AST_False)(args);
+
+ default:
+ args.value = val;
+ return new AST_RegExp(args);
+ }
+ },
+ UnaryExpression: From_Moz_Unary,
+ UpdateExpression: From_Moz_Unary,
+ Identifier: function(M) {
+ var p = FROM_MOZ_STACK[FROM_MOZ_STACK.length - 2];
+ return new (M.name == "this" ? AST_This : p.type == "LabeledStatement" ? AST_Label : p.type == "VariableDeclarator" && p.id === M ? p.kind == "const" ? AST_SymbolConst : AST_SymbolVar : p.type == "FunctionExpression" ? p.id === M ? AST_SymbolLambda : AST_SymbolFunarg : p.type == "FunctionDeclaration" ? p.id === M ? AST_SymbolDefun : AST_SymbolFunarg : p.type == "CatchClause" ? AST_SymbolCatch : p.type == "BreakStatement" || p.type == "ContinueStatement" ? AST_LabelRef : AST_SymbolRef)({
+ start: my_start_token(M),
+ end: my_end_token(M),
+ name: M.name
+ });
+ }
+ };
+ function From_Moz_Unary(M) {
+ var prefix = "prefix" in M ? M.prefix : M.type == "UnaryExpression" ? true : false;
+ return new (prefix ? AST_UnaryPrefix : AST_UnaryPostfix)({
+ start: my_start_token(M),
+ end: my_end_token(M),
+ operator: M.operator,
+ expression: from_moz(M.argument)
+ });
+ }
+ var ME_TO_MOZ = {};
+ map("Node", AST_Node);
+ map("Program", AST_Toplevel, "body@body");
+ map("Function", AST_Function, "id>name, params@argnames, body%body");
+ map("EmptyStatement", AST_EmptyStatement);
+ map("BlockStatement", AST_BlockStatement, "body@body");
+ map("ExpressionStatement", AST_SimpleStatement, "expression>body");
+ map("IfStatement", AST_If, "test>condition, consequent>body, alternate>alternative");
+ map("LabeledStatement", AST_LabeledStatement, "label>label, body>body");
+ map("BreakStatement", AST_Break, "label>label");
+ map("ContinueStatement", AST_Continue, "label>label");
+ map("WithStatement", AST_With, "object>expression, body>body");
+ map("SwitchStatement", AST_Switch, "discriminant>expression, cases@body");
+ map("ReturnStatement", AST_Return, "argument>value");
+ map("ThrowStatement", AST_Throw, "argument>value");
+ map("WhileStatement", AST_While, "test>condition, body>body");
+ map("DoWhileStatement", AST_Do, "test>condition, body>body");
+ map("ForStatement", AST_For, "init>init, test>condition, update>step, body>body");
+ map("ForInStatement", AST_ForIn, "left>init, right>object, body>body");
+ map("DebuggerStatement", AST_Debugger);
+ map("FunctionDeclaration", AST_Defun, "id>name, params@argnames, body%body");
+ map("VariableDeclaration", AST_Var, "declarations@definitions");
+ map("VariableDeclarator", AST_VarDef, "id>name, init>value");
+ map("ThisExpression", AST_This);
+ map("ArrayExpression", AST_Array, "elements@elements");
+ map("FunctionExpression", AST_Function, "id>name, params@argnames, body%body");
+ map("BinaryExpression", AST_Binary, "operator=operator, left>left, right>right");
+ map("AssignmentExpression", AST_Assign, "operator=operator, left>left, right>right");
+ map("LogicalExpression", AST_Binary, "operator=operator, left>left, right>right");
+ map("ConditionalExpression", AST_Conditional, "test>condition, consequent>consequent, alternate>alternative");
+ map("NewExpression", AST_New, "callee>expression, arguments@args");
+ map("CallExpression", AST_Call, "callee>expression, arguments@args");
+ function my_start_token(moznode) {
+ return new AST_Token({
+ file: moznode.loc && moznode.loc.source,
+ line: moznode.loc && moznode.loc.start.line,
+ col: moznode.loc && moznode.loc.start.column,
+ pos: moznode.start,
+ endpos: moznode.start
+ });
+ }
+ function my_end_token(moznode) {
+ return new AST_Token({
+ file: moznode.loc && moznode.loc.source,
+ line: moznode.loc && moznode.loc.end.line,
+ col: moznode.loc && moznode.loc.end.column,
+ pos: moznode.end,
+ endpos: moznode.end
+ });
+ }
+ function map(moztype, mytype, propmap) {
+ var moz_to_me = "function From_Moz_" + moztype + "(M){\n";
+ moz_to_me += "return new mytype({\n" + "start: my_start_token(M),\n" + "end: my_end_token(M)";
+ if (propmap) propmap.split(/\s*,\s*/).forEach(function(prop) {
+ var m = /([a-z0-9$_]+)(=|@|>|%)([a-z0-9$_]+)/i.exec(prop);
+ if (!m) throw new Error("Can't understand property map: " + prop);
+ var moz = "M." + m[1], how = m[2], my = m[3];
+ moz_to_me += ",\n" + my + ": ";
+ if (how == "@") {
+ moz_to_me += moz + ".map(from_moz)";
+ } else if (how == ">") {
+ moz_to_me += "from_moz(" + moz + ")";
+ } else if (how == "=") {
+ moz_to_me += moz;
+ } else if (how == "%") {
+ moz_to_me += "from_moz(" + moz + ").body";
+ } else throw new Error("Can't understand operator in propmap: " + prop);
+ });
+ moz_to_me += "\n})}";
+ moz_to_me = new Function("mytype", "my_start_token", "my_end_token", "from_moz", "return(" + moz_to_me + ")")(mytype, my_start_token, my_end_token, from_moz);
+ return MOZ_TO_ME[moztype] = moz_to_me;
+ }
+ var FROM_MOZ_STACK = null;
+ function from_moz(node) {
+ FROM_MOZ_STACK.push(node);
+ var ret = node != null ? MOZ_TO_ME[node.type](node) : null;
+ FROM_MOZ_STACK.pop();
+ return ret;
+ }
+ AST_Node.from_mozilla_ast = function(node) {
+ var save_stack = FROM_MOZ_STACK;
+ FROM_MOZ_STACK = [];
+ var ast = from_moz(node);
+ FROM_MOZ_STACK = save_stack;
+ return ast;
+ };
+ })();
+ exports["array_to_hash"] = array_to_hash;
+ exports["slice"] = slice;
+ exports["characters"] = characters;
+ exports["member"] = member;
+ exports["find_if"] = find_if;
+ exports["repeat_string"] = repeat_string;
+ exports["DefaultsError"] = DefaultsError;
+ exports["defaults"] = defaults;
+ exports["merge"] = merge;
+ exports["noop"] = noop;
+ exports["MAP"] = MAP;
+ exports["push_uniq"] = push_uniq;
+ exports["string_template"] = string_template;
+ exports["remove"] = remove;
+ exports["mergeSort"] = mergeSort;
+ exports["set_difference"] = set_difference;
+ exports["set_intersection"] = set_intersection;
+ exports["makePredicate"] = makePredicate;
+ exports["all"] = all;
+ exports["Dictionary"] = Dictionary;
+ exports["DEFNODE"] = DEFNODE;
+ exports["AST_Token"] = AST_Token;
+ exports["AST_Node"] = AST_Node;
+ exports["AST_Statement"] = AST_Statement;
+ exports["AST_Debugger"] = AST_Debugger;
+ exports["AST_Directive"] = AST_Directive;
+ exports["AST_SimpleStatement"] = AST_SimpleStatement;
+ exports["walk_body"] = walk_body;
+ exports["AST_Block"] = AST_Block;
+ exports["AST_BlockStatement"] = AST_BlockStatement;
+ exports["AST_EmptyStatement"] = AST_EmptyStatement;
+ exports["AST_StatementWithBody"] = AST_StatementWithBody;
+ exports["AST_LabeledStatement"] = AST_LabeledStatement;
+ exports["AST_DWLoop"] = AST_DWLoop;
+ exports["AST_Do"] = AST_Do;
+ exports["AST_While"] = AST_While;
+ exports["AST_For"] = AST_For;
+ exports["AST_ForIn"] = AST_ForIn;
+ exports["AST_With"] = AST_With;
+ exports["AST_Scope"] = AST_Scope;
+ exports["AST_Toplevel"] = AST_Toplevel;
+ exports["AST_Lambda"] = AST_Lambda;
+ exports["AST_Accessor"] = AST_Accessor;
+ exports["AST_Function"] = AST_Function;
+ exports["AST_Defun"] = AST_Defun;
+ exports["AST_Jump"] = AST_Jump;
+ exports["AST_Exit"] = AST_Exit;
+ exports["AST_Return"] = AST_Return;
+ exports["AST_Throw"] = AST_Throw;
+ exports["AST_LoopControl"] = AST_LoopControl;
+ exports["AST_Break"] = AST_Break;
+ exports["AST_Continue"] = AST_Continue;
+ exports["AST_If"] = AST_If;
+ exports["AST_Switch"] = AST_Switch;
+ exports["AST_SwitchBranch"] = AST_SwitchBranch;
+ exports["AST_Default"] = AST_Default;
+ exports["AST_Case"] = AST_Case;
+ exports["AST_Try"] = AST_Try;
+ exports["AST_Catch"] = AST_Catch;
+ exports["AST_Finally"] = AST_Finally;
+ exports["AST_Definitions"] = AST_Definitions;
+ exports["AST_Var"] = AST_Var;
+ exports["AST_Const"] = AST_Const;
+ exports["AST_VarDef"] = AST_VarDef;
+ exports["AST_Call"] = AST_Call;
+ exports["AST_New"] = AST_New;
+ exports["AST_Seq"] = AST_Seq;
+ exports["AST_PropAccess"] = AST_PropAccess;
+ exports["AST_Dot"] = AST_Dot;
+ exports["AST_Sub"] = AST_Sub;
+ exports["AST_Unary"] = AST_Unary;
+ exports["AST_UnaryPrefix"] = AST_UnaryPrefix;
+ exports["AST_UnaryPostfix"] = AST_UnaryPostfix;
+ exports["AST_Binary"] = AST_Binary;
+ exports["AST_Conditional"] = AST_Conditional;
+ exports["AST_Assign"] = AST_Assign;
+ exports["AST_Array"] = AST_Array;
+ exports["AST_Object"] = AST_Object;
+ exports["AST_ObjectProperty"] = AST_ObjectProperty;
+ exports["AST_ObjectKeyVal"] = AST_ObjectKeyVal;
+ exports["AST_ObjectSetter"] = AST_ObjectSetter;
+ exports["AST_ObjectGetter"] = AST_ObjectGetter;
+ exports["AST_Symbol"] = AST_Symbol;
+ exports["AST_SymbolAccessor"] = AST_SymbolAccessor;
+ exports["AST_SymbolDeclaration"] = AST_SymbolDeclaration;
+ exports["AST_SymbolVar"] = AST_SymbolVar;
+ exports["AST_SymbolConst"] = AST_SymbolConst;
+ exports["AST_SymbolFunarg"] = AST_SymbolFunarg;
+ exports["AST_SymbolDefun"] = AST_SymbolDefun;
+ exports["AST_SymbolLambda"] = AST_SymbolLambda;
+ exports["AST_SymbolCatch"] = AST_SymbolCatch;
+ exports["AST_Label"] = AST_Label;
+ exports["AST_SymbolRef"] = AST_SymbolRef;
+ exports["AST_LabelRef"] = AST_LabelRef;
+ exports["AST_This"] = AST_This;
+ exports["AST_Constant"] = AST_Constant;
+ exports["AST_String"] = AST_String;
+ exports["AST_Number"] = AST_Number;
+ exports["AST_RegExp"] = AST_RegExp;
+ exports["AST_Atom"] = AST_Atom;
+ exports["AST_Null"] = AST_Null;
+ exports["AST_NaN"] = AST_NaN;
+ exports["AST_Undefined"] = AST_Undefined;
+ exports["AST_Hole"] = AST_Hole;
+ exports["AST_Infinity"] = AST_Infinity;
+ exports["AST_Boolean"] = AST_Boolean;
+ exports["AST_False"] = AST_False;
+ exports["AST_True"] = AST_True;
+ exports["TreeWalker"] = TreeWalker;
+ exports["KEYWORDS"] = KEYWORDS;
+ exports["KEYWORDS_ATOM"] = KEYWORDS_ATOM;
+ exports["RESERVED_WORDS"] = RESERVED_WORDS;
+ exports["KEYWORDS_BEFORE_EXPRESSION"] = KEYWORDS_BEFORE_EXPRESSION;
+ exports["OPERATOR_CHARS"] = OPERATOR_CHARS;
+ exports["RE_HEX_NUMBER"] = RE_HEX_NUMBER;
+ exports["RE_OCT_NUMBER"] = RE_OCT_NUMBER;
+ exports["RE_DEC_NUMBER"] = RE_DEC_NUMBER;
+ exports["OPERATORS"] = OPERATORS;
+ exports["WHITESPACE_CHARS"] = WHITESPACE_CHARS;
+ exports["PUNC_BEFORE_EXPRESSION"] = PUNC_BEFORE_EXPRESSION;
+ exports["PUNC_CHARS"] = PUNC_CHARS;
+ exports["REGEXP_MODIFIERS"] = REGEXP_MODIFIERS;
+ exports["UNICODE"] = UNICODE;
+ exports["is_letter"] = is_letter;
+ exports["is_digit"] = is_digit;
+ exports["is_alphanumeric_char"] = is_alphanumeric_char;
+ exports["is_unicode_combining_mark"] = is_unicode_combining_mark;
+ exports["is_unicode_connector_punctuation"] = is_unicode_connector_punctuation;
+ exports["is_identifier"] = is_identifier;
+ exports["is_identifier_start"] = is_identifier_start;
+ exports["is_identifier_char"] = is_identifier_char;
+ exports["is_identifier_string"] = is_identifier_string;
+ exports["parse_js_number"] = parse_js_number;
+ exports["JS_Parse_Error"] = JS_Parse_Error;
+ exports["js_error"] = js_error;
+ exports["is_token"] = is_token;
+ exports["EX_EOF"] = EX_EOF;
+ exports["tokenizer"] = tokenizer;
+ exports["UNARY_PREFIX"] = UNARY_PREFIX;
+ exports["UNARY_POSTFIX"] = UNARY_POSTFIX;
+ exports["ASSIGNMENT"] = ASSIGNMENT;
+ exports["PRECEDENCE"] = PRECEDENCE;
+ exports["STATEMENTS_WITH_LABELS"] = STATEMENTS_WITH_LABELS;
+ exports["ATOMIC_START_TOKEN"] = ATOMIC_START_TOKEN;
+ exports["parse"] = parse;
+ exports["TreeTransformer"] = TreeTransformer;
+ exports["SymbolDef"] = SymbolDef;
+ exports["base54"] = base54;
+ exports["OutputStream"] = OutputStream;
+ exports["Compressor"] = Compressor;
+ exports["SourceMap"] = SourceMap;
+})({}, function() {
+ return exports;
+}());
+
+var UglifyJS = exports.UglifyJS;
+
+UglifyJS.AST_Node.warn_function = function(txt) {
+ logger.error("uglifyjs2 WARN: " + txt);
+};
+
+//JRB: MODIFIED FROM UGLIFY SOURCE
+//to take a name for the file, and then set toplevel.filename to be that name.
+exports.minify = function(files, options, name) {
+ options = UglifyJS.defaults(options, {
+ outSourceMap : null,
+ sourceRoot : null,
+ inSourceMap : null,
+ fromString : false,
+ warnings : false,
+ mangle : {},
+ output : null,
+ compress : {}
+ });
+ if (typeof files == "string")
+ files = [ files ];
+
+ // 1. parse
+ var toplevel = null;
+ files.forEach(function(file){
+ var code = options.fromString
+ ? file
+ : rjsFile.readFile(file, "utf8");
+ toplevel = UglifyJS.parse(code, {
+ filename: options.fromString ? name : file,
+ toplevel: toplevel
+ });
+ });
+
+ // 2. compress
+ if (options.compress) {
+ var compress = { warnings: options.warnings };
+ UglifyJS.merge(compress, options.compress);
+ toplevel.figure_out_scope();
+ var sq = UglifyJS.Compressor(compress);
+ toplevel = toplevel.transform(sq);
+ }
+
+ // 3. mangle
+ if (options.mangle) {
+ toplevel.figure_out_scope();
+ toplevel.compute_char_frequency();
+ toplevel.mangle_names(options.mangle);
+ }
+
+ // 4. output
+ var map = null;
+ var inMap = null;
+ if (options.inSourceMap) {
+ inMap = rjsFile.readFile(options.inSourceMap, "utf8");
+ }
+ if (options.outSourceMap) map = UglifyJS.SourceMap({
+ file: options.outSourceMap,
+ orig: inMap,
+ root: options.sourceRoot
+ });
+ var output = { source_map: map };
+ if (options.output) {
+ UglifyJS.merge(output, options.output);
+ }
+ var stream = UglifyJS.OutputStream(output);
+ toplevel.print(stream);
+ return {
+ code : stream + "",
+ map : map + ""
+ };
+};
+
+// exports.describe_ast = function() {
+// function doitem(ctor) {
+// var sub = {};
+// ctor.SUBCLASSES.forEach(function(ctor){
+// sub[ctor.TYPE] = doitem(ctor);
+// });
+// var ret = {};
+// if (ctor.SELF_PROPS.length > 0) ret.props = ctor.SELF_PROPS;
+// if (ctor.SUBCLASSES.length > 0) ret.sub = sub;
+// return ret;
+// }
+// return doitem(UglifyJS.AST_Node).sub;
+// }
+
+exports.describe_ast = function() {
+ var out = UglifyJS.OutputStream({ beautify: true });
+ function doitem(ctor) {
+ out.print("AST_" + ctor.TYPE);
+ var props = ctor.SELF_PROPS.filter(function(prop){
+ return !/^\$/.test(prop);
+ });
+ if (props.length > 0) {
+ out.space();
+ out.with_parens(function(){
+ props.forEach(function(prop, i){
+ if (i) out.space();
+ out.print(prop);
+ });
+ });
+ }
+ if (ctor.documentation) {
+ out.space();
+ out.print_string(ctor.documentation);
+ }
+ if (ctor.SUBCLASSES.length > 0) {
+ out.space();
+ out.with_block(function(){
+ ctor.SUBCLASSES.forEach(function(ctor, i){
+ out.indent();
+ doitem(ctor);
+ out.newline();
+ });
+ });
+ }
+ };
+ doitem(UglifyJS.AST_Node);
+ return out + "";
+};
+
+});
+/**
+ * @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: false */
+
+define('parse', ['./esprimaAdapter', 'lang'], function (esprima, lang) {
+ 'use strict';
+
+ function arrayToString(ary) {
+ var output = '[';
+ if (ary) {
+ ary.forEach(function (item, i) {
+ output += (i > 0 ? ',' : '') + '"' + lang.jsEscape(item) + '"';
+ });
+ }
+ output += ']';
+
+ return output;
+ }
+
+ //This string is saved off because JSLint complains
+ //about obj.arguments use, as 'reserved word'
+ var argPropName = 'arguments';
+
+ //From an esprima example for traversing its ast.
+ function traverse(object, visitor) {
+ var key, child;
+
+ if (!object) {
+ return;
+ }
+
+ if (visitor.call(null, object) === false) {
+ return false;
+ }
+ for (key in object) {
+ if (object.hasOwnProperty(key)) {
+ child = object[key];
+ if (typeof child === 'object' && child !== null) {
+ if (traverse(child, visitor) === false) {
+ return false;
+ }
+ }
+ }
+ }
+ }
+
+ //Like traverse, but visitor returning false just
+ //stops that subtree analysis, not the rest of tree
+ //visiting.
+ function traverseBroad(object, visitor) {
+ var key, child;
+
+ if (!object) {
+ return;
+ }
+
+ if (visitor.call(null, object) === false) {
+ return false;
+ }
+ for (key in object) {
+ if (object.hasOwnProperty(key)) {
+ child = object[key];
+ if (typeof child === 'object' && child !== null) {
+ traverse(child, visitor);
+ }
+ }
+ }
+ }
+
+ /**
+ * Pulls out dependencies from an array literal with just string members.
+ * If string literals, will just return those string values in an array,
+ * skipping other items in the array.
+ *
+ * @param {Node} node an AST node.
+ *
+ * @returns {Array} an array of strings.
+ * If null is returned, then it means the input node was not a valid
+ * dependency.
+ */
+ function getValidDeps(node) {
+ if (!node || node.type !== 'ArrayExpression' || !node.elements) {
+ return;
+ }
+
+ var deps = [];
+
+ node.elements.some(function (elem) {
+ if (elem.type === 'Literal') {
+ deps.push(elem.value);
+ }
+ });
+
+ return deps.length ? deps : undefined;
+ }
+
+ /**
+ * 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.
+ */
+ function parse(moduleName, fileName, fileContents, options) {
+ options = options || {};
+
+ //Set up source input
+ var i, moduleCall, depString,
+ moduleDeps = [],
+ result = '',
+ moduleList = [],
+ needsDefine = true,
+ astRoot = esprima.parse(fileContents);
+
+ parse.recurse(astRoot, function (callName, config, name, deps) {
+ if (!deps) {
+ deps = [];
+ }
+
+ if (callName === 'define' && (!name || name === moduleName)) {
+ needsDefine = false;
+ }
+
+ if (!name) {
+ //If there is no module name, the dependencies are for
+ //this file/default module name.
+ moduleDeps = moduleDeps.concat(deps);
+ } else {
+ moduleList.push({
+ name: name,
+ deps: deps
+ });
+ }
+
+ //If define was found, no need to dive deeper, unless
+ //the config explicitly wants to dig deeper.
+ return !!options.findNestedDependencies;
+ }, options);
+
+ if (options.insertNeedsDefine && needsDefine) {
+ result += 'require.needsDefine("' + moduleName + '");';
+ }
+
+ if (moduleDeps.length || moduleList.length) {
+ for (i = 0; i < moduleList.length; i++) {
+ moduleCall = moduleList[i];
+ 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.
+ if (moduleCall.name === moduleName) {
+ moduleCall.deps = moduleCall.deps.concat(moduleDeps);
+ moduleDeps = [];
+ }
+
+ depString = arrayToString(moduleCall.deps);
+ result += 'define("' + moduleCall.name + '",' +
+ depString + ');';
+ }
+ if (moduleDeps.length) {
+ if (result) {
+ result += '\n';
+ }
+ depString = arrayToString(moduleDeps);
+ result += 'define("' + moduleName + '",' + depString + ');';
+ }
+ }
+
+ return result || null;
+ }
+
+ parse.traverse = traverse;
+ parse.traverseBroad = traverseBroad;
+
+ /**
+ * 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.
+ */
+ parse.recurse = function (object, onMatch, options) {
+ //Like traverse, but skips if branches that would not be processed
+ //after has application that results in tests of true or false boolean
+ //literal values.
+ var key, child,
+ hasHas = options && options.has;
+
+ if (!object) {
+ return;
+ }
+
+ //If has replacement has resulted in if(true){} or if(false){}, take
+ //the appropriate branch and skip the other one.
+ if (hasHas && object.type === 'IfStatement' && object.test.type &&
+ object.test.type === 'Literal') {
+ if (object.test.value) {
+ //Take the if branch
+ this.recurse(object.consequent, onMatch, options);
+ } else {
+ //Take the else branch
+ this.recurse(object.alternate, onMatch, options);
+ }
+ } else {
+ if (this.parseNode(object, onMatch) === false) {
+ return;
+ }
+ for (key in object) {
+ if (object.hasOwnProperty(key)) {
+ child = object[key];
+ if (typeof child === 'object' && child !== null) {
+ this.recurse(child, onMatch, options);
+ }
+ }
+ }
+ }
+ };
+
+ /**
+ * Determines if the file defines the require/define module API.
+ * Specifically, it looks for the `define.amd = ` expression.
+ * @param {String} fileName
+ * @param {String} fileContents
+ * @returns {Boolean}
+ */
+ parse.definesRequire = function (fileName, fileContents) {
+ var found = false;
+
+ traverse(esprima.parse(fileContents), function (node) {
+ if (parse.hasDefineAmd(node)) {
+ found = true;
+
+ //Stop traversal
+ return false;
+ }
+ });
+
+ return found;
+ };
+
+ /**
+ * 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|Object} fileContents: a string of contents, or an already
+ * parsed AST tree.
+ * @returns {Array} an array of module names that are dependencies. Always
+ * returns an array, but could be of length zero.
+ */
+ parse.getAnonDeps = function (fileName, fileContents) {
+ var astRoot = typeof fileContents === 'string' ?
+ esprima.parse(fileContents) : fileContents,
+ defFunc = this.findAnonDefineFactory(astRoot);
+
+ return parse.getAnonDepsFromNode(defFunc);
+ };
+
+ /**
+ * 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.
+ */
+ parse.getAnonDepsFromNode = function (node) {
+ var deps = [],
+ funcArgLength;
+
+ if (node) {
+ this.findRequireDepNames(node, deps);
+
+ //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.
+ funcArgLength = node.params && node.params.length;
+ if (funcArgLength) {
+ deps = (funcArgLength > 1 ? ["require", "exports", "module"] :
+ ["require"]).concat(deps);
+ }
+ }
+ return deps;
+ };
+
+ parse.isDefineNodeWithArgs = function (node) {
+ return node && node.type === 'CallExpression' &&
+ node.callee && node.callee.type === 'Identifier' &&
+ node.callee.name === 'define' && node[argPropName];
+ };
+
+ /**
+ * Finds the function in define(function (require, exports, module){});
+ * @param {Array} node
+ * @returns {Boolean}
+ */
+ parse.findAnonDefineFactory = function (node) {
+ var match;
+
+ traverse(node, function (node) {
+ var arg0, arg1;
+
+ if (parse.isDefineNodeWithArgs(node)) {
+
+ //Just the factory function passed to define
+ arg0 = node[argPropName][0];
+ if (arg0 && arg0.type === 'FunctionExpression') {
+ match = arg0;
+ return false;
+ }
+
+ //A string literal module ID followed by the factory function.
+ arg1 = node[argPropName][1];
+ if (arg0.type === 'Literal' &&
+ arg1 && arg1.type === 'FunctionExpression') {
+ match = arg1;
+ return false;
+ }
+ }
+ });
+
+ return match;
+ };
+
+ /**
+ * Finds any config that is passed to requirejs. That includes calls to
+ * require/requirejs.config(), as well as require({}, ...) and
+ * requirejs({}, ...)
+ * @param {String} fileContents
+ *
+ * @returns {Object} a config details object with the following properties:
+ * - config: {Object} the config object found. Can be undefined if no
+ * config found.
+ * - range: {Array} the start index and end index in the contents where
+ * the config was found. Can be undefined if no config found.
+ * Can throw an error if the config in the file cannot be evaluated in
+ * a build context to valid JavaScript.
+ */
+ parse.findConfig = function (fileContents) {
+ /*jslint evil: true */
+ var jsConfig, foundConfig, stringData, foundRange, quote, quoteMatch,
+ quoteRegExp = /(:\s|\[\s*)(['"])/,
+ astRoot = esprima.parse(fileContents, {
+ loc: true
+ });
+
+ traverse(astRoot, function (node) {
+ var arg,
+ requireType = parse.hasRequire(node);
+
+ if (requireType && (requireType === 'require' ||
+ requireType === 'requirejs' ||
+ requireType === 'requireConfig' ||
+ requireType === 'requirejsConfig')) {
+
+ arg = node[argPropName] && node[argPropName][0];
+
+ if (arg && arg.type === 'ObjectExpression') {
+ stringData = parse.nodeToString(fileContents, arg);
+ jsConfig = stringData.value;
+ foundRange = stringData.range;
+ return false;
+ }
+ } else {
+ arg = parse.getRequireObjectLiteral(node);
+ if (arg) {
+ stringData = parse.nodeToString(fileContents, arg);
+ jsConfig = stringData.value;
+ foundRange = stringData.range;
+ return false;
+ }
+ }
+ });
+
+ if (jsConfig) {
+ // Eval the config
+ quoteMatch = quoteRegExp.exec(jsConfig);
+ quote = (quoteMatch && quoteMatch[2]) || '"';
+ foundConfig = eval('(' + jsConfig + ')');
+ }
+
+ return {
+ config: foundConfig,
+ range: foundRange,
+ quote: quote
+ };
+ };
+
+ /** Returns the node for the object literal assigned to require/requirejs,
+ * for holding a declarative config.
+ */
+ parse.getRequireObjectLiteral = function (node) {
+ if (node.id && node.id.type === 'Identifier' &&
+ (node.id.name === 'require' || node.id.name === 'requirejs') &&
+ node.init && node.init.type === 'ObjectExpression') {
+ return node.init;
+ }
+ };
+
+ /**
+ * Renames require/requirejs/define calls to be ns + '.' + require/requirejs/define
+ * Does *not* do .config calls though. See pragma.namespace for the complete
+ * set of namespace transforms. This function is used because require calls
+ * inside a define() call should not be renamed, so a simple regexp is not
+ * good enough.
+ * @param {String} fileContents the contents to transform.
+ * @param {String} ns the namespace, *not* including trailing dot.
+ * @return {String} the fileContents with the namespace applied
+ */
+ parse.renameNamespace = function (fileContents, ns) {
+ var lines,
+ locs = [],
+ astRoot = esprima.parse(fileContents, {
+ loc: true
+ });
+
+ parse.recurse(astRoot, function (callName, config, name, deps, node) {
+ locs.push(node.loc);
+ //Do not recurse into define functions, they should be using
+ //local defines.
+ return callName !== 'define';
+ }, {});
+
+ if (locs.length) {
+ lines = fileContents.split('\n');
+
+ //Go backwards through the found locs, adding in the namespace name
+ //in front.
+ locs.reverse();
+ locs.forEach(function (loc) {
+ var startIndex = loc.start.column,
+ //start.line is 1-based, not 0 based.
+ lineIndex = loc.start.line - 1,
+ line = lines[lineIndex];
+
+ lines[lineIndex] = line.substring(0, startIndex) +
+ ns + '.' +
+ line.substring(startIndex,
+ line.length);
+ });
+
+ fileContents = lines.join('\n');
+ }
+
+ return fileContents;
+ };
+
+ /**
+ * 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.
+ */
+ parse.findDependencies = function (fileName, fileContents, options) {
+ var dependencies = [],
+ astRoot = esprima.parse(fileContents);
+
+ parse.recurse(astRoot, function (callName, config, name, deps) {
+ if (deps) {
+ dependencies = dependencies.concat(deps);
+ }
+ }, options);
+
+ return dependencies;
+ };
+
+ /**
+ * Finds only CJS dependencies, ones that are the form
+ * require('stringLiteral')
+ */
+ parse.findCjsDependencies = function (fileName, fileContents) {
+ var dependencies = [];
+
+ traverse(esprima.parse(fileContents), function (node) {
+ var arg;
+
+ if (node && node.type === 'CallExpression' && node.callee &&
+ node.callee.type === 'Identifier' &&
+ node.callee.name === 'require' && node[argPropName] &&
+ node[argPropName].length === 1) {
+ arg = node[argPropName][0];
+ if (arg.type === 'Literal') {
+ dependencies.push(arg.value);
+ }
+ }
+ });
+
+ return dependencies;
+ };
+
+ //function define() {}
+ parse.hasDefDefine = function (node) {
+ return node.type === 'FunctionDeclaration' && node.id &&
+ node.id.type === 'Identifier' && node.id.name === 'define';
+ };
+
+ //define.amd = ...
+ parse.hasDefineAmd = function (node) {
+ return node && node.type === 'AssignmentExpression' &&
+ node.left && node.left.type === 'MemberExpression' &&
+ node.left.object && node.left.object.name === 'define' &&
+ node.left.property && node.left.property.name === 'amd';
+ };
+
+ //define.amd reference, as in: if (define.amd)
+ parse.refsDefineAmd = function (node) {
+ return node && node.type === 'MemberExpression' &&
+ node.object && node.object.name === 'define' &&
+ node.object.type === 'Identifier' &&
+ node.property && node.property.name === 'amd' &&
+ node.property.type === 'Identifier';
+ };
+
+ //require(), requirejs(), require.config() and requirejs.config()
+ parse.hasRequire = function (node) {
+ var callName,
+ c = node && node.callee;
+
+ if (node && node.type === 'CallExpression' && c) {
+ if (c.type === 'Identifier' &&
+ (c.name === 'require' ||
+ c.name === 'requirejs')) {
+ //A require/requirejs({}, ...) call
+ callName = c.name;
+ } else if (c.type === 'MemberExpression' &&
+ c.object &&
+ c.object.type === 'Identifier' &&
+ (c.object.name === 'require' ||
+ c.object.name === 'requirejs') &&
+ c.property && c.property.name === 'config') {
+ // require/requirejs.config({}) call
+ callName = c.object.name + 'Config';
+ }
+ }
+
+ return callName;
+ };
+
+ //define()
+ parse.hasDefine = function (node) {
+ return node && node.type === 'CallExpression' && node.callee &&
+ node.callee.type === 'Identifier' &&
+ node.callee.name === 'define';
+ };
+
+ /**
+ * If there is a named define in the file, returns the name. Does not
+ * scan for mulitple names, just the first one.
+ */
+ parse.getNamedDefine = function (fileContents) {
+ var name;
+ traverse(esprima.parse(fileContents), function (node) {
+ if (node && node.type === 'CallExpression' && node.callee &&
+ node.callee.type === 'Identifier' &&
+ node.callee.name === 'define' &&
+ node[argPropName] && node[argPropName][0] &&
+ node[argPropName][0].type === 'Literal') {
+ name = node[argPropName][0].value;
+ return false;
+ }
+ });
+
+ return name;
+ };
+
+ /**
+ * Determines if define(), require({}|[]) or requirejs was called in the
+ * file. Also finds out if define() is declared and if define.amd is called.
+ */
+ parse.usesAmdOrRequireJs = function (fileName, fileContents) {
+ var uses;
+
+ traverse(esprima.parse(fileContents), function (node) {
+ var type, callName, arg;
+
+ if (parse.hasDefDefine(node)) {
+ //function define() {}
+ type = 'declaresDefine';
+ } else if (parse.hasDefineAmd(node)) {
+ type = 'defineAmd';
+ } else {
+ callName = parse.hasRequire(node);
+ if (callName) {
+ arg = node[argPropName] && node[argPropName][0];
+ if (arg && (arg.type === 'ObjectExpression' ||
+ arg.type === 'ArrayExpression')) {
+ type = callName;
+ }
+ } else if (parse.hasDefine(node)) {
+ type = 'define';
+ }
+ }
+
+ if (type) {
+ if (!uses) {
+ uses = {};
+ }
+ uses[type] = true;
+ }
+ });
+
+ return uses;
+ };
+
+ /**
+ * Determines if require(''), exports.x =, module.exports =,
+ * __dirname, __filename are used. So, not strictly traditional CommonJS,
+ * also checks for Node variants.
+ */
+ parse.usesCommonJs = function (fileName, fileContents) {
+ var uses = null,
+ assignsExports = false;
+
+
+ traverse(esprima.parse(fileContents), function (node) {
+ var type,
+ exp = node.expression || node.init;
+
+ if (node.type === 'Identifier' &&
+ (node.name === '__dirname' || node.name === '__filename')) {
+ type = node.name.substring(2);
+ } else if (node.type === 'VariableDeclarator' && node.id &&
+ node.id.type === 'Identifier' &&
+ node.id.name === 'exports') {
+ //Hmm, a variable assignment for exports, so does not use cjs
+ //exports.
+ type = 'varExports';
+ } else if (exp && exp.type === 'AssignmentExpression' && exp.left &&
+ exp.left.type === 'MemberExpression' && exp.left.object) {
+ if (exp.left.object.name === 'module' && exp.left.property &&
+ exp.left.property.name === 'exports') {
+ type = 'moduleExports';
+ } else if (exp.left.object.name === 'exports' &&
+ exp.left.property) {
+ type = 'exports';
+ }
+
+ } else if (node && node.type === 'CallExpression' && node.callee &&
+ node.callee.type === 'Identifier' &&
+ node.callee.name === 'require' && node[argPropName] &&
+ node[argPropName].length === 1 &&
+ node[argPropName][0].type === 'Literal') {
+ type = 'require';
+ }
+
+ if (type) {
+ if (type === 'varExports') {
+ assignsExports = true;
+ } else if (type !== 'exports' || !assignsExports) {
+ if (!uses) {
+ uses = {};
+ }
+ uses[type] = true;
+ }
+ }
+ });
+
+ return uses;
+ };
+
+
+ parse.findRequireDepNames = function (node, deps) {
+ traverse(node, function (node) {
+ var arg;
+
+ if (node && node.type === 'CallExpression' && node.callee &&
+ node.callee.type === 'Identifier' &&
+ node.callee.name === 'require' &&
+ node[argPropName] && node[argPropName].length === 1) {
+
+ arg = node[argPropName][0];
+ if (arg.type === 'Literal') {
+ deps.push(arg.value);
+ }
+ }
+ });
+ };
+
+ /**
+ * 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.
+ *
+ * @returns {String} a JS source string with the valid require/define call.
+ * Otherwise null.
+ */
+ parse.parseNode = function (node, onMatch) {
+ var name, deps, cjsDeps, arg, factory, exp, refsDefine, bodyNode,
+ args = node && node[argPropName],
+ callName = parse.hasRequire(node);
+
+ if (callName === 'require' || callName === 'requirejs') {
+ //A plain require/requirejs call
+ arg = node[argPropName] && node[argPropName][0];
+ if (arg.type !== 'ArrayExpression') {
+ if (arg.type === 'ObjectExpression') {
+ //A config call, try the second arg.
+ arg = node[argPropName][1];
+ }
+ }
+
+ deps = getValidDeps(arg);
+ if (!deps) {
+ return;
+ }
+
+ return onMatch("require", null, null, deps, node);
+ } else if (parse.hasDefine(node) && args && args.length) {
+ name = args[0];
+ deps = args[1];
+ factory = args[2];
+
+ if (name.type === 'ArrayExpression') {
+ //No name, adjust args
+ factory = deps;
+ deps = name;
+ name = null;
+ } else if (name.type === 'FunctionExpression') {
+ //Just the factory, no name or deps
+ factory = name;
+ name = deps = null;
+ } else if (name.type !== 'Literal') {
+ //An object literal, just null out
+ name = deps = factory = null;
+ }
+
+ if (name && name.type === 'Literal' && deps) {
+ if (deps.type === 'FunctionExpression') {
+ //deps is the factory
+ factory = deps;
+ deps = null;
+ } else if (deps.type === 'ObjectExpression') {
+ //deps is object literal, null out
+ deps = factory = null;
+ } else if (deps.type === 'Identifier' && args.length === 2) {
+ // define('id', factory)
+ deps = factory = null;
+ }
+ }
+
+ if (deps && deps.type === 'ArrayExpression') {
+ deps = getValidDeps(deps);
+ } else if (factory && factory.type === 'FunctionExpression') {
+ //If no deps and a factory function, could be a commonjs sugar
+ //wrapper, scan the function for dependencies.
+ cjsDeps = parse.getAnonDepsFromNode(factory);
+ if (cjsDeps.length) {
+ deps = cjsDeps;
+ }
+ } else if (deps || factory) {
+ //Does not match the shape of an AMD call.
+ return;
+ }
+
+ //Just save off the name as a string instead of an AST object.
+ if (name && name.type === 'Literal') {
+ name = name.value;
+ }
+
+ return onMatch("define", null, name, deps, node);
+ } else if (node.type === 'CallExpression' && node.callee &&
+ node.callee.type === 'FunctionExpression' &&
+ node.callee.body && node.callee.body.body &&
+ node.callee.body.body.length === 1 &&
+ node.callee.body.body[0].type === 'IfStatement') {
+ bodyNode = node.callee.body.body[0];
+ //Look for a define(Identifier) case, but only if inside an
+ //if that has a define.amd test
+ if (bodyNode.consequent && bodyNode.consequent.body) {
+ exp = bodyNode.consequent.body[0];
+ if (exp.type === 'ExpressionStatement' && exp.expression &&
+ parse.hasDefine(exp.expression) &&
+ exp.expression.arguments &&
+ exp.expression.arguments.length === 1 &&
+ exp.expression.arguments[0].type === 'Identifier') {
+
+ //Calls define(Identifier) as first statement in body.
+ //Confirm the if test references define.amd
+ traverse(bodyNode.test, function (node) {
+ if (parse.refsDefineAmd(node)) {
+ refsDefine = true;
+ return false;
+ }
+ });
+
+ if (refsDefine) {
+ return onMatch("define", null, null, null, exp.expression);
+ }
+ }
+ }
+ }
+ };
+
+ /**
+ * Converts an AST node into a JS source string by extracting
+ * the node's location from the given contents string. Assumes
+ * esprima.parse() with loc was done.
+ * @param {String} contents
+ * @param {Object} node
+ * @returns {String} a JS source string.
+ */
+ parse.nodeToString = function (contents, node) {
+ var loc = node.loc,
+ lines = contents.split('\n'),
+ firstLine = loc.start.line > 1 ?
+ lines.slice(0, loc.start.line - 1).join('\n') + '\n' :
+ '',
+ preamble = firstLine +
+ lines[loc.start.line - 1].substring(0, loc.start.column),
+ extracted = lines[loc.start.line - 1].substring(loc.start.column) +
+ '\n' +
+ lines.slice(loc.start.line, loc.end.line - 1).join('\n') +
+ '\n' +
+ lines[loc.end.line - 1].substring(0, loc.end.column);
+
+ return {
+ value: extracted,
+ range: [
+ preamble.length,
+ preamble.length + extracted.length
+ ]
+ };
+ };
+
+ /**
+ * Extracts license comments from JS text.
+ * @param {String} fileName
+ * @param {String} contents
+ * @returns {String} a string of license comments.
+ */
+ parse.getLicenseComments = function (fileName, contents) {
+ var commentNode, refNode, subNode, value, i, j,
+ //xpconnect's Reflect does not support comment or range, but
+ //prefer continued operation vs strict parity of operation,
+ //as license comments can be expressed in other ways, like
+ //via wrap args, or linked via sourcemaps.
+ ast = esprima.parse(contents, {
+ comment: true,
+ range: true
+ }),
+ result = '',
+ existsMap = {},
+ lineEnd = contents.indexOf('\r') === -1 ? '\n' : '\r\n';
+
+ if (ast.comments) {
+ for (i = 0; i < ast.comments.length; i++) {
+ commentNode = ast.comments[i];
+
+ if (commentNode.type === 'Line') {
+ value = '//' + commentNode.value + lineEnd;
+ refNode = commentNode;
+
+ if (i + 1 >= ast.comments.length) {
+ value += lineEnd;
+ } else {
+ //Look for immediately adjacent single line comments
+ //since it could from a multiple line comment made out
+ //of single line comments. Like this comment.
+ for (j = i + 1; j < ast.comments.length; j++) {
+ subNode = ast.comments[j];
+ if (subNode.type === 'Line' &&
+ subNode.range[0] === refNode.range[1] + 1) {
+ //Adjacent single line comment. Collect it.
+ value += '//' + subNode.value + lineEnd;
+ refNode = subNode;
+ } else {
+ //No more single line comment blocks. Break out
+ //and continue outer looping.
+ break;
+ }
+ }
+ value += lineEnd;
+ i = j - 1;
+ }
+ } else {
+ value = '/*' + commentNode.value + '*/' + lineEnd + lineEnd;
+ }
+
+ if (!existsMap[value] && (value.indexOf('license') !== -1 ||
+ (commentNode.type === 'Block' &&
+ value.indexOf('/*!') === 0) ||
+ value.indexOf('opyright') !== -1 ||
+ value.indexOf('(c)') !== -1)) {
+
+ result += value;
+ existsMap[value] = true;
+ }
+
+ }
+ }
+
+ return result;
+ };
+
+ return parse;
+});
+/**
+ * @license Copyright (c) 2012, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+
+/*global define */
+
+define('transform', [ './esprimaAdapter', './parse', 'logger', 'lang'],
+function (esprima, parse, logger, lang) {
+ 'use strict';
+ var transform,
+ baseIndentRegExp = /^([ \t]+)/,
+ indentRegExp = /\{[\r\n]+([ \t]+)/,
+ keyRegExp = /^[_A-Za-z]([A-Za-z\d_]*)$/,
+ bulkIndentRegExps = {
+ '\n': /\n/g,
+ '\r\n': /\r\n/g
+ };
+
+ function applyIndent(str, indent, lineReturn) {
+ var regExp = bulkIndentRegExps[lineReturn];
+ return str.replace(regExp, '$&' + indent);
+ }
+
+ transform = {
+ toTransport: function (namespace, moduleName, path, contents, onFound, options) {
+ options = options || {};
+
+ var astRoot, contentLines, modLine,
+ foundAnon,
+ scanCount = 0,
+ scanReset = false,
+ defineInfos = [];
+
+ try {
+ astRoot = esprima.parse(contents, {
+ loc: true
+ });
+ } catch (e) {
+ logger.trace('toTransport skipping ' + path + ': ' +
+ e.toString());
+ return contents;
+ }
+
+ //Find the define calls and their position in the files.
+ parse.traverseBroad(astRoot, function (node) {
+ var args, firstArg, firstArgLoc, factoryNode,
+ needsId, depAction, foundId,
+ sourceUrlData, range,
+ namespaceExists = false;
+
+ namespaceExists = namespace &&
+ node.type === 'CallExpression' &&
+ node.callee && node.callee.object &&
+ node.callee.object.type === 'Identifier' &&
+ node.callee.object.name === namespace &&
+ node.callee.property.type === 'Identifier' &&
+ node.callee.property.name === 'define';
+
+ if (namespaceExists || parse.isDefineNodeWithArgs(node)) {
+ //The arguments are where its at.
+ args = node.arguments;
+ if (!args || !args.length) {
+ return;
+ }
+
+ firstArg = args[0];
+ firstArgLoc = firstArg.loc;
+
+ if (args.length === 1) {
+ if (firstArg.type === 'Identifier') {
+ //The define(factory) case, but
+ //only allow it if one Identifier arg,
+ //to limit impact of false positives.
+ needsId = true;
+ depAction = 'empty';
+ } else if (firstArg.type === 'FunctionExpression') {
+ //define(function(){})
+ factoryNode = firstArg;
+ needsId = true;
+ depAction = 'scan';
+ } else if (firstArg.type === 'ObjectExpression') {
+ //define({});
+ needsId = true;
+ depAction = 'skip';
+ } else if (firstArg.type === 'Literal' &&
+ typeof firstArg.value === 'number') {
+ //define('12345');
+ needsId = true;
+ depAction = 'skip';
+ } else if (firstArg.type === 'UnaryExpression' &&
+ firstArg.operator === '-' &&
+ firstArg.argument &&
+ firstArg.argument.type === 'Literal' &&
+ typeof firstArg.argument.value === 'number') {
+ //define('-12345');
+ needsId = true;
+ depAction = 'skip';
+ } else if (firstArg.type === 'MemberExpression' &&
+ firstArg.object &&
+ firstArg.property &&
+ firstArg.property.type === 'Identifier') {
+ //define(this.key);
+ needsId = true;
+ depAction = 'empty';
+ }
+ } else if (firstArg.type === 'ArrayExpression') {
+ //define([], ...);
+ needsId = true;
+ depAction = 'skip';
+ } else if (firstArg.type === 'Literal' &&
+ typeof firstArg.value === 'string') {
+ //define('string', ....)
+ //Already has an ID.
+ needsId = false;
+ if (args.length === 2 &&
+ args[1].type === 'FunctionExpression') {
+ //Needs dependency scanning.
+ factoryNode = args[1];
+ depAction = 'scan';
+ } else {
+ depAction = 'skip';
+ }
+ } else {
+ //Unknown define entity, keep looking, even
+ //in the subtree for this node.
+ return;
+ }
+
+ range = {
+ foundId: foundId,
+ needsId: needsId,
+ depAction: depAction,
+ namespaceExists: namespaceExists,
+ node: node,
+ defineLoc: node.loc,
+ firstArgLoc: firstArgLoc,
+ factoryNode: factoryNode,
+ sourceUrlData: sourceUrlData
+ };
+
+ //Only transform ones that do not have IDs. If it has an
+ //ID but no dependency array, assume it is something like
+ //a phonegap implementation, that has its own internal
+ //define that cannot handle dependency array constructs,
+ //and if it is a named module, then it means it has been
+ //set for transport form.
+ if (range.needsId) {
+ if (foundAnon) {
+ logger.trace(path + ' has more than one anonymous ' +
+ 'define. May be a built file from another ' +
+ 'build system like, Ender. Skipping normalization.');
+ defineInfos = [];
+ return false;
+ } else {
+ foundAnon = range;
+ defineInfos.push(range);
+ }
+ } else if (depAction === 'scan') {
+ scanCount += 1;
+ if (scanCount > 1) {
+ //Just go back to an array that just has the
+ //anon one, since this is an already optimized
+ //file like the phonegap one.
+ if (!scanReset) {
+ defineInfos = foundAnon ? [foundAnon] : [];
+ scanReset = true;
+ }
+ } else {
+ defineInfos.push(range);
+ }
+ }
+ }
+ });
+
+ if (!defineInfos.length) {
+ return contents;
+ }
+
+ //Reverse the matches, need to start from the bottom of
+ //the file to modify it, so that the ranges are still true
+ //further up.
+ defineInfos.reverse();
+
+ contentLines = contents.split('\n');
+
+ modLine = function (loc, contentInsertion) {
+ var startIndex = loc.start.column,
+ //start.line is 1-based, not 0 based.
+ lineIndex = loc.start.line - 1,
+ line = contentLines[lineIndex];
+ contentLines[lineIndex] = line.substring(0, startIndex) +
+ contentInsertion +
+ line.substring(startIndex,
+ line.length);
+ };
+
+ defineInfos.forEach(function (info) {
+ var deps,
+ contentInsertion = '',
+ depString = '';
+
+ //Do the modifications "backwards", in other words, start with the
+ //one that is farthest down and work up, so that the ranges in the
+ //defineInfos still apply. So that means deps, id, then namespace.
+ if (info.needsId && moduleName) {
+ contentInsertion += "'" + moduleName + "',";
+ }
+
+ if (info.depAction === 'scan') {
+ deps = parse.getAnonDepsFromNode(info.factoryNode);
+
+ if (deps.length) {
+ depString = '[' + deps.map(function (dep) {
+ return "'" + dep + "'";
+ }) + ']';
+ } else {
+ depString = '[]';
+ }
+ depString += ',';
+
+ if (info.factoryNode) {
+ //Already have a named module, need to insert the
+ //dependencies after the name.
+ modLine(info.factoryNode.loc, depString);
+ } else {
+ contentInsertion += depString;
+ }
+ }
+
+ if (contentInsertion) {
+ modLine(info.firstArgLoc, contentInsertion);
+ }
+
+ //Do namespace last so that ui does not mess upthe parenRange
+ //used above.
+ if (namespace && !info.namespaceExists) {
+ modLine(info.defineLoc, namespace + '.');
+ }
+
+ //Notify any listener for the found info
+ if (onFound) {
+ onFound(info);
+ }
+ });
+
+ contents = contentLines.join('\n');
+
+ if (options.useSourceUrl) {
+ contents = 'eval("' + lang.jsEscape(contents) +
+ '\\n//# sourceURL=' + (path.indexOf('/') === 0 ? '' : '/') +
+ path +
+ '");\n';
+ }
+
+ return contents;
+ },
+
+ /**
+ * Modify the contents of a require.config/requirejs.config call. This
+ * call will LOSE any existing comments that are in the config string.
+ *
+ * @param {String} fileContents String that may contain a config call
+ * @param {Function} onConfig Function called when the first config
+ * call is found. It will be passed an Object which is the current
+ * config, and the onConfig function should return an Object to use
+ * as the config.
+ * @return {String} the fileContents with the config changes applied.
+ */
+ modifyConfig: function (fileContents, onConfig) {
+ var details = parse.findConfig(fileContents),
+ config = details.config;
+
+ if (config) {
+ config = onConfig(config);
+ if (config) {
+ return transform.serializeConfig(config,
+ fileContents,
+ details.range[0],
+ details.range[1],
+ {
+ quote: details.quote
+ });
+ }
+ }
+
+ return fileContents;
+ },
+
+ serializeConfig: function (config, fileContents, start, end, options) {
+ //Calculate base level of indent
+ var indent, match, configString, outDentRegExp,
+ baseIndent = '',
+ startString = fileContents.substring(0, start),
+ existingConfigString = fileContents.substring(start, end),
+ lineReturn = existingConfigString.indexOf('\r') === -1 ? '\n' : '\r\n',
+ lastReturnIndex = startString.lastIndexOf('\n');
+
+ //Get the basic amount of indent for the require config call.
+ if (lastReturnIndex === -1) {
+ lastReturnIndex = 0;
+ }
+
+ match = baseIndentRegExp.exec(startString.substring(lastReturnIndex + 1, start));
+ if (match && match[1]) {
+ baseIndent = match[1];
+ }
+
+ //Calculate internal indentation for config
+ match = indentRegExp.exec(existingConfigString);
+ if (match && match[1]) {
+ indent = match[1];
+ }
+
+ if (!indent || indent.length < baseIndent) {
+ indent = ' ';
+ } else {
+ indent = indent.substring(baseIndent.length);
+ }
+
+ outDentRegExp = new RegExp('(' + lineReturn + ')' + indent, 'g');
+
+ configString = transform.objectToString(config, {
+ indent: indent,
+ lineReturn: lineReturn,
+ outDentRegExp: outDentRegExp,
+ quote: options && options.quote
+ });
+
+ //Add in the base indenting level.
+ configString = applyIndent(configString, baseIndent, lineReturn);
+
+ return startString + configString + fileContents.substring(end);
+ },
+
+ /**
+ * Tries converting a JS object to a string. This will likely suck, and
+ * is tailored to the type of config expected in a loader config call.
+ * So, hasOwnProperty fields, strings, numbers, arrays and functions,
+ * no weird recursively referenced stuff.
+ * @param {Object} obj the object to convert
+ * @param {Object} options options object with the following values:
+ * {String} indent the indentation to use for each level
+ * {String} lineReturn the type of line return to use
+ * {outDentRegExp} outDentRegExp the regexp to use to outdent functions
+ * {String} quote the quote type to use, ' or ". Optional. Default is "
+ * @param {String} totalIndent the total indent to print for this level
+ * @return {String} a string representation of the object.
+ */
+ objectToString: function (obj, options, totalIndent) {
+ var startBrace, endBrace, nextIndent,
+ first = true,
+ value = '',
+ lineReturn = options.lineReturn,
+ indent = options.indent,
+ outDentRegExp = options.outDentRegExp,
+ quote = options.quote || '"';
+
+ totalIndent = totalIndent || '';
+ nextIndent = totalIndent + indent;
+
+ if (obj === null) {
+ value = 'null';
+ } else if (obj === undefined) {
+ value = 'undefined';
+ } else if (typeof obj === 'number' || typeof obj === 'boolean') {
+ value = obj;
+ } else if (typeof obj === 'string') {
+ //Use double quotes in case the config may also work as JSON.
+ value = quote + lang.jsEscape(obj) + quote;
+ } else if (lang.isArray(obj)) {
+ lang.each(obj, function (item, i) {
+ value += (i !== 0 ? ',' + lineReturn : '' ) +
+ nextIndent +
+ transform.objectToString(item,
+ options,
+ nextIndent);
+ });
+
+ startBrace = '[';
+ endBrace = ']';
+ } else if (lang.isFunction(obj) || lang.isRegExp(obj)) {
+ //The outdent regexp just helps pretty up the conversion
+ //just in node. Rhino strips comments and does a different
+ //indent scheme for Function toString, so not really helpful
+ //there.
+ value = obj.toString().replace(outDentRegExp, '$1');
+ } else {
+ //An object
+ lang.eachProp(obj, function (v, prop) {
+ value += (first ? '': ',' + lineReturn) +
+ nextIndent +
+ (keyRegExp.test(prop) ? prop : quote + lang.jsEscape(prop) + quote )+
+ ': ' +
+ transform.objectToString(v,
+ options,
+ nextIndent);
+ first = false;
+ });
+ startBrace = '{';
+ endBrace = '}';
+ }
+
+ if (startBrace) {
+ value = startBrace +
+ lineReturn +
+ value +
+ lineReturn + totalIndent +
+ endBrace;
+ }
+
+ return value;
+ }
+ };
+
+ return transform;
+});
+/**
+ * @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: true, plusplus: true */
+/*global define: false */
+
+define('pragma', ['parse', 'logger'], function (parse, logger) {
+ 'use strict';
+ function Temp() {}
+
+ function create(obj, mixin) {
+ Temp.prototype = obj;
+ var temp = new Temp(), prop;
+
+ //Avoid any extra memory hanging around
+ Temp.prototype = null;
+
+ if (mixin) {
+ for (prop in mixin) {
+ if (mixin.hasOwnProperty(prop) && !temp.hasOwnProperty(prop)) {
+ temp[prop] = mixin[prop];
+ }
+ }
+ }
+
+ return temp; // Object
+ }
+
+ var pragma = {
+ conditionalRegExp: /(exclude|include)Start\s*\(\s*["'](\w+)["']\s*,(.*)\)/,
+ useStrictRegExp: /['"]use strict['"];/g,
+ hasRegExp: /has\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+ configRegExp: /(^|[^\.])(requirejs|require)(\.config)\s*\(/g,
+ nsWrapRegExp: /\/\*requirejs namespace: true \*\//,
+ apiDefRegExp: /var requirejs, require, define;/,
+ defineCheckRegExp: /typeof\s+define\s*===\s*["']function["']\s*&&\s*define\s*\.\s*amd/g,
+ defineStringCheckRegExp: /typeof\s+define\s*===\s*["']function["']\s*&&\s*define\s*\[\s*["']amd["']\s*\]/g,
+ defineTypeFirstCheckRegExp: /\s*["']function["']\s*===\s*typeof\s+define\s*&&\s*define\s*\.\s*amd/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,
+
+ removeStrict: function (contents, config) {
+ return config.useStrict ? contents : contents.replace(pragma.useStrictRegExp, '');
+ },
+
+ namespace: function (fileContents, ns, onLifecycleName) {
+ if (ns) {
+ //Namespace require/define calls
+ fileContents = fileContents.replace(pragma.configRegExp, '$1' + ns + '.$2$3(');
+
+
+ fileContents = parse.renameNamespace(fileContents, ns);
+
+ //Namespace define ternary use:
+ fileContents = fileContents.replace(pragma.defineTernaryRegExp,
+ "typeof " + ns + ".define === 'function' && " + ns + ".define.amd ? " + ns + ".define");
+
+ //Namespace define jquery use:
+ fileContents = fileContents.replace(pragma.defineJQueryRegExp,
+ "typeof " + ns + ".define === 'function' && " + ns + ".define.amd && " + ns + ".define.amd.jQuery");
+
+ //Namespace has.js define use:
+ fileContents = fileContents.replace(pragma.defineHasRegExp,
+ "typeof " + ns + ".define === 'function' && typeof " + ns + ".define.amd === 'object' && " + ns + ".define.amd");
+
+ //Namespace define checks.
+ //Do these ones last, since they are a subset of the more specific
+ //checks above.
+ fileContents = fileContents.replace(pragma.defineCheckRegExp,
+ "typeof " + ns + ".define === 'function' && " + ns + ".define.amd");
+ fileContents = fileContents.replace(pragma.defineStringCheckRegExp,
+ "typeof " + ns + ".define === 'function' && " + ns + ".define['amd']");
+ fileContents = fileContents.replace(pragma.defineTypeFirstCheckRegExp,
+ "'function' === typeof " + ns + ".define && " + ns + ".define.amd");
+
+ //Check for require.js with the require/define definitions
+ if (pragma.apiDefRegExp.test(fileContents) &&
+ fileContents.indexOf("if (!" + ns + " || !" + ns + ".requirejs)") === -1) {
+ //Wrap the file contents in a typeof check, and a function
+ //to contain the API globals.
+ fileContents = "var " + ns + ";(function () { if (!" + ns + " || !" + ns + ".requirejs) {\n" +
+ "if (!" + ns + ") { " + ns + ' = {}; } else { require = ' + ns + '; }\n' +
+ fileContents +
+ "\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*/
+ if (pragma.nsWrapRegExp.test(fileContents)) {
+ //Remove the pragma.
+ fileContents = fileContents.replace(pragma.nsWrapRegExp, '');
+
+ //Alter the contents.
+ fileContents = '(function () {\n' +
+ 'var require = ' + ns + '.require,' +
+ 'requirejs = ' + ns + '.requirejs,' +
+ 'define = ' + ns + '.define;\n' +
+ fileContents +
+ '\n}());';
+ }
+ }
+
+ return fileContents;
+ },
+
+ /**
+ * processes the fileContents for some //>> conditional statements
+ */
+ process: function (fileName, fileContents, config, onLifecycleName, pluginCollector) {
+ /*jslint evil: true */
+ var foundIndex = -1, startIndex = 0, lineEndIndex, conditionLine,
+ matches, type, marker, condition, isTrue, endRegExp, endMatches,
+ endMarkerIndex, shouldInclude, startLength, lifecycleHas, deps,
+ i, dep, moduleName, collectorMod,
+ lifecyclePragmas, pragmas = config.pragmas, hasConfig = config.has,
+ //Legacy arg defined to help in dojo conversion script. Remove later
+ //when dojo no longer needs conversion:
+ kwArgs = pragmas;
+
+ //Mix in a specific lifecycle scoped object, to allow targeting
+ //some pragmas/has tests to only when files are saved, or at different
+ //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) {
+ lifecyclePragmas = config['pragmas' + onLifecycleName];
+ lifecycleHas = config['has' + onLifecycleName];
+
+ if (lifecyclePragmas) {
+ pragmas = create(pragmas || {}, lifecyclePragmas);
+ }
+
+ if (lifecycleHas) {
+ hasConfig = create(hasConfig || {}, lifecycleHas);
+ }
+ }
+
+ //Replace has references if desired
+ if (hasConfig) {
+ fileContents = fileContents.replace(pragma.hasRegExp, function (match, test) {
+ if (hasConfig.hasOwnProperty(test)) {
+ return !!hasConfig[test];
+ }
+ return match;
+ });
+ }
+
+ if (!config.skipPragmas) {
+
+ while ((foundIndex = fileContents.indexOf("//>>", startIndex)) !== -1) {
+ //Found a conditional. Get the conditional line.
+ lineEndIndex = fileContents.indexOf("\n", foundIndex);
+ if (lineEndIndex === -1) {
+ lineEndIndex = fileContents.length - 1;
+ }
+
+ //Increment startIndex past the line so the next conditional search can be done.
+ startIndex = lineEndIndex + 1;
+
+ //Break apart the conditional.
+ conditionLine = fileContents.substring(foundIndex, lineEndIndex + 1);
+ matches = conditionLine.match(pragma.conditionalRegExp);
+ if (matches) {
+ type = matches[1];
+ marker = matches[2];
+ condition = matches[3];
+ isTrue = false;
+ //See if the condition is true.
+ try {
+ isTrue = !!eval("(" + condition + ")");
+ } catch (e) {
+ throw "Error in file: " +
+ fileName +
+ ". Conditional comment: " +
+ conditionLine +
+ " failed with this error: " + e;
+ }
+
+ //Find the endpoint marker.
+ endRegExp = new RegExp('\\/\\/\\>\\>\\s*' + type + 'End\\(\\s*[\'"]' + marker + '[\'"]\\s*\\)', "g");
+ endMatches = endRegExp.exec(fileContents.substring(startIndex, fileContents.length));
+ if (endMatches) {
+ endMarkerIndex = startIndex + endRegExp.lastIndex - endMatches[0].length;
+
+ //Find the next line return based on the match position.
+ lineEndIndex = fileContents.indexOf("\n", endMarkerIndex);
+ if (lineEndIndex === -1) {
+ lineEndIndex = fileContents.length - 1;
+ }
+
+ //Should we include the segment?
+ shouldInclude = ((type === "exclude" && !isTrue) || (type === "include" && isTrue));
+
+ //Remove the conditional comments, and optionally remove the content inside
+ //the conditional comments.
+ startLength = startIndex - foundIndex;
+ fileContents = fileContents.substring(0, foundIndex) +
+ (shouldInclude ? fileContents.substring(startIndex, endMarkerIndex) : "") +
+ fileContents.substring(lineEndIndex + 1, fileContents.length);
+
+ //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.
+ startIndex = foundIndex;
+ } else {
+ throw "Error in file: " +
+ fileName +
+ ". Cannot find end marker for conditional comment: " +
+ conditionLine;
+
+ }
+ }
+ }
+ }
+
+ //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.
+ if (config.optimizeAllPluginResources && pluginCollector) {
+ try {
+ deps = parse.findDependencies(fileName, fileContents);
+ if (deps.length) {
+ for (i = 0; i < deps.length; i++) {
+ dep = deps[i];
+ if (dep.indexOf('!') !== -1) {
+ moduleName = dep.split('!')[0];
+ collectorMod = pluginCollector[moduleName];
+ if (!collectorMod) {
+ collectorMod = pluginCollector[moduleName] = [];
+ }
+ collectorMod.push(dep);
+ }
+ }
+ }
+ } catch (eDep) {
+ logger.error('Parse error looking for plugin resources in ' +
+ fileName + ', skipping.');
+ }
+ }
+
+ //Strip amdefine use for node-shared modules.
+ fileContents = fileContents.replace(pragma.amdefineRegExp, '');
+
+ //Do namespacing
+ if (onLifecycleName === 'OnSave' && config.namespace) {
+ fileContents = pragma.namespace(fileContents, config.namespace, onLifecycleName);
+ }
+
+
+ return pragma.removeStrict(fileContents, config);
+ }
+ };
+
+ return pragma;
+});
+if(env === 'browser') {
+/**
+ * @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 */
+
+define('browser/optimize', {});
+
+}
+
+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 */
+
+define('node/optimize', {});
+
+}
+
+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 sloppy: true, plusplus: true */
+/*global define, java, Packages, com */
+
+define('rhino/optimize', ['logger', 'env!env/file'], function (logger, file) {
+
+ //Add .reduce to Rhino so UglifyJS can run in Rhino,
+ //inspired by https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/reduce
+ //but rewritten for brevity, and to be good enough for use by UglifyJS.
+ if (!Array.prototype.reduce) {
+ Array.prototype.reduce = function (fn /*, initialValue */) {
+ var i = 0,
+ length = this.length,
+ accumulator;
+
+ if (arguments.length >= 2) {
+ accumulator = arguments[1];
+ } else {
+ if (length) {
+ while (!(i in this)) {
+ i++;
+ }
+ accumulator = this[i++];
+ }
+ }
+
+ for (; i < length; i++) {
+ if (i in this) {
+ accumulator = fn.call(undefined, accumulator, this[i], i, this);
+ }
+ }
+
+ return accumulator;
+ };
+ }
+
+ var JSSourceFilefromCode, optimize,
+ mapRegExp = /"file":"[^"]+"/;
+
+ //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.
+ function closurefromCode(filename, content) {
+ return JSSourceFilefromCode.invoke(null, [filename, content]);
+ }
+
+
+ function getFileWriter(fileName, encoding) {
+ var outFile = new java.io.File(fileName), outWriter, parentDir;
+
+ parentDir = outFile.getAbsoluteFile().getParentFile();
+ if (!parentDir.exists()) {
+ if (!parentDir.mkdirs()) {
+ throw "Could not create directory: " + parentDir.getAbsolutePath();
+ }
+ }
+
+ if (encoding) {
+ outWriter = new java.io.OutputStreamWriter(new java.io.FileOutputStream(outFile), encoding);
+ } else {
+ outWriter = new java.io.OutputStreamWriter(new java.io.FileOutputStream(outFile));
+ }
+
+ return new java.io.BufferedWriter(outWriter);
+ }
+
+ optimize = {
+ closure: function (fileName, fileContents, outFileName, keepLines, config) {
+ config = config || {};
+ var result, mappings, optimized, compressed, baseName, writer,
+ outBaseName, outFileNameMap, outFileNameMapContent,
+ jscomp = Packages.com.google.javascript.jscomp,
+ flags = Packages.com.google.common.flags,
+ //Fake extern
+ externSourceFile = closurefromCode("fakeextern.js", " "),
+ //Set up source input
+ jsSourceFile = closurefromCode(String(fileName), String(fileContents)),
+ options, option, FLAG_compilation_level, compiler,
+ Compiler = Packages.com.google.javascript.jscomp.Compiler;
+
+ logger.trace("Minifying file: " + fileName);
+
+ baseName = (new java.io.File(fileName)).getName();
+
+ //Set up options
+ options = new jscomp.CompilerOptions();
+ for (option in config.CompilerOptions) {
+ // options are false by default and jslint wanted an if statement in this for loop
+ if (config.CompilerOptions[option]) {
+ options[option] = config.CompilerOptions[option];
+ }
+
+ }
+ options.prettyPrint = keepLines || options.prettyPrint;
+
+ FLAG_compilation_level = jscomp.CompilationLevel[config.CompilationLevel || 'SIMPLE_OPTIMIZATIONS'];
+ FLAG_compilation_level.setOptionsForCompilationLevel(options);
+
+ if (config.generateSourceMaps) {
+ mappings = new java.util.ArrayList();
+
+ mappings.add(new com.google.javascript.jscomp.SourceMap.LocationMapping(fileName, baseName + ".src"));
+ options.setSourceMapLocationMappings(mappings);
+ options.setSourceMapOutputPath(fileName + ".map");
+ }
+
+ //Trigger the compiler
+ Compiler.setLoggingLevel(Packages.java.util.logging.Level[config.loggingLevel || 'WARNING']);
+ compiler = new Compiler();
+
+ result = compiler.compile(externSourceFile, jsSourceFile, options);
+ if (result.success) {
+ optimized = String(compiler.toSource());
+
+ if (config.generateSourceMaps && result.sourceMap && outFileName) {
+ outBaseName = (new java.io.File(outFileName)).getName();
+
+ file.saveUtf8File(outFileName + ".src", fileContents);
+
+ outFileNameMap = outFileName + ".map";
+ writer = getFileWriter(outFileNameMap, "utf-8");
+ result.sourceMap.appendTo(writer, outFileName);
+ writer.close();
+
+ //Not sure how better to do this, but right now the .map file
+ //leaks the full OS path in the "file" property. Manually
+ //modify it to not do that.
+ file.saveFile(outFileNameMap,
+ file.readFile(outFileNameMap).replace(mapRegExp, '"file":"' + baseName + '"'));
+
+ fileContents = optimized + "\n//# sourceMappingURL=" + outBaseName + ".map";
+ } else {
+ fileContents = optimized;
+ }
+ return fileContents;
+ } else {
+ throw new Error('Cannot closure compile file: ' + fileName + '. Skipping it.');
+ }
+
+ return fileContents;
+ }
+ };
+
+ return optimize;
+});
+}
+
+if(env === 'xpconnect') {
+define('xpconnect/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: true, nomen: true, regexp: true */
+/*global define: false */
+
+define('optimize', [ 'lang', 'logger', 'env!env/optimize', 'env!env/file', 'parse',
+ 'pragma', 'uglifyjs/index', 'uglifyjs2',
+ 'source-map'],
+function (lang, logger, envOptimize, file, parse,
+ pragma, uglify, uglify2,
+ sourceMap) {
+ 'use strict';
+
+ var optimize,
+ cssImportRegExp = /\@import\s+(url\()?\s*([^);]+)\s*(\))?([\w, ]*)(;)?/ig,
+ cssCommentImportRegExp = /\/\*[^\*]*@import[^\*]*\*\//g,
+ cssUrlRegExp = /\url\(\s*([^\)]+)\s*\)?/g,
+ SourceMapGenerator = sourceMap.SourceMapGenerator,
+ SourceMapConsumer =sourceMap.SourceMapConsumer;
+
+ /**
+ * If an URL from a CSS url value contains start/end quotes, remove them.
+ * 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.
+ url = url.replace(/\s+$/, "");
+
+ if (url.charAt(0) === "'" || url.charAt(0) === "\"") {
+ url = url.substring(1, url.length - 1);
+ }
+
+ return url;
+ }
+
+ /**
+ * Inlines nested stylesheets that have @import calls in them.
+ * @param {String} fileName the file name
+ * @param {String} fileContents the file contents
+ * @param {String} cssImportIgnore comma delimited string of files to ignore
+ * @param {String} cssPrefix string to be prefixed before relative URLs
+ * @param {Object} included an object used to track the files already imported
+ */
+ function flattenCss(fileName, fileContents, cssImportIgnore, cssPrefix, included) {
+ //Find the last slash in the name.
+ fileName = fileName.replace(lang.backSlashRegExp, "/");
+ var endIndex = fileName.lastIndexOf("/"),
+ //Make a file path based on the last slash.
+ //If no slash, so must be just a file name. Use empty string then.
+ filePath = (endIndex !== -1) ? fileName.substring(0, endIndex + 1) : "",
+ //store a list of merged files
+ importList = [],
+ skippedList = [];
+
+ //First make a pass by removing an commented out @import calls.
+ fileContents = fileContents.replace(cssCommentImportRegExp, '');
+
+ //Make sure we have a delimited ignore list to make matching faster
+ if (cssImportIgnore && cssImportIgnore.charAt(cssImportIgnore.length - 1) !== ",") {
+ cssImportIgnore += ",";
+ }
+
+ fileContents = fileContents.replace(cssImportRegExp, function (fullMatch, urlStart, importFileName, urlEnd, mediaTypes) {
+ //Only process media type "all" or empty media type rules.
+ if (mediaTypes && ((mediaTypes.replace(/^\s\s*/, '').replace(/\s\s*$/, '')) !== "all")) {
+ skippedList.push(fileName);
+ return fullMatch;
+ }
+
+ importFileName = cleanCssUrlQuotes(importFileName);
+
+ //Ignore the file import if it is part of an ignore list.
+ if (cssImportIgnore && cssImportIgnore.indexOf(importFileName + ",") !== -1) {
+ return fullMatch;
+ }
+
+ //Make sure we have a unix path for the rest of the operation.
+ importFileName = importFileName.replace(lang.backSlashRegExp, "/");
+
+ 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,
+ importContents = file.readFile(fullImportFileName), i,
+ importEndIndex, importPath, fixedUrlMatch, colonIndex, parts, flat;
+
+ //Skip the file if it has already been included.
+ if (included[fullImportFileName]) {
+ return '';
+ }
+ included[fullImportFileName] = true;
+
+ //Make sure to flatten any nested imports.
+ flat = flattenCss(fullImportFileName, importContents, cssImportIgnore, cssPrefix, included);
+ importContents = flat.fileContents;
+
+ if (flat.importList.length) {
+ importList.push.apply(importList, flat.importList);
+ }
+ if (flat.skippedList.length) {
+ skippedList.push.apply(skippedList, flat.skippedList);
+ }
+
+ //Make the full import path
+ importEndIndex = importFileName.lastIndexOf("/");
+
+ //Make a file path based on the last slash.
+ //If no slash, so must be just a file name. Use empty string then.
+ importPath = (importEndIndex !== -1) ? importFileName.substring(0, importEndIndex + 1) : "";
+
+ //fix url() on relative import (#5)
+ importPath = importPath.replace(/^\.\//, '');
+
+ //Modify URL paths to match the path represented by this file.
+ importContents = importContents.replace(cssUrlRegExp, function (fullMatch, urlMatch) {
+ fixedUrlMatch = cleanCssUrlQuotes(urlMatch);
+ fixedUrlMatch = fixedUrlMatch.replace(lang.backSlashRegExp, "/");
+
+ //Only do the work for relative URLs. Skip things that start with / or have
+ //a protocol.
+ colonIndex = fixedUrlMatch.indexOf(":");
+ if (fixedUrlMatch.charAt(0) !== "/" && (colonIndex === -1 || colonIndex > fixedUrlMatch.indexOf("/"))) {
+ //It is a relative URL, tack on the cssPrefix and path prefix
+ urlMatch = cssPrefix + importPath + fixedUrlMatch;
+
+ } else {
+ logger.trace(importFileName + "\n URL not a relative URL, skipping: " + urlMatch);
+ }
+
+ //Collapse .. and .
+ parts = urlMatch.split("/");
+ for (i = parts.length - 1; i > 0; i--) {
+ if (parts[i] === ".") {
+ parts.splice(i, 1);
+ } else if (parts[i] === "..") {
+ if (i !== 0 && parts[i - 1] !== "..") {
+ parts.splice(i - 1, 2);
+ i -= 1;
+ }
+ }
+ }
+
+ return "url(" + parts.join("/") + ")";
+ });
+
+ importList.push(fullImportFileName);
+ return importContents;
+ } catch (e) {
+ logger.warn(fileName + "\n Cannot inline css import, skipping: " + importFileName);
+ return fullMatch;
+ }
+ });
+
+ return {
+ importList : importList,
+ skippedList: skippedList,
+ fileContents : fileContents
+ };
+ }
+
+ optimize = {
+ /**
+ * 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} fileContents the contents to optimize. If this is
+ * a null value, then fileName will be used to read the fileContents.
+ * @param {String} outFileName the name of the file to use for the
+ * saved optimized content.
+ * @param {Object} config the build config object.
+ * @param {Array} [pluginCollector] storage for any plugin resources
+ * found.
+ */
+ jsFile: function (fileName, fileContents, outFileName, config, pluginCollector) {
+ if (!fileContents) {
+ fileContents = file.readFile(fileName);
+ }
+
+ fileContents = optimize.js(fileName, fileContents, outFileName, config, pluginCollector);
+
+ file.saveUtf8File(outFileName, fileContents);
+ },
+
+ /**
+ * 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 {Object} [config] the build config object.
+ * @param {Array} [pluginCollector] storage for any plugin resources
+ * found.
+ */
+ js: function (fileName, fileContents, outFileName, config, pluginCollector) {
+ var optFunc, optConfig,
+ parts = (String(config.optimize)).split('.'),
+ optimizerName = parts[0],
+ keepLines = parts[1] === 'keepLines',
+ licenseContents = '';
+
+ config = config || {};
+
+ //Apply pragmas/namespace renaming
+ fileContents = pragma.process(fileName, fileContents, config, 'OnSave', pluginCollector);
+
+ //Optimize the JS files if asked.
+ if (optimizerName && optimizerName !== 'none') {
+ optFunc = envOptimize[optimizerName] || optimize.optimizers[optimizerName];
+ if (!optFunc) {
+ throw new Error('optimizer with name of "' +
+ optimizerName +
+ '" not found for this environment');
+ }
+
+ optConfig = config[optimizerName] || {};
+ if (config.generateSourceMaps) {
+ optConfig.generateSourceMaps = !!config.generateSourceMaps;
+ }
+
+ try {
+ if (config.preserveLicenseComments) {
+ //Pull out any license comments for prepending after optimization.
+ try {
+ licenseContents = parse.getLicenseComments(fileName, fileContents);
+ } catch (e) {
+ throw new Error('Cannot parse file: ' + fileName + ' for comments. Skipping it. Error is:\n' + e.toString());
+ }
+ }
+
+ fileContents = licenseContents + optFunc(fileName,
+ fileContents,
+ outFileName,
+ keepLines,
+ optConfig);
+ } catch (e) {
+ if (config.throwWhen && config.throwWhen.optimize) {
+ throw e;
+ } else {
+ logger.error(e);
+ }
+ }
+ }
+
+ 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.
+ */
+ cssFile: function (fileName, outFileName, config) {
+
+ //Read in the file. Make sure we have a JS string.
+ var originalFileContents = file.readFile(fileName),
+ flat = flattenCss(fileName, originalFileContents, config.cssImportIgnore, config.cssPrefix, {}),
+ //Do not use the flattened CSS if there was one that was skipped.
+ fileContents = flat.skippedList.length ? originalFileContents : flat.fileContents,
+ startIndex, endIndex, buildText, comment;
+
+ if (flat.skippedList.length) {
+ logger.warn('Cannot inline @imports for ' + fileName +
+ ',\nthe following files had media queries in them:\n' +
+ flat.skippedList.join('\n'));
+ }
+
+ //Do comment removal.
+ try {
+ if (config.optimizeCss.indexOf(".keepComments") === -1) {
+ startIndex = 0;
+ //Get rid of comments.
+ while ((startIndex = fileContents.indexOf("/*", startIndex)) !== -1) {
+ endIndex = fileContents.indexOf("*/", startIndex + 2);
+ if (endIndex === -1) {
+ throw "Improper comment in CSS file: " + fileName;
+ }
+ comment = fileContents.substring(startIndex, endIndex);
+
+ if (config.preserveLicenseComments &&
+ (comment.indexOf('license') !== -1 ||
+ comment.indexOf('opyright') !== -1 ||
+ comment.indexOf('(c)') !== -1)) {
+ //Keep the comment, just increment the startIndex
+ startIndex = endIndex;
+ } else {
+ fileContents = fileContents.substring(0, startIndex) + fileContents.substring(endIndex + 2, fileContents.length);
+ startIndex = 0;
+ }
+ }
+ }
+ //Get rid of newlines.
+ if (config.optimizeCss.indexOf(".keepLines") === -1) {
+ fileContents = fileContents.replace(/[\r\n]/g, "");
+ fileContents = fileContents.replace(/\s+/g, " ");
+ fileContents = fileContents.replace(/\{\s/g, "{");
+ fileContents = fileContents.replace(/\s\}/g, "}");
+ } else {
+ //Remove multiple empty lines.
+ fileContents = fileContents.replace(/(\r\n)+/g, "\r\n");
+ fileContents = fileContents.replace(/(\n)+/g, "\n");
+ }
+ } catch (e) {
+ fileContents = originalFileContents;
+ logger.error("Could not optimized CSS file: " + fileName + ", error: " + e);
+ }
+
+ file.saveUtf8File(outFileName, fileContents);
+
+ //text output to stdout and/or written to build.txt file
+ buildText = "\n"+ outFileName.replace(config.dir, "") +"\n----------------\n";
+ flat.importList.push(fileName);
+ buildText += flat.importList.map(function(path){
+ return path.replace(config.dir, "");
+ }).join("\n");
+
+ return {
+ importList: flat.importList,
+ buildText: buildText +"\n"
+ };
+ },
+
+ /**
+ * 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.
+ */
+ css: function (startDir, config) {
+ var buildText = "",
+ importList = [],
+ shouldRemove = config.dir && config.removeCombined,
+ i, fileName, result, fileList;
+ if (config.optimizeCss.indexOf("standard") !== -1) {
+ fileList = file.getFilteredFileList(startDir, /\.css$/, true);
+ if (fileList) {
+ for (i = 0; i < fileList.length; i++) {
+ fileName = fileList[i];
+ logger.trace("Optimizing (" + config.optimizeCss + ") CSS file: " + fileName);
+ result = optimize.cssFile(fileName, fileName, config);
+ buildText += result.buildText;
+ if (shouldRemove) {
+ result.importList.pop();
+ importList = importList.concat(result.importList);
+ }
+ }
+ }
+
+ if (shouldRemove) {
+ importList.forEach(function (path) {
+ if (file.exists(path)) {
+ file.deleteFile(path);
+ }
+ });
+ }
+ }
+ return buildText;
+ },
+
+ optimizers: {
+ uglify: function (fileName, fileContents, outFileName, keepLines, config) {
+ var parser = uglify.parser,
+ processor = uglify.uglify,
+ ast, errMessage, errMatch;
+
+ config = config || {};
+
+ logger.trace("Uglifying file: " + fileName);
+
+ try {
+ ast = parser.parse(fileContents, config.strict_semicolons);
+ if (config.no_mangle !== true) {
+ ast = processor.ast_mangle(ast, config);
+ }
+ ast = processor.ast_squeeze(ast, config);
+
+ fileContents = processor.gen_code(ast, config);
+
+ if (config.max_line_length) {
+ fileContents = processor.split_lines(fileContents, config.max_line_length);
+ }
+
+ //Add trailing semicolon to match uglifyjs command line version
+ fileContents += ';';
+ } catch (e) {
+ errMessage = e.toString();
+ errMatch = /\nError(\r)?\n/.exec(errMessage);
+ if (errMatch) {
+ errMessage = errMessage.substring(0, errMatch.index);
+ }
+ throw new Error('Cannot uglify file: ' + fileName + '. Skipping it. Error is:\n' + errMessage);
+ }
+ return fileContents;
+ },
+ uglify2: function (fileName, fileContents, outFileName, keepLines, config) {
+ var result, existingMap, resultMap, finalMap, sourceIndex,
+ uconfig = {},
+ existingMapPath = outFileName + '.map',
+ baseName = fileName && fileName.split('/').pop();
+
+ config = config || {};
+
+ lang.mixin(uconfig, config, true);
+
+ uconfig.fromString = true;
+
+ if (config.generateSourceMaps && outFileName) {
+ uconfig.outSourceMap = baseName;
+
+ if (file.exists(existingMapPath)) {
+ uconfig.inSourceMap = existingMapPath;
+ existingMap = JSON.parse(file.readFile(existingMapPath));
+ }
+ }
+
+ logger.trace("Uglify2 file: " + fileName);
+
+ try {
+ //var tempContents = fileContents.replace(/\/\/\# sourceMappingURL=.*$/, '');
+ result = uglify2.minify(fileContents, uconfig, baseName + '.src.js');
+ if (uconfig.outSourceMap && result.map) {
+ resultMap = result.map;
+ if (existingMap) {
+ resultMap = JSON.parse(resultMap);
+ finalMap = SourceMapGenerator.fromSourceMap(new SourceMapConsumer(resultMap));
+ finalMap.applySourceMap(new SourceMapConsumer(existingMap));
+ resultMap = finalMap.toString();
+ } else {
+ file.saveFile(outFileName + '.src.js', fileContents);
+ }
+ file.saveFile(outFileName + '.map', resultMap);
+ fileContents = result.code + "\n//# sourceMappingURL=" + baseName + ".map";
+ } else {
+ fileContents = result.code;
+ }
+ } catch (e) {
+ throw new Error('Cannot uglify2 file: ' + fileName + '. Skipping it. Error is:\n' + e.toString());
+ }
+ 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.
+ */
+
+//Using sloppy since this uses eval for some code like plugins,
+//which may not be strict mode compliant. So if use strict is used
+//below they will have strict rules applied and may cause an error.
+/*jslint sloppy: true, nomen: true, plusplus: true, regexp: true */
+/*global require, define: true */
+
+//NOT asking for require as a dependency since the goal is to modify the
+//global require below
+define('requirePatch', [ 'env!env/file', 'pragma', 'parse', 'lang', 'logger', 'commonJs', 'prim'], function (
+ file,
+ pragma,
+ parse,
+ lang,
+ logger,
+ commonJs,
+ prim
+) {
+
+ var allowRun = true,
+ hasProp = lang.hasProp,
+ falseProp = lang.falseProp,
+ getOwn = lang.getOwn;
+
+ //This method should be called when the patches to require should take hold.
+ return function () {
+ if (!allowRun) {
+ return;
+ }
+ allowRun = false;
+
+ var layer,
+ pluginBuilderRegExp = /(["']?)pluginBuilder(["']?)\s*[=\:]\s*["']([^'"\s]+)["']/,
+ oldNewContext = require.s.newContext,
+ oldDef,
+
+ //create local undefined values for module and exports,
+ //so that when files are evaled in this function they do not
+ //see the node values used for r.js
+ exports,
+ module;
+
+ /**
+ * Reset "global" build caches that are kept around between
+ * build layer builds. Useful to do when there are multiple
+ * top level requirejs.optimize() calls.
+ */
+ require._cacheReset = function () {
+ //Stored raw text caches, used by browser use.
+ require._cachedRawText = {};
+ //Stored cached file contents for reuse in other layers.
+ require._cachedFileContents = {};
+ //Store which cached files contain a require definition.
+ require._cachedDefinesRequireUrls = {};
+ };
+ require._cacheReset();
+
+ /**
+ * Makes sure the URL is something that can be supported by the
+ * optimization tool.
+ * @param {String} url
+ * @returns {Boolean}
+ */
+ require._isSupportedBuildUrl = function (url) {
+ //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.
+ if (url.indexOf("://") === -1 && url.indexOf("?") === -1 &&
+ url.indexOf('empty:') !== 0 && url.indexOf('//') !== 0) {
+ return true;
+ } else {
+ if (!layer.ignoredUrls[url]) {
+ if (url.indexOf('empty:') === -1) {
+ logger.info('Cannot optimize network URL, skipping: ' + url);
+ }
+ layer.ignoredUrls[url] = true;
+ }
+ return false;
+ }
+ };
+
+ function normalizeUrlWithBase(context, moduleName, url) {
+ //Adjust the URL if it was not transformed to use baseUrl.
+ if (require.jsExtRegExp.test(moduleName)) {
+ url = (context.config.dir || context.config.dirBaseUrl) + url;
+ }
+ return url;
+ }
+
+ //Overrides the new context call to add existing tracking features.
+ require.s.newContext = function (name) {
+ var context = oldNewContext(name),
+ oldEnable = context.enable,
+ moduleProto = context.Module.prototype,
+ oldInit = moduleProto.init,
+ oldCallPlugin = moduleProto.callPlugin;
+
+ //Only do this for the context used for building.
+ if (name === '_') {
+ //For build contexts, do everything sync
+ context.nextTick = function (fn) {
+ fn();
+ };
+
+ context.needFullExec = {};
+ context.fullExec = {};
+ context.plugins = {};
+ context.buildShimExports = {};
+
+ //Override the shim exports function generator to just
+ //spit out strings that can be used in the stringified
+ //build output.
+ context.makeShimExports = function (value) {
+ function fn() {
+ return '(function (global) {\n' +
+ ' return function () {\n' +
+ ' var ret, fn;\n' +
+ (value.init ?
+ (' fn = ' + value.init.toString() + ';\n' +
+ ' ret = fn.apply(global, arguments);\n') : '') +
+ (value.exports ?
+ ' return ret || global.' + value.exports + ';\n' :
+ ' return ret;\n') +
+ ' };\n' +
+ '}(this))';
+ }
+
+ return fn;
+ };
+
+ context.enable = function (depMap, parent) {
+ var id = depMap.id,
+ parentId = parent && parent.map.id,
+ needFullExec = context.needFullExec,
+ fullExec = context.fullExec,
+ mod = getOwn(context.registry, id);
+
+ if (mod && !mod.defined) {
+ if (parentId && getOwn(needFullExec, parentId)) {
+ needFullExec[id] = true;
+ }
+
+ } else if ((getOwn(needFullExec, id) && falseProp(fullExec, id)) ||
+ (parentId && getOwn(needFullExec, parentId) &&
+ falseProp(fullExec, id))) {
+ context.require.undef(id);
+ }
+
+ return oldEnable.apply(context, arguments);
+ };
+
+ //Override load so that the file paths can be collected.
+ context.load = function (moduleName, url) {
+ /*jslint evil: true */
+ var contents, pluginBuilderMatch, builderName,
+ shim, shimExports;
+
+ //Do not mark the url as fetched 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) {
+ delete context.urlFetched[url];
+ }
+
+ //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
+ if (require._isSupportedBuildUrl(url)) {
+ //Adjust the URL if it was not transformed to use baseUrl.
+ url = normalizeUrlWithBase(context, moduleName, url);
+
+ //Save the module name to path and path to module name mappings.
+ layer.buildPathMap[moduleName] = url;
+ layer.buildFileToModule[url] = moduleName;
+
+ if (hasProp(context.plugins, moduleName)) {
+ //plugins need to have their source evaled as-is.
+ context.needFullExec[moduleName] = true;
+ }
+
+ prim().start(function () {
+ if (hasProp(require._cachedFileContents, url) &&
+ (falseProp(context.needFullExec, moduleName) ||
+ getOwn(context.fullExec, moduleName))) {
+ contents = require._cachedFileContents[url];
+
+ //If it defines require, mark it so it can be hoisted.
+ //Done here and in the else below, before the
+ //else block removes code from the contents.
+ //Related to #263
+ if (!layer.existingRequireUrl && require._cachedDefinesRequireUrls[url]) {
+ layer.existingRequireUrl = url;
+ }
+ } else {
+ //Load the file contents, process for conditionals, then
+ //evaluate it.
+ return require._cacheReadAsync(url).then(function (text) {
+ contents = text;
+
+ if (context.config.cjsTranslate &&
+ (!context.config.shim || !lang.hasProp(context.config.shim, moduleName))) {
+ contents = commonJs.convert(url, contents);
+ }
+
+ //If there is a read filter, run it now.
+ if (context.config.onBuildRead) {
+ contents = context.config.onBuildRead(moduleName, url, contents);
+ }
+
+ contents = pragma.process(url, contents, context.config, 'OnExecute');
+
+ //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.
+ try {
+ if (!layer.existingRequireUrl && parse.definesRequire(url, contents)) {
+ layer.existingRequireUrl = url;
+ require._cachedDefinesRequireUrls[url] = true;
+ }
+ } catch (e1) {
+ throw new Error('Parse error using esprima ' +
+ 'for file: ' + url + '\n' + e1);
+ }
+ }).then(function () {
+ if (hasProp(context.plugins, moduleName)) {
+ //This is a loader plugin, check to see if it has a build extension,
+ //otherwise the plugin will act as the plugin builder too.
+ pluginBuilderMatch = pluginBuilderRegExp.exec(contents);
+ if (pluginBuilderMatch) {
+ //Load the plugin builder for the plugin contents.
+ builderName = context.makeModuleMap(pluginBuilderMatch[3],
+ context.makeModuleMap(moduleName),
+ null,
+ true).id;
+ return require._cacheReadAsync(context.nameToUrl(builderName));
+ }
+ }
+ return contents;
+ }).then(function (text) {
+ contents = text;
+
+ //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 {
+ if (falseProp(context.needFullExec, moduleName)) {
+ contents = parse(moduleName, url, contents, {
+ insertNeedsDefine: true,
+ has: context.config.has,
+ findNestedDependencies: context.config.findNestedDependencies
+ });
+ }
+ } catch (e2) {
+ throw new Error('Parse error using esprima ' +
+ 'for file: ' + url + '\n' + e2);
+ }
+
+ require._cachedFileContents[url] = contents;
+ });
+ }
+ }).then(function () {
+ if (contents) {
+ eval(contents);
+ }
+
+ try {
+ //If have a string shim config, and this is
+ //a fully executed module, try to see if
+ //it created a variable in this eval scope
+ if (getOwn(context.needFullExec, moduleName)) {
+ shim = getOwn(context.config.shim, moduleName);
+ if (shim && shim.exports) {
+ shimExports = eval(shim.exports);
+ if (typeof shimExports !== 'undefined') {
+ context.buildShimExports[moduleName] = shimExports;
+ }
+ }
+ }
+
+ //Need to close out completion of this module
+ //so that listeners will get notified that it is available.
+ context.completeLoad(moduleName);
+ } catch (e) {
+ //Track which module could not complete loading.
+ if (!e.moduleTree) {
+ e.moduleTree = [];
+ }
+ e.moduleTree.push(moduleName);
+ throw e;
+ }
+ }).then(null, function (eOuter) {
+
+ if (!eOuter.fileName) {
+ eOuter.fileName = url;
+ }
+ throw eOuter;
+ }).end();
+ } else {
+ //With unsupported URLs still need to call completeLoad to
+ //finish loading.
+ context.completeLoad(moduleName);
+ }
+ };
+
+ //Marks module has having a name, and optionally executes the
+ //callback, but only if it meets certain criteria.
+ context.execCb = function (name, cb, args, exports) {
+ var buildShimExports = getOwn(layer.context.buildShimExports, name);
+
+ if (buildShimExports) {
+ return buildShimExports;
+ } else if (cb.__requireJsBuild || getOwn(layer.context.needFullExec, name)) {
+ return cb.apply(exports, args);
+ }
+ return undefined;
+ };
+
+ moduleProto.init = function (depMaps) {
+ if (context.needFullExec[this.map.id]) {
+ lang.each(depMaps, lang.bind(this, function (depMap) {
+ if (typeof depMap === 'string') {
+ depMap = context.makeModuleMap(depMap,
+ (this.map.isDefine ? this.map : this.map.parentMap));
+ }
+
+ if (!context.fullExec[depMap.id]) {
+ context.require.undef(depMap.id);
+ }
+ }));
+ }
+
+ return oldInit.apply(this, arguments);
+ };
+
+ moduleProto.callPlugin = function () {
+ var map = this.map,
+ pluginMap = context.makeModuleMap(map.prefix),
+ pluginId = pluginMap.id,
+ pluginMod = getOwn(context.registry, pluginId);
+
+ context.plugins[pluginId] = true;
+ context.needFullExec[pluginId] = true;
+
+ //If the module is not waiting to finish being defined,
+ //undef it and start over, to get full execution.
+ if (falseProp(context.fullExec, pluginId) && (!pluginMod || pluginMod.defined)) {
+ context.require.undef(pluginMap.id);
+ }
+
+ return oldCallPlugin.apply(this, arguments);
+ };
+ }
+
+ return context;
+ };
+
+ //Clear up the existing context so that the newContext modifications
+ //above will be active.
+ delete require.s.contexts._;
+
+ /** Reset state for each build layer pass. */
+ require._buildReset = function () {
+ var oldContext = require.s.contexts._;
+
+ //Clear up the existing context.
+ delete require.s.contexts._;
+
+ //Set up new context, so the layer object can hold onto it.
+ require({});
+
+ layer = require._layer = {
+ buildPathMap: {},
+ buildFileToModule: {},
+ buildFilePaths: [],
+ pathAdded: {},
+ modulesWithNames: {},
+ needsDefine: {},
+ existingRequireUrl: "",
+ ignoredUrls: {},
+ context: require.s.contexts._
+ };
+
+ //Return the previous context in case it is needed, like for
+ //the basic config object.
+ return oldContext;
+ };
+
+ require._buildReset();
+
+ //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 context.execCb, so we need to catch them
+ //at the define call.
+ oldDef = define;
+
+ //This function signature does not have to be exact, just match what we
+ //are looking for.
+ define = function (name) {
+ if (typeof name === "string" && falseProp(layer.needsDefine, name)) {
+ layer.modulesWithNames[name] = true;
+ }
+ return oldDef.apply(require, arguments);
+ };
+
+ define.amd = oldDef.amd;
+
+ //Add some utilities for plugins
+ require._readFile = file.readFile;
+ require._fileExists = function (path) {
+ return file.exists(path);
+ };
+
+ //Called when execManager runs for a dependency. Used to figure out
+ //what order of execution.
+ require.onResourceLoad = function (context, map) {
+ var id = map.id,
+ url;
+
+ //If build needed a full execution, indicate it
+ //has been done now. But only do it if the context is tracking
+ //that. Only valid for the context used in a build, not for
+ //other contexts being run, like for useLib, plain requirejs
+ //use in node/rhino.
+ if (context.needFullExec && getOwn(context.needFullExec, id)) {
+ context.fullExec[id] = true;
+ }
+
+ //A plugin.
+ if (map.prefix) {
+ if (falseProp(layer.pathAdded, id)) {
+ layer.buildFilePaths.push(id);
+ //For plugins the real path is not knowable, use the name
+ //for both module to file and file to module mappings.
+ layer.buildPathMap[id] = id;
+ layer.buildFileToModule[id] = id;
+ layer.modulesWithNames[id] = true;
+ layer.pathAdded[id] = true;
+ }
+ } else if (map.url && require._isSupportedBuildUrl(map.url)) {
+ //If the url has not been added to the layer yet, and it
+ //is from an actual file that was loaded, add it now.
+ url = normalizeUrlWithBase(context, id, map.url);
+ if (!layer.pathAdded[url] && getOwn(layer.buildPathMap, id)) {
+ //Remember the list of dependencies for this layer.
+ layer.buildFilePaths.push(url);
+ layer.pathAdded[url] = true;
+ }
+ }
+ };
+
+ //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.
+ require.needsDefine = function (moduleName) {
+ layer.needsDefine[moduleName] = true;
+ };
+ };
+});
+/**
+ * @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 */
+/*global define: false, console: false */
+
+define('commonJs', ['env!env/file', 'parse'], function (file, parse) {
+ 'use strict';
+ var commonJs = {
+ //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,
+
+ convertDir: function (commonJsPath, savePath) {
+ var fileList, i,
+ jsFileRegExp = /\.js$/,
+ fileName, convertedFileName, fileContents;
+
+ //Get list of files to convert.
+ fileList = file.getFilteredFileList(commonJsPath, /\w/, true);
+
+ //Normalize on front slashes and make sure the paths do not end in a slash.
+ commonJsPath = commonJsPath.replace(/\\/g, "/");
+ savePath = savePath.replace(/\\/g, "/");
+ if (commonJsPath.charAt(commonJsPath.length - 1) === "/") {
+ commonJsPath = commonJsPath.substring(0, commonJsPath.length - 1);
+ }
+ if (savePath.charAt(savePath.length - 1) === "/") {
+ savePath = savePath.substring(0, savePath.length - 1);
+ }
+
+ //Cycle through all the JS files and convert them.
+ if (!fileList || !fileList.length) {
+ if (commonJs.useLog) {
+ if (commonJsPath === "convert") {
+ //A request just to convert one file.
+ console.log('\n\n' + commonJs.convert(savePath, file.readFile(savePath)));
+ } else {
+ console.log("No files to convert in directory: " + commonJsPath);
+ }
+ }
+ } else {
+ for (i = 0; i < fileList.length; i++) {
+ fileName = fileList[i];
+ convertedFileName = fileName.replace(commonJsPath, savePath);
+
+ //Handle JS files.
+ if (jsFileRegExp.test(fileName)) {
+ fileContents = file.readFile(fileName);
+ fileContents = commonJs.convert(fileName, fileContents);
+ file.saveUtf8File(convertedFileName, fileContents);
+ } else {
+ //Just copy the file over.
+ file.copyFile(fileName, convertedFileName, true);
+ }
+ }
+ }
+ },
+
+ /**
+ * Does the actual file conversion.
+ *
+ * @param {String} fileName the name of the file.
+ *
+ * @param {String} fileContents the contents of a file :)
+ *
+ * @returns {String} the converted contents
+ */
+ convert: function (fileName, fileContents) {
+ //Strip out comments.
+ try {
+ var preamble = '',
+ commonJsProps = parse.usesCommonJs(fileName, fileContents);
+
+ //First see if the module is not already RequireJS-formatted.
+ if (parse.usesAmdOrRequireJs(fileName, fileContents) || !commonJsProps) {
+ return fileContents;
+ }
+
+ if (commonJsProps.dirname || commonJsProps.filename) {
+ preamble = 'var __filename = module.uri || "", ' +
+ '__dirname = __filename.substring(0, __filename.lastIndexOf("/") + 1); ';
+ }
+
+ //Construct the wrapper boilerplate.
+ fileContents = 'define(function (require, exports, module) {' +
+ preamble +
+ fileContents +
+ '\n});\n';
+
+ } catch (e) {
+ console.log("commonJs.convert: COULD NOT CONVERT: " + fileName + ", so skipping it. Error was: " + 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, regexp: true */
+/*global define, requirejs */
+
+
+define('build', function (require) {
+ 'use strict';
+
+ var build, buildBaseConfig,
+ lang = require('lang'),
+ prim = require('prim'),
+ logger = require('logger'),
+ file = require('env!env/file'),
+ parse = require('parse'),
+ optimize = require('optimize'),
+ pragma = require('pragma'),
+ transform = require('transform'),
+ requirePatch = require('requirePatch'),
+ env = require('env'),
+ commonJs = require('commonJs'),
+ SourceMapGenerator = require('source-map/source-map-generator'),
+ hasProp = lang.hasProp,
+ getOwn = lang.getOwn,
+ falseProp = lang.falseProp,
+ endsWithSemiColonRegExp = /;\s*$/;
+
+ prim.nextTick = function (fn) {
+ fn();
+ };
+
+ //Now map require to the outermost requirejs, now that we have
+ //local dependencies for this module. The rest of the require use is
+ //manipulating the requirejs loader.
+ require = requirejs;
+
+ //Caching function for performance. Attached to
+ //require so it can be reused in requirePatch.js. _cachedRawText
+ //set up by requirePatch.js
+ require._cacheReadAsync = function (path, encoding) {
+ var d;
+
+ if (lang.hasProp(require._cachedRawText, path)) {
+ d = prim();
+ d.resolve(require._cachedRawText[path]);
+ return d.promise;
+ } else {
+ return file.readFileAsync(path, encoding).then(function (text) {
+ require._cachedRawText[path] = text;
+ return text;
+ });
+ }
+ };
+
+ buildBaseConfig = {
+ appDir: "",
+ pragmas: {},
+ paths: {},
+ optimize: "uglify",
+ optimizeCss: "standard.keepLines",
+ 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,
+ _buildPathToModuleIndex: {}
+ };
+
+ /**
+ * 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, config) {
+ if (config.skipSemiColonInsertion || endsWithSemiColonRegExp.test(text)) {
+ return text;
+ } else {
+ return text + ";";
+ }
+ }
+
+ function endsWithSlash(dirName) {
+ if (dirName.charAt(dirName.length - 1) !== "/") {
+ dirName += "/";
+ }
+ return dirName;
+ }
+
+ //Method used by plugin writeFile calls, defined up here to avoid
+ //jslint warning about "making a function in a loop".
+ function makeWriteFile(namespace, 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(namespace, 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:
+ *
+ * The object could also contain a "buildFile" property, which is a string
+ * 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, errorMsg, errorStack, stackMatch, errorTree,
+ i, j, errorMod,
+ stackRegExp = /( {4}at[^\n]+)\n/,
+ standardIndent = ' ';
+
+ return prim().start(function () {
+ if (!args || lang.isArray(args)) {
+ if (!args || args.length < 1) {
+ logger.error("build.js buildProfile.js\n" +
+ "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);
+ }).then(null, function (e) {
+ errorMsg = e.toString();
+ errorTree = e.moduleTree;
+ stackMatch = stackRegExp.exec(errorMsg);
+
+ if (stackMatch) {
+ errorMsg += errorMsg.substring(0, stackMatch.index + stackMatch[0].length + 1);
+ }
+
+ //If a module tree that shows what module triggered the error,
+ //print it out.
+ if (errorTree && errorTree.length > 0) {
+ errorMsg += '\nIn module tree:\n';
+
+ for (i = errorTree.length - 1; i > -1; i--) {
+ errorMod = errorTree[i];
+ if (errorMod) {
+ for (j = errorTree.length - i; j > -1; j--) {
+ errorMsg += standardIndent;
+ }
+ errorMsg += errorMod + '\n';
+ }
+ }
+
+ logger.error(errorMsg);
+ }
+
+ errorStack = e.stack;
+
+ if (typeof args === 'string' && args.indexOf('stacktrace=true') !== -1) {
+ errorMsg += '\n' + errorStack;
+ } else {
+ if (!stackMatch && errorStack) {
+ //Just trim out the first "at" in the stack.
+ stackMatch = stackRegExp.exec(errorStack);
+ if (stackMatch) {
+ errorMsg += '\n' + stackMatch[0] || '';
+ }
+ }
+ }
+
+ throw new Error(errorMsg);
+ });
+ };
+
+ build._run = function (cmdConfig) {
+ var buildPaths, fileName, fileNames,
+ paths, i,
+ baseConfig, config,
+ modules, srcPath, buildContext,
+ destPath, moduleMap, parentModuleMap, context,
+ resources, resource, plugin, fileContents,
+ pluginProcessed = {},
+ buildFileContents = "",
+ pluginCollector = {};
+
+ return prim().start(function () {
+ var prop;
+
+ //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;
+
+ //Remove the previous build dir, in case it contains source transforms,
+ //like the ones done with onBuildRead and onBuildWrite.
+ if (config.dir && !config.keepBuildDir && file.exists(config.dir)) {
+ file.deleteFile(config.dir);
+ }
+
+ 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 (hasProp(paths, prop)) {
+ buildPaths[prop] = paths[prop].replace(config.appDir, config.dir);
+ }
+ }
+ } else {
+ //If no appDir, then make sure to copy the other paths to this directory.
+ for (prop in paths) {
+ if (hasProp(paths, prop)) {
+ //Set up build path for each path prefix, but only do so
+ //if the path falls out of the current baseUrl
+ if (paths[prop].indexOf(config.baseUrl) === 0) {
+ buildPaths[prop] = paths[prop].replace(config.baseUrl, config.dirBaseUrl);
+ } else {
+ 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,
+ //as indicated by a true "create" property on the module, and
+ //it is not a plugin-loaded resource, and there is no
+ //'rawText' containing the module's source then throw an error.
+ if (!file.exists(module._sourcePath) && !module.create &&
+ module.name.indexOf('!') === -1 &&
+ (!config.rawText || !lang.hasProp(config.rawText, module.name))) {
+ throw new Error("ERROR: module path does not exist: " +
+ module._sourcePath + " for module named: " + module.name +
+ ". Path is relative to: " + file.absPath('.'));
+ }
+ }
+ });
+ }
+
+ if (config.out) {
+ //Just set up the _buildPath for the module layer.
+ require(config);
+ if (!config.cssIn) {
+ config.modules[0]._buildPath = typeof config.out === 'function' ?
+ 'FUNCTION' : 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.
+ if (config.optimizeCss && config.optimizeCss !== "none" && config.dir) {
+ buildFileContents += optimize.css(config.dir, config);
+ }
+ }).then(function () {
+ var actions = [];
+
+ if (modules) {
+ actions = modules.map(function (module, i) {
+ return function () {
+ //Save off buildPath to module index in a hash for quicker
+ //lookup later.
+ config._buildPathToModuleIndex[module._buildPath] = i;
+
+ //Call require to calculate dependencies.
+ return build.traceDependencies(module, config)
+ .then(function (layer) {
+ module.layer = layer;
+ });
+ };
+ });
+
+ return prim.serial(actions);
+ }
+ }).then(function () {
+ var actions;
+
+ if (modules) {
+ //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.
+ actions = modules.map(function (module) {
+ return function () {
+ if (module.exclude) {
+ module.excludeLayers = [];
+ return prim.serial(module.exclude.map(function (exclude, i) {
+ return function () {
+ //See if it is already in the list of modules.
+ //If not trace dependencies for it.
+ var found = build.findBuildModule(exclude, modules);
+ if (found) {
+ module.excludeLayers[i] = found;
+ } else {
+ return build.traceDependencies({name: exclude}, config)
+ .then(function (layer) {
+ module.excludeLayers[i] = { layer: layer };
+ });
+ }
+ };
+ }));
+ }
+ };
+ });
+
+ return prim.serial(actions);
+ }
+ }).then(function () {
+ if (modules) {
+ return prim.serial(modules.map(function (module) {
+ return function () {
+ 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.buildFileToModule;
+ excludeLayer.buildFilePaths.forEach(function(filePath){
+ build.removeModulePath(map[filePath], filePath, 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 = getOwn(module.layer.buildPathMap, excludeShallowModule);
+ if (path) {
+ build.removeModulePath(excludeShallowModule, path, module.layer);
+ }
+ });
+ }
+
+ //Flatten them and collect the build output for each module.
+ return build.flattenModule(module, module.layer, config).then(function (builtModule) {
+ var finalText, baseName;
+ //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.
+ if (module._buildPath === 'FUNCTION') {
+ module._buildText = builtModule.text;
+ module._buildSourceMap = builtModule.sourceMap;
+ } else {
+ finalText = builtModule.text;
+ if (builtModule.sourceMap) {
+ baseName = module._buildPath.split('/');
+ baseName = baseName.pop();
+ finalText += '\n//# sourceMappingURL=' + baseName + '.map';
+ file.saveUtf8File(module._buildPath + '.map', builtModule.sourceMap);
+ }
+ file.saveUtf8File(module._buildPath + '-temp', finalText);
+
+ }
+ buildFileContents += builtModule.buildText;
+ });
+ };
+ }));
+ }
+ }).then(function () {
+ var moduleName;
+ if (modules) {
+ //Now move the build layers to their final position.
+ modules.forEach(function (module) {
+ var finalPath = module._buildPath;
+ if (finalPath !== 'FUNCTION') {
+ if (file.exists(finalPath)) {
+ file.deleteFile(finalPath);
+ }
+ file.renameFile(finalPath + '-temp', finalPath);
+
+ //And finally, if removeCombined is specified, remove
+ //any of the files that were used in this layer.
+ //Be sure not to remove other build layers.
+ if (config.removeCombined) {
+ module.layer.buildFilePaths.forEach(function (path) {
+ if (file.exists(path) && !modules.some(function (mod) {
+ return mod._buildPath === path;
+ })) {
+ file.deleteFile(path);
+ }
+ });
+ }
+ }
+
+ //Signal layer is done
+ if (config.onModuleBundleComplete) {
+ config.onModuleBundleComplete(module.onCompleteData);
+ }
+ });
+ }
+
+ //If removeCombined in play, remove any empty directories that
+ //may now exist because of its use
+ if (config.removeCombined && !config.out && config.dir) {
+ file.deleteEmptyDirs(config.dir);
+ }
+
+ //Do other optimizations.
+ if (config.out && !config.cssIn) {
+ //Just need to worry about one JS file.
+ fileName = config.modules[0]._buildPath;
+ if (fileName === 'FUNCTION') {
+ config.modules[0]._buildText = optimize.js(fileName,
+ config.modules[0]._buildText,
+ null,
+ config);
+ } else {
+ optimize.jsFile(fileName, null, fileName, config);
+ }
+ } else if (!config.cssIn) {
+ //Normal optimizations across modules.
+
+ //JS optimizations.
+ fileNames = file.getFilteredFileList(config.dir, /\.js$/, true);
+ fileNames.forEach(function (fileName) {
+ var cfg, override, moduleIndex;
+
+ //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);
+
+ //If there is an override for a specific layer build module,
+ //and this file is that module, mix in the override for use
+ //by optimize.jsFile.
+ moduleIndex = getOwn(config._buildPathToModuleIndex, fileName);
+ //Normalize, since getOwn could have returned undefined
+ moduleIndex = moduleIndex === 0 || moduleIndex > 0 ? moduleIndex : -1;
+
+ //Try to avoid extra work if the other files do not need to
+ //be read. Build layers should be processed at the very
+ //least for optimization.
+ if (moduleIndex > -1 || !config.skipDirOptimize ||
+ config.normalizeDirDefines === "all" ||
+ config.cjsTranslate) {
+ //Convert the file to transport format, but without a name
+ //inserted (by passing null for moduleName) since the files are
+ //standalone, one module per file.
+ fileContents = file.readFile(fileName);
+
+
+ //For builds, if wanting cjs translation, do it now, so that
+ //the individual modules can be loaded cross domain via
+ //plain script tags.
+ if (config.cjsTranslate &&
+ (!config.shim || !lang.hasProp(config.shim, moduleName))) {
+ fileContents = commonJs.convert(fileName, fileContents);
+ }
+
+ if (moduleIndex === -1) {
+ if (config.onBuildRead) {
+ fileContents = config.onBuildRead(moduleName,
+ fileName,
+ fileContents);
+ }
+
+ //Only do transport normalization if this is not a build
+ //layer (since it was already normalized) and if
+ //normalizeDirDefines indicated all should be done.
+ if (config.normalizeDirDefines === "all") {
+ fileContents = build.toTransport(config.namespace,
+ null,
+ fileName,
+ fileContents);
+ }
+
+ if (config.onBuildWrite) {
+ fileContents = config.onBuildWrite(moduleName,
+ fileName,
+ fileContents);
+ }
+ }
+
+ override = moduleIndex > -1 ?
+ config.modules[moduleIndex].override : null;
+ if (override) {
+ cfg = build.createOverrideConfig(config, override);
+ } else {
+ cfg = config;
+ }
+
+ if (moduleIndex > -1 || !config.skipDirOptimize) {
+ optimize.jsFile(fileName, fileContents, fileName, cfg, pluginCollector);
+ }
+ }
+ });
+
+ //Normalize all the plugin resources.
+ context = require.s.contexts._;
+
+ for (moduleName in pluginCollector) {
+ if (hasProp(pluginCollector, moduleName)) {
+ parentModuleMap = context.makeModuleMap(moduleName);
+ resources = pluginCollector[moduleName];
+ for (i = 0; i < resources.length; i++) {
+ resource = resources[i];
+ moduleMap = context.makeModuleMap(resource, parentModuleMap);
+ if (falseProp(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 (falseProp(pluginProcessed, moduleMap.id)) {
+ //Only do the work if the plugin was really loaded.
+ //Using an internal access because the file may
+ //not really be loaded.
+ plugin = getOwn(context.defined, moduleMap.prefix);
+ if (plugin && plugin.writeFile) {
+ plugin.writeFile(
+ moduleMap.prefix,
+ moduleMap.name,
+ require,
+ makeWriteFile(
+ config.namespace
+ ),
+ context.config
+ );
+ }
+
+ pluginProcessed[moduleMap.id] = true;
+ }
+ }
+
+ }
+ }
+
+ //console.log('PLUGIN COLLECTOR: ' + JSON.stringify(pluginCollector, null, " "));
+
+
+ //All module layers are done, write out the build.txt file.
+ file.saveUtf8File(config.dir + "build.txt", buildFileContents);
+ }
+
+ //If just have one CSS file to optimize, do that here.
+ if (config.cssIn) {
+ buildFileContents += optimize.cssFile(config.cssIn, config.out, config).buildText;
+ }
+
+ if (typeof config.out === 'function') {
+ config.out(config.modules[0]._buildText);
+ }
+
+ //Print out what was built into which layers.
+ if (buildFileContents) {
+ logger.info(buildFileContents);
+ return buildFileContents;
+ }
+
+ return '';
+ });
+ };
+
+ /**
+ * Converts command line args like "paths.foo=../some/path"
+ * result.paths = { foo: '../some/path' } where prop = paths,
+ * name = paths.foo and value = ../some/path, so it assumes the
+ * name=value splitting has already happened.
+ */
+ function stringDotToObj(result, name, value) {
+ var parts = name.split('.');
+
+ parts.forEach(function (prop, i) {
+ if (i === parts.length - 1) {
+ result[prop] = value;
+ } else {
+ if (falseProp(result, prop)) {
+ result[prop] = {};
+ }
+ result = result[prop];
+ }
+
+ });
+ }
+
+ build.objProps = {
+ paths: true,
+ wrap: true,
+ pragmas: true,
+ pragmasOnSave: true,
+ has: true,
+ hasOnSave: true,
+ uglify: true,
+ uglify2: true,
+ closure: true,
+ map: true,
+ throwWhen: true
+ };
+
+ build.hasDotPropMatch = function (prop) {
+ var dotProp,
+ index = prop.indexOf('.');
+
+ if (index !== -1) {
+ dotProp = prop.substring(0, index);
+ return hasProp(build.objProps, dotProp);
+ }
+ return false;
+ };
+
+ /**
+ * Converts an array that has String members of "name=value"
+ * 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.
+ * member name/value pairs, and converts some comma-separated lists into
+ * arrays.
+ * @param {Array} ary
+ */
+ build.convertArrayToObject = function (ary) {
+ var result = {}, i, separatorIndex, prop, value,
+ needArray = {
+ "include": true,
+ "exclude": true,
+ "excludeShallow": true,
+ "insertRequire": true,
+ "stubModules": true,
+ "deps": true
+ };
+
+ for (i = 0; i < ary.length; i++) {
+ separatorIndex = ary[i].indexOf("=");
+ if (separatorIndex === -1) {
+ throw "Malformed name/value pair: [" + ary[i] + "]. Format should be name=value";
+ }
+
+ 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 (getOwn(needArray, prop)) {
+ value = value.split(",");
+ }
+
+ if (build.hasDotPropMatch(prop)) {
+ stringDotToObj(result, prop, value);
+ } else {
+ result[prop] = value;
+ }
+ }
+ return result; //Object
+ };
+
+ build.makeAbsPath = function (path, absFilePath) {
+ if (!absFilePath) {
+ return path;
+ }
+
+ //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; i < props.length; i++) {
+ prop = props[i];
+ if (hasProp(obj, prop) && typeof obj[prop] === 'string') {
+ 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;
+
+ props = ["appDir", "dir", "baseUrl"];
+ for (i = 0; i < props.length; i++) {
+ prop = props[i];
+
+ if (getOwn(config, prop)) {
+ //Add abspath if necessary, make sure these paths end in
+ //slashes
+ if (prop === "baseUrl") {
+ 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]);
+ }
+ }
+
+ build.makeAbsObject(["out", "cssIn"], config, absFilePath);
+ build.makeAbsObject(["startFile", "endFile"], config.wrap, absFilePath);
+ };
+
+ /**
+ * Creates a relative path to targetPath from refPath.
+ * Only deals with file paths, not folders. If folders,
+ * make sure paths end in a trailing '/'.
+ */
+ build.makeRelativeFilePath = function (refPath, targetPath) {
+ var i, dotLength, finalParts, length,
+ refParts = refPath.split('/'),
+ targetParts = targetPath.split('/'),
+ //Pull off file name
+ targetName = targetParts.pop(),
+ dotParts = [];
+
+ //Also pop off the ref file name to make the matches against
+ //targetParts equivalent.
+ refParts.pop();
+
+ length = refParts.length;
+
+ for (i = 0; i < length; i += 1) {
+ if (refParts[i] !== targetParts[i]) {
+ break;
+ }
+ }
+
+ //Now i is the index in which they diverge.
+ finalParts = targetParts.slice(i);
+
+ dotLength = length - i;
+ for (i = 0; i > -1 && i < dotLength; i += 1) {
+ dotParts.push('..');
+ }
+
+ return dotParts.join('/') + (dotParts.length ? '/' : '') +
+ finalParts.join('/') + (finalParts.length ? '/' : '') +
+ targetName;
+ };
+
+ 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 (hasProp(source, 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;
+ }
+ }
+ }
+
+ //Set up log level since it can affect if errors are thrown
+ //or caught and passed to errbacks while doing config setup.
+ if (lang.hasProp(target, 'logLevel')) {
+ logger.logLevel(target.logLevel);
+ }
+ }
+
+ /**
+ * Converts a wrap.startFile or endFile to be start/end as a string.
+ * the startFile/endFile values can be arrays.
+ */
+ function flattenWrapFile(wrap, keyName, absFilePath) {
+ var keyFileName = keyName + 'File';
+
+ if (typeof wrap[keyName] !== 'string' && wrap[keyFileName]) {
+ wrap[keyName] = '';
+ if (typeof wrap[keyFileName] === 'string') {
+ wrap[keyFileName] = [wrap[keyFileName]];
+ }
+ wrap[keyFileName].forEach(function (fileName) {
+ wrap[keyName] += (wrap[keyName] ? '\n' : '') +
+ file.readFile(build.makeAbsPath(fileName, absFilePath));
+ });
+ } else if (wrap[keyName] === null || wrap[keyName] === undefined) {
+ //Allow missing one, just set to empty string.
+ wrap[keyName] = '';
+ } else if (typeof wrap[keyName] !== 'string') {
+ throw new Error('wrap.' + keyName + ' or wrap.' + keyFileName + ' malformed');
+ }
+ }
+
+ /**
+ * 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, mainConfigPath, 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);
+
+ //Set up log level early since it can affect if errors are thrown
+ //or caught and passed to errbacks, even while constructing config.
+ if (lang.hasProp(config, 'logLevel')) {
+ logger.logLevel(config.logLevel);
+ }
+
+ 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)) {
+ throw new Error("ERROR: build file does not exist: " + 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);
+
+ //Mix in the config now so that items in mainConfigFile can
+ //be resolved relative to them if necessary, like if appDir
+ //is set here, but the baseUrl is in mainConfigFile. Will
+ //re-mix in the same build config later after mainConfigFile
+ //is processed, since build config should take priority.
+ mixConfig(config, buildFileConfig);
+ } catch (e) {
+ throw new Error("Build file " + buildFile + " is malformed: " + e);
+ }
+ }
+
+ mainConfigFile = config.mainConfigFile || (buildFileConfig && buildFileConfig.mainConfigFile);
+ if (mainConfigFile) {
+ mainConfigFile = build.makeAbsPath(mainConfigFile, absFilePath);
+ if (!file.exists(mainConfigFile)) {
+ throw new Error(mainConfigFile + ' does not exist.');
+ }
+ try {
+ mainConfig = parse.findConfig(file.readFile(mainConfigFile)).config;
+ } 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.\n' +
+ 'Source error from parsing: ' + mainConfigFile + ': ' + configError);
+ }
+ if (mainConfig) {
+ mainConfigPath = mainConfigFile.substring(0, mainConfigFile.lastIndexOf('/'));
+
+ //Add in some existing config, like appDir, since they can be
+ //used inside the mainConfigFile -- paths and baseUrl are
+ //relative to them.
+ if (config.appDir && !mainConfig.appDir) {
+ mainConfig.appDir = config.appDir;
+ }
+
+ //If no baseUrl, then use the directory holding the main config.
+ if (!mainConfig.baseUrl) {
+ mainConfig.baseUrl = mainConfigPath;
+ }
+
+ build.makeAbsConfig(mainConfig, mainConfigPath);
+ 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);
+
+ //Fix paths to full paths so that they can be adjusted consistently
+ //lately to be in the output area.
+ lang.eachProp(config.paths, function (value, prop) {
+ if (lang.isArray(value)) {
+ throw new Error('paths fallback not supported in optimizer. ' +
+ 'Please provide a build config path override ' +
+ 'for ' + prop);
+ }
+ config.paths[prop] = build.makeAbsPath(value, config.baseUrl);
+ });
+
+ //Set final output dir
+ if (hasProp(config, "baseUrl")) {
+ 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.main) {
+ throw new Error('"main" passed as an option, but the ' +
+ 'supported option is called "name".');
+ }
+ if (config.out && !config.name && !config.modules && !config.include &&
+ !config.cssIn) {
+ throw new Error('Missing either a "name", "include" or "modules" ' +
+ 'option');
+ }
+ if (config.cssIn) {
+ if (config.dir || config.appDir) {
+ throw new Error('cssIn is only for the output of single file ' +
+ 'CSS optimizations and is not compatible with "dir" or "appDir" configuration.');
+ }
+ if (!config.out) {
+ throw new Error('"out" option missing.');
+ }
+ }
+ if (!config.cssIn && !config.baseUrl) {
+ //Just use the current directory as the baseUrl
+ config.baseUrl = './';
+ }
+ if (!config.out && !config.dir) {
+ throw new Error('Missing either an "out" or "dir" config value. ' +
+ 'If using "appDir" for a full project optimization, ' +
+ 'use "dir". If you want to optimize to one file, ' +
+ 'use "out".');
+ }
+ if (config.appDir && config.out) {
+ throw new Error('"appDir" is not compatible with "out". Use "dir" ' +
+ 'instead. appDir is used to copy whole projects, ' +
+ 'where "out" with "baseUrl" is used to just ' +
+ 'optimize to one file.');
+ }
+ if (config.out && config.dir) {
+ throw new Error('The "out" and "dir" options are incompatible.' +
+ ' Use "out" if you are targeting a single file for' +
+ ' for optimization, and "dir" if you want the appDir' +
+ ' or baseUrl directories optimized.');
+ }
+
+ if (config.dir) {
+ // Make sure the output dir is not set to a parent of the
+ // source dir or the same dir, as it will result in source
+ // code deletion.
+ if (config.dir === config.baseUrl ||
+ config.dir === config.appDir ||
+ (config.baseUrl && build.makeRelativeFilePath(config.dir,
+ config.baseUrl).indexOf('..') !== 0) ||
+ (config.appDir &&
+ build.makeRelativeFilePath(config.dir, config.appDir).indexOf('..') !== 0)) {
+ throw new Error('"dir" is set to a parent or same directory as' +
+ ' "appDir" or "baseUrl". This can result in' +
+ ' the deletion of source code. Stopping.');
+ }
+ }
+
+ if (config.insertRequire && !lang.isArray(config.insertRequire)) {
+ throw new Error('insertRequire should be a list of module IDs' +
+ ' to insert in to a require([]) call.');
+ }
+
+ if (config.generateSourceMaps) {
+ if (config.preserveLicenseComments && config.optimize !== 'none') {
+ throw new Error('Cannot use preserveLicenseComments and ' +
+ 'generateSourceMaps together. Either explcitly set ' +
+ 'preserveLicenseComments to false (default is true) or ' +
+ 'turn off generateSourceMaps. If you want source maps with ' +
+ 'license comments, see: ' +
+ 'http://requirejs.org/docs/errors.html#sourcemapcomments');
+ } else if (config.optimize !== 'none' &&
+ config.optimize !== 'closure' &&
+ config.optimize !== 'uglify2') {
+ //Allow optimize: none to pass, since it is useful when toggling
+ //minification on and off to debug something, and it implicitly
+ //works, since it does not need a source map.
+ throw new Error('optimize: "' + config.optimize +
+ '" does not support generateSourceMaps.');
+ }
+ }
+
+ 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,
+ create: config.create,
+ include: config.include,
+ exclude: config.exclude,
+ excludeShallow: config.excludeShallow,
+ insertRequire: config.insertRequire,
+ stubModules: config.stubModules
+ }
+ ];
+ delete config.stubModules;
+ } else if (config.modules && config.out) {
+ throw new Error('If the "modules" option is used, then there ' +
+ 'should be a "dir" option set and "out" should ' +
+ 'not be used since "out" is only for single file ' +
+ 'optimization output.');
+ } else if (config.modules && config.name) {
+ throw new Error('"name" and "modules" options are incompatible. ' +
+ 'Either use "name" if doing a single file ' +
+ 'optimization, or "modules" if you want to target ' +
+ 'more than one file for optimization.');
+ }
+
+ 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) {
+ config.optimizeCss = "none";
+ }
+ }
+
+ //Normalize cssPrefix
+ if (config.cssPrefix) {
+ //Make sure cssPrefix ends in a slash
+ config.cssPrefix = endsWithSlash(config.cssPrefix);
+ } else {
+ config.cssPrefix = '';
+ }
+
+ //Cycle through modules and combine any local stubModules with
+ //global values.
+ if (config.modules && config.modules.length) {
+ config.modules.forEach(function (mod) {
+ if (config.stubModules) {
+ mod.stubModules = config.stubModules.concat(mod.stubModules || []);
+ }
+
+ //Create a hash lookup for the stubModules config to make lookup
+ //cheaper later.
+ if (mod.stubModules) {
+ mod.stubModules._byName = {};
+ mod.stubModules.forEach(function (id) {
+ mod.stubModules._byName[id] = true;
+ });
+ }
+ });
+ }
+
+ //Get any wrap text.
+ try {
+ if (config.wrap) {
+ if (config.wrap === true) {
+ //Use default values.
+ config.wrap = {
+ start: '(function () {',
+ end: '}());'
+ };
+ } else {
+ flattenWrapFile(config.wrap, 'start', absFilePath);
+ flattenWrapFile(config.wrap, 'end', absFilePath);
+ }
+ }
+ } catch (wrapError) {
+ throw new Error('Malformed wrap config: ' + wrapError.toString());
+ }
+
+ //Do final input verification
+ if (config.context) {
+ throw new Error('The build argument "context" is not supported' +
+ ' in a build. It should only be used in web' +
+ ' pages.');
+ }
+
+ //Set up normalizeDirDefines. If not explicitly set, if optimize "none",
+ //set to "skip" otherwise set to "all".
+ if (!hasProp(config, 'normalizeDirDefines')) {
+ if (config.optimize === 'none' || config.skipDirOptimize) {
+ config.normalizeDirDefines = 'skip';
+ } else {
+ config.normalizeDirDefines = 'all';
+ }
+ }
+
+ //Set file.fileExclusionRegExp if desired
+ if (hasProp(config, 'fileExclusionRegExp')) {
+ if (typeof config.fileExclusionRegExp === "string") {
+ file.exclusionRegExp = new RegExp(config.fileExclusionRegExp);
+ } else {
+ file.exclusionRegExp = config.fileExclusionRegExp;
+ }
+ } else if (hasProp(config, 'dirExclusionRegExp')) {
+ //Set file.dirExclusionRegExp if desired, this is the old
+ //name for fileExclusionRegExp before 1.0.2. Support for backwards
+ //compatibility
+ file.exclusionRegExp = config.dirExclusionRegExp;
+ }
+
+ //Remove things that may cause problems in the build.
+ delete config.jQuery;
+ delete config.enforceDefine;
+ delete config.urlArgs;
+
+ return config;
+ };
+
+ /**
+ * finds the module being built/optimized with the given moduleName,
+ * 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; i < modules.length; i++) {
+ module = modules[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
+ * @param {Object} layer the layer to remove the module/path from
+ */
+ build.removeModulePath = function (module, path, layer) {
+ var index = layer.buildFilePaths.indexOf(path);
+ if (index !== -1) {
+ layer.buildFilePaths.splice(index, 1);
+ }
+ };
+
+ /**
+ * 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,
+ rawTextByIds,
+ syncChecks = {
+ rhino: true,
+ node: true,
+ xpconnect: true
+ },
+ deferred = prim();
+
+ //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.mixin({}, baseConfig, true));
+
+ logger.trace("\nTracing dependencies for: " + (module.name || module.out));
+ 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.mixin({}, baseConfig, true);
+ lang.mixin(override, module.override, true);
+ require(override);
+ }
+
+ //Now, populate the rawText cache with any values explicitly passed in
+ //via config.
+ rawTextByIds = require.s.contexts._.config.rawText;
+ if (rawTextByIds) {
+ lang.eachProp(rawTextByIds, function (contents, id) {
+ var url = require.toUrl(id) + '.js';
+ require._cachedRawText[url] = contents;
+ });
+ }
+
+
+ //Configure the callbacks to be called.
+ deferred.reject.__requireJsBuild = true;
+
+ //Use a wrapping function so can check for errors.
+ function includeFinished(value) {
+ //If a sync build environment, check for errors here, instead of
+ //in the then callback below, since some errors, like two IDs pointed
+ //to same URL but only one anon ID will leave the loader in an
+ //unresolved state since a setTimeout cannot be used to check for
+ //timeout.
+ var hasError = false;
+ if (syncChecks[env.get()]) {
+ try {
+ build.checkForErrors(context);
+ } catch (e) {
+ hasError = true;
+ deferred.reject(e);
+ }
+ }
+
+ if (!hasError) {
+ deferred.resolve(value);
+ }
+ }
+ includeFinished.__requireJsBuild = true;
+
+ //Figure out module layer dependencies by calling require to do the work.
+ require(include, includeFinished, deferred.reject);
+
+ return deferred.promise.then(function () {
+ //Reset config
+ if (module.override) {
+ require(baseConfig);
+ }
+
+ build.checkForErrors(context);
+
+ return layer;
+ });
+ };
+
+ build.checkForErrors = function (context) {
+ //Check to see if it all loaded. If not, then throw, and give
+ //a message on what is left.
+ var id, prop, mod, errUrl, idParts, pluginId,
+ errMessage = '',
+ failedPluginMap = {},
+ failedPluginIds = [],
+ errIds = [],
+ errUrlMap = {},
+ errUrlConflicts = {},
+ hasErrUrl = false,
+ registry = context.registry;
+
+ for (id in registry) {
+ if (hasProp(registry, id) && id.indexOf('_@r') !== 0) {
+ mod = getOwn(registry, id);
+ if (id.indexOf('_unnormalized') === -1 && mod && mod.enabled) {
+ errIds.push(id);
+ errUrl = mod.map.url;
+
+ if (errUrlMap[errUrl]) {
+ hasErrUrl = true;
+ //This error module has the same URL as another
+ //error module, could be misconfiguration.
+ if (!errUrlConflicts[errUrl]) {
+ errUrlConflicts[errUrl] = [];
+ //Store the original module that had the same URL.
+ errUrlConflicts[errUrl].push(errUrlMap[errUrl]);
+ }
+ errUrlConflicts[errUrl].push(id);
+ } else {
+ errUrlMap[errUrl] = id;
+ }
+ }
+
+ //Look for plugins that did not call load()
+ idParts = id.split('!');
+ pluginId = idParts[0];
+ if (idParts.length > 1 && falseProp(failedPluginMap, pluginId)) {
+ failedPluginIds.push(pluginId);
+ failedPluginMap[pluginId] = true;
+ }
+ }
+ }
+
+ if (errIds.length || failedPluginIds.length) {
+ if (failedPluginIds.length) {
+ errMessage += 'Loader plugin' +
+ (failedPluginIds.length === 1 ? '' : 's') +
+ ' did not call ' +
+ 'the load callback in the build: ' +
+ failedPluginIds.join(', ') + '\n';
+ }
+ errMessage += 'Module loading did not complete for: ' + errIds.join(', ');
+
+ if (hasErrUrl) {
+ errMessage += '\nThe following modules share the same URL. This ' +
+ 'could be a misconfiguration if that URL only has ' +
+ 'one anonymous module in it:';
+ for (prop in errUrlConflicts) {
+ if (hasProp(errUrlConflicts, prop)) {
+ errMessage += '\n' + prop + ': ' +
+ errUrlConflicts[prop].join(', ');
+ }
+ }
+ }
+ throw new Error(errMessage);
+ }
+
+ };
+
+ build.createOverrideConfig = function (config, override) {
+ var cfg = {};
+
+ lang.mixin(cfg, config, true);
+ lang.eachProp(override, function (value, prop) {
+ if (hasProp(build.objProps, prop)) {
+ //An object property, merge keys. Start a new object
+ //so that source object in config does not get modified.
+ cfg[prop] = {};
+ lang.mixin(cfg[prop], config[prop], true);
+ lang.mixin(cfg[prop], override[prop], true);
+ } else {
+ cfg[prop] = override[prop];
+ }
+ });
+ return cfg;
+ };
+
+ /**
+ * 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.
+ *
+ * @returns {Object} with two properties: "text", the text of the flattened
+ * module, and "buildText", a string of text representing which files were
+ * included in the flattened module text.
+ */
+ build.flattenModule = function (module, layer, config) {
+ var fileContents, sourceMapGenerator,
+ sourceMapBase,
+ buildFileContents = '';
+
+ return prim().start(function () {
+ var reqIndex, currContents,
+ moduleName, shim, packageConfig, nonPackageName,
+ parts, builder, writeApi,
+ namespace, namespaceWithDot, stubModulesByName,
+ context = layer.context,
+ onLayerEnds = [],
+ onLayerEndAdded = {};
+
+ //Use override settings, particularly for pragmas
+ //Do this before the var readings since it reads config values.
+ if (module.override) {
+ config = build.createOverrideConfig(config, module.override);
+ }
+
+ namespace = config.namespace || '';
+ namespaceWithDot = namespace ? namespace + '.' : '';
+ stubModulesByName = (module.stubModules && module.stubModules._byName) || {};
+
+ //Start build output for the module.
+ module.onCompleteData = {
+ name: module.name,
+ path: (config.dir ? module._buildPath.replace(config.dir, "") : module._buildPath),
+ included: []
+ };
+
+ buildFileContents += "\n" +
+ module.onCompleteData.path +
+ "\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);
+ }
+ }
+
+ if (config.generateSourceMaps) {
+ sourceMapBase = config.dir || config.baseUrl;
+ sourceMapGenerator = new SourceMapGenerator.SourceMapGenerator({
+ file: module._buildPath.replace(sourceMapBase, '')
+ });
+ }
+
+ //Write the built module to disk, and build up the build output.
+ fileContents = "";
+ return prim.serial(layer.buildFilePaths.map(function (path) {
+ return function () {
+ var lineCount,
+ singleContents = '';
+
+ moduleName = layer.buildFileToModule[path];
+ //If the moduleName is for a package main, then update it to the
+ //real main value.
+ packageConfig = layer.context.config.pkgs &&
+ getOwn(layer.context.config.pkgs, moduleName);
+ if (packageConfig) {
+ nonPackageName = moduleName;
+ moduleName += '/' + packageConfig.main;
+ }
+
+ return prim().start(function () {
+ //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 && getOwn(context.defined, parts.prefix);
+ if (builder) {
+ if (builder.onLayerEnd && falseProp(onLayerEndAdded, parts.prefix)) {
+ onLayerEnds.push(builder);
+ onLayerEndAdded[parts.prefix] = true;
+ }
+
+ if (builder.write) {
+ writeApi = function (input) {
+ singleContents += "\n" + addSemiColon(input, config);
+ if (config.onBuildWrite) {
+ singleContents = config.onBuildWrite(moduleName, path, singleContents);
+ }
+ };
+ writeApi.asModule = function (moduleName, input) {
+ singleContents += "\n" +
+ addSemiColon(build.toTransport(namespace, moduleName, path, input, layer, {
+ useSourceUrl: layer.context.config.useSourceUrl
+ }), config);
+ if (config.onBuildWrite) {
+ singleContents = config.onBuildWrite(moduleName, path, singleContents);
+ }
+ };
+ builder.write(parts.prefix, parts.name, writeApi);
+ }
+ return;
+ } else {
+ return prim().start(function () {
+ if (hasProp(stubModulesByName, moduleName)) {
+ //Just want to insert a simple module definition instead
+ //of the source module. Useful for plugins that inline
+ //all their resources.
+ if (hasProp(layer.context.plugins, moduleName)) {
+ //Slightly different content for plugins, to indicate
+ //that dynamic loading will not work.
+ return 'define({load: function(id){throw new Error("Dynamic load not allowed: " + id);}});';
+ } else {
+ return 'define({});';
+ }
+ } else {
+ return require._cacheReadAsync(path);
+ }
+ }).then(function (text) {
+ var hasPackageName;
+
+ currContents = text;
+
+ if (config.cjsTranslate &&
+ (!config.shim || !lang.hasProp(config.shim, moduleName))) {
+ currContents = commonJs.convert(path, currContents);
+ }
+
+ if (config.onBuildRead) {
+ currContents = config.onBuildRead(moduleName, path, currContents);
+ }
+
+ if (packageConfig) {
+ hasPackageName = (nonPackageName === parse.getNamedDefine(currContents));
+ }
+
+ if (namespace) {
+ currContents = pragma.namespace(currContents, namespace);
+ }
+
+ currContents = build.toTransport(namespace, moduleName, path, currContents, layer, {
+ useSourceUrl: config.useSourceUrl
+ });
+
+ if (packageConfig && !hasPackageName) {
+ currContents = addSemiColon(currContents, config) + '\n';
+ currContents += namespaceWithDot + "define('" +
+ packageConfig.name + "', ['" + moduleName +
+ "'], function (main) { return main; });\n";
+ }
+
+ if (config.onBuildWrite) {
+ currContents = config.onBuildWrite(moduleName, path, currContents);
+ }
+
+ //Semicolon is for files that are not well formed when
+ //concatenated with other content.
+ singleContents += "\n" + addSemiColon(currContents, config);
+ });
+ }
+ }).then(function () {
+ var sourceMapPath, sourceMapLineNumber,
+ shortPath = path.replace(config.dir, "");
+
+ module.onCompleteData.included.push(shortPath);
+ buildFileContents += shortPath + "\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 && falseProp(layer.modulesWithNames, moduleName) && !config.skipModuleInsertion) {
+ shim = config.shim && (getOwn(config.shim, moduleName) || (packageConfig && getOwn(config.shim, nonPackageName)));
+ if (shim) {
+ singleContents += '\n' + namespaceWithDot + 'define("' + moduleName + '", ' +
+ (shim.deps && shim.deps.length ?
+ build.makeJsArrayString(shim.deps) + ', ' : '') +
+ (shim.exportsFn ? shim.exportsFn() : 'function(){}') +
+ ');\n';
+ } else {
+ singleContents += '\n' + namespaceWithDot + 'define("' + moduleName + '", function(){});\n';
+ }
+ }
+
+ //Add to the source map
+ if (sourceMapGenerator) {
+ sourceMapPath = build.makeRelativeFilePath(module._buildPath, path);
+ sourceMapLineNumber = fileContents.split('\n').length - 1;
+ lineCount = singleContents.split('\n').length;
+ for (var i = 1; i <= lineCount; i += 1) {
+ sourceMapGenerator.addMapping({
+ generated: {
+ line: sourceMapLineNumber + i,
+ column: 0
+ },
+ original: {
+ line: i,
+ column: 0
+ },
+ source: sourceMapPath
+ });
+ }
+
+ //Store the content of the original in the source
+ //map since other transforms later like minification
+ //can mess up translating back to the original
+ //source
+ sourceMapGenerator.setSourceContent(sourceMapPath, singleContents);
+ }
+
+ //Add the file to the final contents
+ fileContents += singleContents;
+ });
+ };
+ })).then(function () {
+ if (onLayerEnds.length) {
+ onLayerEnds.forEach(function (builder) {
+ var path;
+ if (typeof module.out === 'string') {
+ path = module.out;
+ } else if (typeof module._buildPath === 'string') {
+ path = module._buildPath;
+ }
+ builder.onLayerEnd(function (input) {
+ fileContents += "\n" + addSemiColon(input, config);
+ }, {
+ name: module.name,
+ path: path
+ });
+ });
+ }
+
+ if (module.create) {
+ //The ID is for a created layer. Write out
+ //a module definition for it in case the
+ //built file is used with enforceDefine
+ //(#432)
+ fileContents += '\n' + namespaceWithDot + 'define("' + module.name + '", function(){});\n';
+ }
+
+ //Add a require at the end to kick start module execution, if that
+ //was desired. Usually this is only specified when using small shim
+ //loaders like almond.
+ if (module.insertRequire) {
+ fileContents += '\n' + namespaceWithDot + 'require(["' + module.insertRequire.join('", "') + '"]);\n';
+ }
+ });
+ }).then(function () {
+ return {
+ text: config.wrap ?
+ config.wrap.start + fileContents + config.wrap.end :
+ fileContents,
+ buildText: buildFileContents,
+ sourceMap: sourceMapGenerator ?
+ JSON.stringify(sourceMapGenerator.toJSON(), null, ' ') :
+ undefined
+ };
+ });
+ };
+
+ //Converts an JS array of strings to a string representation.
+ //Not using JSON.stringify() for Rhino's sake.
+ build.makeJsArrayString = function (ary) {
+ return '["' + ary.map(function (item) {
+ //Escape any double quotes, backslashes
+ return lang.jsEscape(item);
+ }).join('","') + '"]';
+ };
+
+ build.toTransport = function (namespace, moduleName, path, contents, layer, options) {
+ var baseUrl = layer && layer.context.config.baseUrl;
+
+ function onFound(info) {
+ //Only mark this module as having a name if not a named module,
+ //or if a named module and the name matches expectations.
+ if (layer && (info.needsId || info.foundId === moduleName)) {
+ layer.modulesWithNames[moduleName] = true;
+ }
+ }
+
+ //Convert path to be a local one to the baseUrl, useful for
+ //useSourceUrl.
+ if (baseUrl) {
+ path = path.replace(baseUrl, '');
+ }
+
+ return transform.toTransport(namespace, moduleName, path, contents, onFound, options);
+ };
+
+ 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.
+ dir = fileName.replace(/\\/g, '/');
+ if (dir.indexOf('/') !== -1) {
+ dir = dir.split('/');
+ dir.pop();
+ dir = dir.join('/');
+ exec("require({baseUrl: '" + dir + "'});");
+ }
+ }
+
+ function createRjsApi() {
+ //Create a method that will run the optimzer given an object
+ //config.
+ requirejs.optimize = function (config, callback, errback) {
+ if (!loadedOptimizedLib) {
+ loadLib();
+ loadedOptimizedLib = true;
+ }
+
+ //Create the function that will be called once build modules
+ //have been loaded.
+ var runBuild = function (build, logger, quit) {
+ //Make sure config has a log level, and if not,
+ //make it "silent" by default.
+ config.logLevel = config.hasOwnProperty('logLevel') ?
+ config.logLevel : logger.SILENT;
+
+ //Reset build internals first in case this is part
+ //of a long-running server process that could have
+ //exceptioned out in a bad state. It is only defined
+ //after the first call though.
+ if (requirejs._buildReset) {
+ requirejs._buildReset();
+ requirejs._cacheReset();
+ }
+
+ function done(result) {
+ //And clean up, in case something else triggers
+ //a build in another pathway.
+ if (requirejs._buildReset) {
+ requirejs._buildReset();
+ requirejs._cacheReset();
+ }
+
+ // Ensure errors get propagated to the errback
+ if (result instanceof Error) {
+ throw result;
+ }
+
+ return result;
+ }
+
+ errback = errback || function (err) {
+ // Using console here since logger may have
+ // turned off error logging. Since quit is
+ // called want to be sure a message is printed.
+ console.log(err);
+ quit(1);
+ };
+
+ build(config).then(done, done).then(callback, errback);
+ };
+
+ requirejs({
+ context: 'build'
+ }, ['build', 'logger', 'env!env/quit'], runBuild);
+ };
+
+ requirejs.tools = {
+ useLib: function (contextName, callback) {
+ if (!callback) {
+ callback = contextName;
+ contextName = 'uselib';
+ }
+
+ if (!useLibLoaded[contextName]) {
+ loadLib();
+ useLibLoaded[contextName] = true;
+ }
+
+ var req = requirejs({
+ context: contextName
+ });
+
+ req(['build'], function () {
+ callback(req);
+ });
+ }
+ };
+
+ requirejs.define = define;
+ }
+
+ //If in Node, and included via a require('requirejs'), just export and
+ //THROW IT ON THE GROUND!
+ if (env === 'node' && reqMain !== module) {
+ setBaseUrl(path.resolve(reqMain ? reqMain.filename : '.'));
+
+ createRjsApi();
+
+ module.exports = requirejs;
+ return;
+ } else if (env === 'browser') {
+ //Only option is to use the API.
+ setBaseUrl(location.href);
+ createRjsApi();
+ return;
+ } else if ((env === 'rhino' || env === 'xpconnect') &&
+ //User sets up requirejsAsLib variable to indicate it is loaded
+ //via load() to be used as a library.
+ typeof requirejsAsLib !== 'undefined' && requirejsAsLib) {
+ //This script is loaded via rhino's load() method, expose the
+ //API and get out.
+ setBaseUrl(fileName);
+ createRjsApi();
+ 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({
+ baseUrl: require.s.contexts._.config.baseUrl,
+ //Use a separate context than the default context so that the
+ //build can use the default context.
+ context: 'build',
+ catchError: {
+ define: true
+ }
+}, ['env!env/args', 'env!env/quit', 'logger', 'build'],
+function (args, quit, logger, build) {
+ build(args).then(function () {}, function (err) {
+ logger.error(err);
+ quit(1);
+ });
+});
+
+
+ } else if (commandOption === 'v') {
+ console.log('r.js: ' + version +
+ ', RequireJS: ' + this.requirejsVars.require.version +
+ ', UglifyJS2: 2.3.6, UglifyJS: 1.3.4');
+ } else if (commandOption === 'convert') {
+ loadLib();
+
+ this.requirejsVars.require(['env!env/args', 'commonJs', 'env!env/print'],
+ function (args, commonJs, print) {
+
+ var srcDir, outDir;
+ srcDir = args[0];
+ outDir = args[1];
+
+ if (!srcDir || !outDir) {
+ print('Usage: path/to/commonjs/modules output/dir');
+ return;
+ }
+
+ commonJs.convertDir(args[0], args[1]);
+ });
+ } else {
+ //Just run an app
+
+ //Load the bundled libraries for use in the app.
+ if (commandOption === 'lib') {
+ loadLib();
+ }
+
+ setBaseUrl(fileName);
+
+ if (exists(fileName)) {
+ exec(readFile(fileName), fileName);
+ } else {
+ showHelp();
+ }
+ }
+
+}((typeof console !== 'undefined' ? console : undefined),
+ (typeof Packages !== 'undefined' || (typeof window === 'undefined' &&
+ typeof Components !== 'undefined' && Components.interfaces) ?
+ Array.prototype.slice.call(arguments, 0) : []),
+ (typeof readFile !== 'undefined' ? readFile : undefined))); \ No newline at end of file
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-25 18:32:10 +0000