...;
+ Parser.prototype.parseImportDefaultSpecifier = function () {
+ var node = this.createNode();
+ var local = this.parseIdentifierName();
+ return this.finalize(node, new Node.ImportDefaultSpecifier(local));
+ };
+ // import <* as foo> ...;
+ Parser.prototype.parseImportNamespaceSpecifier = function () {
+ var node = this.createNode();
+ this.expect('*');
+ if (!this.matchContextualKeyword('as')) {
+ this.throwError(messages_1.Messages.NoAsAfterImportNamespace);
+ }
+ this.nextToken();
+ var local = this.parseIdentifierName();
+ return this.finalize(node, new Node.ImportNamespaceSpecifier(local));
+ };
+ Parser.prototype.parseImportDeclaration = function () {
+ if (this.context.inFunctionBody) {
+ this.throwError(messages_1.Messages.IllegalImportDeclaration);
+ }
+ var node = this.createNode();
+ this.expectKeyword('import');
+ var src;
+ var specifiers = [];
+ if (this.lookahead.type === 8 /* StringLiteral */) {
+ // import 'foo';
+ src = this.parseModuleSpecifier();
+ }
+ else {
+ if (this.match('{')) {
+ // import {bar}
+ specifiers = specifiers.concat(this.parseNamedImports());
+ }
+ else if (this.match('*')) {
+ // import * as foo
+ specifiers.push(this.parseImportNamespaceSpecifier());
+ }
+ else if (this.isIdentifierName(this.lookahead) && !this.matchKeyword('default')) {
+ // import foo
+ specifiers.push(this.parseImportDefaultSpecifier());
+ if (this.match(',')) {
+ this.nextToken();
+ if (this.match('*')) {
+ // import foo, * as foo
+ specifiers.push(this.parseImportNamespaceSpecifier());
+ }
+ else if (this.match('{')) {
+ // import foo, {bar}
+ specifiers = specifiers.concat(this.parseNamedImports());
+ }
+ else {
+ this.throwUnexpectedToken(this.lookahead);
+ }
+ }
+ }
+ else {
+ this.throwUnexpectedToken(this.nextToken());
+ }
+ if (!this.matchContextualKeyword('from')) {
+ var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;
+ this.throwError(message, this.lookahead.value);
+ }
+ this.nextToken();
+ src = this.parseModuleSpecifier();
+ }
+ this.consumeSemicolon();
+ return this.finalize(node, new Node.ImportDeclaration(specifiers, src));
+ };
+ // https://tc39.github.io/ecma262/#sec-exports
+ Parser.prototype.parseExportSpecifier = function () {
+ var node = this.createNode();
+ var local = this.parseIdentifierName();
+ var exported = local;
+ if (this.matchContextualKeyword('as')) {
+ this.nextToken();
+ exported = this.parseIdentifierName();
+ }
+ return this.finalize(node, new Node.ExportSpecifier(local, exported));
+ };
+ Parser.prototype.parseExportDeclaration = function () {
+ if (this.context.inFunctionBody) {
+ this.throwError(messages_1.Messages.IllegalExportDeclaration);
+ }
+ var node = this.createNode();
+ this.expectKeyword('export');
+ var exportDeclaration;
+ if (this.matchKeyword('default')) {
+ // export default ...
+ this.nextToken();
+ if (this.matchKeyword('function')) {
+ // export default function foo () {}
+ // export default function () {}
+ var declaration = this.parseFunctionDeclaration(true);
+ exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
+ }
+ else if (this.matchKeyword('class')) {
+ // export default class foo {}
+ var declaration = this.parseClassDeclaration(true);
+ exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
+ }
+ else if (this.matchContextualKeyword('async')) {
+ // export default async function f () {}
+ // export default async function () {}
+ // export default async x => x
+ var declaration = this.matchAsyncFunction() ? this.parseFunctionDeclaration(true) : this.parseAssignmentExpression();
+ exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
+ }
+ else {
+ if (this.matchContextualKeyword('from')) {
+ this.throwError(messages_1.Messages.UnexpectedToken, this.lookahead.value);
+ }
+ // export default {};
+ // export default [];
+ // export default (1 + 2);
+ var declaration = this.match('{') ? this.parseObjectInitializer() :
+ this.match('[') ? this.parseArrayInitializer() : this.parseAssignmentExpression();
+ this.consumeSemicolon();
+ exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
+ }
+ }
+ else if (this.match('*')) {
+ // export * from 'foo';
+ this.nextToken();
+ if (!this.matchContextualKeyword('from')) {
+ var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;
+ this.throwError(message, this.lookahead.value);
+ }
+ this.nextToken();
+ var src = this.parseModuleSpecifier();
+ this.consumeSemicolon();
+ exportDeclaration = this.finalize(node, new Node.ExportAllDeclaration(src));
+ }
+ else if (this.lookahead.type === 4 /* Keyword */) {
+ // export var f = 1;
+ var declaration = void 0;
+ switch (this.lookahead.value) {
+ case 'let':
+ case 'const':
+ declaration = this.parseLexicalDeclaration({ inFor: false });
+ break;
+ case 'var':
+ case 'class':
+ case 'function':
+ declaration = this.parseStatementListItem();
+ break;
+ default:
+ this.throwUnexpectedToken(this.lookahead);
+ }
+ exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(declaration, [], null));
+ }
+ else if (this.matchAsyncFunction()) {
+ var declaration = this.parseFunctionDeclaration();
+ exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(declaration, [], null));
+ }
+ else {
+ var specifiers = [];
+ var source = null;
+ var isExportFromIdentifier = false;
+ this.expect('{');
+ while (!this.match('}')) {
+ isExportFromIdentifier = isExportFromIdentifier || this.matchKeyword('default');
+ specifiers.push(this.parseExportSpecifier());
+ if (!this.match('}')) {
+ this.expect(',');
+ }
+ }
+ this.expect('}');
+ if (this.matchContextualKeyword('from')) {
+ // export {default} from 'foo';
+ // export {foo} from 'foo';
+ this.nextToken();
+ source = this.parseModuleSpecifier();
+ this.consumeSemicolon();
+ }
+ else if (isExportFromIdentifier) {
+ // export {default}; // missing fromClause
+ var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;
+ this.throwError(message, this.lookahead.value);
+ }
+ else {
+ // export {foo};
+ this.consumeSemicolon();
+ }
+ exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(null, specifiers, source));
+ }
+ return exportDeclaration;
+ };
+ return Parser;
+ }());
+ exports.Parser = Parser;
+
+
+/***/ },
+/* 9 */
+/***/ function(module, exports) {
+
+ "use strict";
+ // 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.
+ Object.defineProperty(exports, "__esModule", { value: true });
+ function assert(condition, message) {
+ /* istanbul ignore if */
+ if (!condition) {
+ throw new Error('ASSERT: ' + message);
+ }
+ }
+ exports.assert = assert;
+
+
+/***/ },
+/* 10 */
+/***/ function(module, exports) {
+
+ "use strict";
+ /* tslint:disable:max-classes-per-file */
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var ErrorHandler = (function () {
+ function ErrorHandler() {
+ this.errors = [];
+ this.tolerant = false;
+ }
+ ErrorHandler.prototype.recordError = function (error) {
+ this.errors.push(error);
+ };
+ ErrorHandler.prototype.tolerate = function (error) {
+ if (this.tolerant) {
+ this.recordError(error);
+ }
+ else {
+ throw error;
+ }
+ };
+ ErrorHandler.prototype.constructError = function (msg, column) {
+ var error = new Error(msg);
+ try {
+ throw error;
+ }
+ catch (base) {
+ /* istanbul ignore else */
+ if (Object.create && Object.defineProperty) {
+ error = Object.create(base);
+ Object.defineProperty(error, 'column', { value: column });
+ }
+ }
+ /* istanbul ignore next */
+ return error;
+ };
+ ErrorHandler.prototype.createError = function (index, line, col, description) {
+ var msg = 'Line ' + line + ': ' + description;
+ var error = this.constructError(msg, col);
+ error.index = index;
+ error.lineNumber = line;
+ error.description = description;
+ return error;
+ };
+ ErrorHandler.prototype.throwError = function (index, line, col, description) {
+ throw this.createError(index, line, col, description);
+ };
+ ErrorHandler.prototype.tolerateError = function (index, line, col, description) {
+ var error = this.createError(index, line, col, description);
+ if (this.tolerant) {
+ this.recordError(error);
+ }
+ else {
+ throw error;
+ }
+ };
+ return ErrorHandler;
+ }());
+ exports.ErrorHandler = ErrorHandler;
+
+
+/***/ },
+/* 11 */
+/***/ function(module, exports) {
+
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ // Error messages should be identical to V8.
+ exports.Messages = {
+ BadGetterArity: 'Getter must not have any formal parameters',
+ BadSetterArity: 'Setter must have exactly one formal parameter',
+ BadSetterRestParameter: 'Setter function argument must not be a rest parameter',
+ ConstructorIsAsync: 'Class constructor may not be an async method',
+ ConstructorSpecialMethod: 'Class constructor may not be an accessor',
+ DeclarationMissingInitializer: 'Missing initializer in %0 declaration',
+ DefaultRestParameter: 'Unexpected token =',
+ DuplicateBinding: 'Duplicate binding %0',
+ DuplicateConstructor: 'A class may only have one constructor',
+ DuplicateProtoProperty: 'Duplicate __proto__ fields are not allowed in object literals',
+ ForInOfLoopInitializer: '%0 loop variable declaration may not have an initializer',
+ GeneratorInLegacyContext: 'Generator declarations are not allowed in legacy contexts',
+ IllegalBreak: 'Illegal break statement',
+ IllegalContinue: 'Illegal continue statement',
+ IllegalExportDeclaration: 'Unexpected token',
+ IllegalImportDeclaration: 'Unexpected token',
+ IllegalLanguageModeDirective: 'Illegal \'use strict\' directive in function with non-simple parameter list',
+ IllegalReturn: 'Illegal return statement',
+ InvalidEscapedReservedWord: 'Keyword must not contain escaped characters',
+ InvalidHexEscapeSequence: 'Invalid hexadecimal escape sequence',
+ InvalidLHSInAssignment: 'Invalid left-hand side in assignment',
+ InvalidLHSInForIn: 'Invalid left-hand side in for-in',
+ InvalidLHSInForLoop: 'Invalid left-hand side in for-loop',
+ InvalidModuleSpecifier: 'Unexpected token',
+ InvalidRegExp: 'Invalid regular expression',
+ LetInLexicalBinding: 'let is disallowed as a lexically bound name',
+ MissingFromClause: 'Unexpected token',
+ MultipleDefaultsInSwitch: 'More than one default clause in switch statement',
+ NewlineAfterThrow: 'Illegal newline after throw',
+ NoAsAfterImportNamespace: 'Unexpected token',
+ NoCatchOrFinally: 'Missing catch or finally after try',
+ ParameterAfterRestParameter: 'Rest parameter must be last formal parameter',
+ Redeclaration: '%0 \'%1\' has already been declared',
+ StaticPrototype: 'Classes may not have static property named prototype',
+ StrictCatchVariable: 'Catch variable may not be eval or arguments in strict mode',
+ StrictDelete: 'Delete of an unqualified identifier in strict mode.',
+ StrictFunction: 'In strict mode code, functions can only be declared at top level or inside a block',
+ StrictFunctionName: 'Function name may not be eval or arguments in strict mode',
+ 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',
+ StrictModeWith: 'Strict mode code may not include a with statement',
+ StrictOctalLiteral: 'Octal literals are not allowed in strict mode.',
+ StrictParamDupe: 'Strict mode function may not have duplicate parameter names',
+ StrictParamName: 'Parameter name eval or arguments is not allowed in strict mode',
+ StrictReservedWord: 'Use of future reserved word in strict mode',
+ StrictVarName: 'Variable name may not be eval or arguments in strict mode',
+ TemplateOctalLiteral: 'Octal literals are not allowed in template strings.',
+ UnexpectedEOS: 'Unexpected end of input',
+ UnexpectedIdentifier: 'Unexpected identifier',
+ UnexpectedNumber: 'Unexpected number',
+ UnexpectedReserved: 'Unexpected reserved word',
+ UnexpectedString: 'Unexpected string',
+ UnexpectedTemplate: 'Unexpected quasi %0',
+ UnexpectedToken: 'Unexpected token %0',
+ UnexpectedTokenIllegal: 'Unexpected token ILLEGAL',
+ UnknownLabel: 'Undefined label \'%0\'',
+ UnterminatedRegExp: 'Invalid regular expression: missing /'
+ };
+
+
+/***/ },
+/* 12 */
+/***/ function(module, exports, __webpack_require__) {
+
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var assert_1 = __webpack_require__(9);
+ var character_1 = __webpack_require__(4);
+ var messages_1 = __webpack_require__(11);
+ function hexValue(ch) {
+ return '0123456789abcdef'.indexOf(ch.toLowerCase());
+ }
+ function octalValue(ch) {
+ return '01234567'.indexOf(ch);
+ }
+ var Scanner = (function () {
+ function Scanner(code, handler) {
+ this.source = code;
+ this.errorHandler = handler;
+ this.trackComment = false;
+ this.isModule = false;
+ this.length = code.length;
+ this.index = 0;
+ this.lineNumber = (code.length > 0) ? 1 : 0;
+ this.lineStart = 0;
+ this.curlyStack = [];
+ }
+ Scanner.prototype.saveState = function () {
+ return {
+ index: this.index,
+ lineNumber: this.lineNumber,
+ lineStart: this.lineStart
+ };
+ };
+ Scanner.prototype.restoreState = function (state) {
+ this.index = state.index;
+ this.lineNumber = state.lineNumber;
+ this.lineStart = state.lineStart;
+ };
+ Scanner.prototype.eof = function () {
+ return this.index >= this.length;
+ };
+ Scanner.prototype.throwUnexpectedToken = function (message) {
+ if (message === void 0) { message = messages_1.Messages.UnexpectedTokenIllegal; }
+ return this.errorHandler.throwError(this.index, this.lineNumber, this.index - this.lineStart + 1, message);
+ };
+ Scanner.prototype.tolerateUnexpectedToken = function (message) {
+ if (message === void 0) { message = messages_1.Messages.UnexpectedTokenIllegal; }
+ this.errorHandler.tolerateError(this.index, this.lineNumber, this.index - this.lineStart + 1, message);
+ };
+ // https://tc39.github.io/ecma262/#sec-comments
+ Scanner.prototype.skipSingleLineComment = function (offset) {
+ var comments = [];
+ var start, loc;
+ if (this.trackComment) {
+ comments = [];
+ start = this.index - offset;
+ loc = {
+ start: {
+ line: this.lineNumber,
+ column: this.index - this.lineStart - offset
+ },
+ end: {}
+ };
+ }
+ while (!this.eof()) {
+ var ch = this.source.charCodeAt(this.index);
+ ++this.index;
+ if (character_1.Character.isLineTerminator(ch)) {
+ if (this.trackComment) {
+ loc.end = {
+ line: this.lineNumber,
+ column: this.index - this.lineStart - 1
+ };
+ var entry = {
+ multiLine: false,
+ slice: [start + offset, this.index - 1],
+ range: [start, this.index - 1],
+ loc: loc
+ };
+ comments.push(entry);
+ }
+ if (ch === 13 && this.source.charCodeAt(this.index) === 10) {
+ ++this.index;
+ }
+ ++this.lineNumber;
+ this.lineStart = this.index;
+ return comments;
+ }
+ }
+ if (this.trackComment) {
+ loc.end = {
+ line: this.lineNumber,
+ column: this.index - this.lineStart
+ };
+ var entry = {
+ multiLine: false,
+ slice: [start + offset, this.index],
+ range: [start, this.index],
+ loc: loc
+ };
+ comments.push(entry);
+ }
+ return comments;
+ };
+ Scanner.prototype.skipMultiLineComment = function () {
+ var comments = [];
+ var start, loc;
+ if (this.trackComment) {
+ comments = [];
+ start = this.index - 2;
+ loc = {
+ start: {
+ line: this.lineNumber,
+ column: this.index - this.lineStart - 2
+ },
+ end: {}
+ };
+ }
+ while (!this.eof()) {
+ var ch = this.source.charCodeAt(this.index);
+ if (character_1.Character.isLineTerminator(ch)) {
+ if (ch === 0x0D && this.source.charCodeAt(this.index + 1) === 0x0A) {
+ ++this.index;
+ }
+ ++this.lineNumber;
+ ++this.index;
+ this.lineStart = this.index;
+ }
+ else if (ch === 0x2A) {
+ // Block comment ends with '*/'.
+ if (this.source.charCodeAt(this.index + 1) === 0x2F) {
+ this.index += 2;
+ if (this.trackComment) {
+ loc.end = {
+ line: this.lineNumber,
+ column: this.index - this.lineStart
+ };
+ var entry = {
+ multiLine: true,
+ slice: [start + 2, this.index - 2],
+ range: [start, this.index],
+ loc: loc
+ };
+ comments.push(entry);
+ }
+ return comments;
+ }
+ ++this.index;
+ }
+ else {
+ ++this.index;
+ }
+ }
+ // Ran off the end of the file - the whole thing is a comment
+ if (this.trackComment) {
+ loc.end = {
+ line: this.lineNumber,
+ column: this.index - this.lineStart
+ };
+ var entry = {
+ multiLine: true,
+ slice: [start + 2, this.index],
+ range: [start, this.index],
+ loc: loc
+ };
+ comments.push(entry);
+ }
+ this.tolerateUnexpectedToken();
+ return comments;
+ };
+ Scanner.prototype.scanComments = function () {
+ var comments;
+ if (this.trackComment) {
+ comments = [];
+ }
+ var start = (this.index === 0);
+ while (!this.eof()) {
+ var ch = this.source.charCodeAt(this.index);
+ if (character_1.Character.isWhiteSpace(ch)) {
+ ++this.index;
+ }
+ else if (character_1.Character.isLineTerminator(ch)) {
+ ++this.index;
+ if (ch === 0x0D && this.source.charCodeAt(this.index) === 0x0A) {
+ ++this.index;
+ }
+ ++this.lineNumber;
+ this.lineStart = this.index;
+ start = true;
+ }
+ else if (ch === 0x2F) {
+ ch = this.source.charCodeAt(this.index + 1);
+ if (ch === 0x2F) {
+ this.index += 2;
+ var comment = this.skipSingleLineComment(2);
+ if (this.trackComment) {
+ comments = comments.concat(comment);
+ }
+ start = true;
+ }
+ else if (ch === 0x2A) {
+ this.index += 2;
+ var comment = this.skipMultiLineComment();
+ if (this.trackComment) {
+ comments = comments.concat(comment);
+ }
+ }
+ else {
+ break;
+ }
+ }
+ else if (start && ch === 0x2D) {
+ // U+003E is '>'
+ if ((this.source.charCodeAt(this.index + 1) === 0x2D) && (this.source.charCodeAt(this.index + 2) === 0x3E)) {
+ // '-->' is a single-line comment
+ this.index += 3;
+ var comment = this.skipSingleLineComment(3);
+ if (this.trackComment) {
+ comments = comments.concat(comment);
+ }
+ }
+ else {
+ break;
+ }
+ }
+ else if (ch === 0x3C && !this.isModule) {
+ if (this.source.slice(this.index + 1, this.index + 4) === '!--') {
+ this.index += 4; // `") && S.newline_before) {
+ forward(3);
+ skip_line_comment("comment4");
+ continue;
+ }
+ }
+ var ch = peek();
+ if (!ch) return token("eof");
+ var code = ch.charCodeAt(0);
+ switch (code) {
+ case 34: case 39: return read_string(ch);
+ case 46: return handle_dot();
+ case 47: {
+ var tok = handle_slash();
+ if (tok === next_token) continue;
+ return tok;
+ }
+ }
+ 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();
+ break;
+ }
+ parse_error("Unexpected character '" + ch + "'");
+ };
- expectKeyword('with');
-
- expect('(');
-
- object = parseExpression();
-
- expect(')');
+ next_token.context = function(nc) {
+ if (nc) S = nc;
+ return S;
+ };
- body = parseStatement();
+ next_token.add_directive = function(directive) {
+ S.directive_stack[S.directive_stack.length - 1].push(directive);
- return {
- type: Syntax.WithStatement,
- object: object,
- body: body
- };
+ if (S.directives[directive] === undefined) {
+ S.directives[directive] = 1;
+ } else {
+ S.directives[directive]++;
+ }
}
- // 12.10 The swith statement
-
- function parseSwitchCase() {
- var test,
- consequent = [],
- statement;
+ next_token.push_directives_stack = function() {
+ S.directive_stack.push([]);
+ }
- if (matchKeyword('default')) {
- lex();
- test = null;
- } else {
- expectKeyword('case');
- test = parseExpression();
- }
- expect(':');
+ next_token.pop_directives_stack = function() {
+ var directives = S.directive_stack[S.directive_stack.length - 1];
- while (index < length) {
- if (match('}') || matchKeyword('default') || matchKeyword('case')) {
- break;
- }
- statement = parseStatement();
- if (typeof statement === 'undefined') {
- break;
- }
- consequent.push(statement);
+ for (var i = 0; i < directives.length; i++) {
+ S.directives[directives[i]]--;
}
- return {
- type: Syntax.SwitchCase,
- test: test,
- consequent: consequent
- };
+ S.directive_stack.pop();
}
- function parseSwitchStatement() {
- var discriminant, cases, clause, oldInSwitch, defaultFound;
-
- expectKeyword('switch');
-
- expect('(');
+ next_token.has_directive = function(directive) {
+ return S.directives[directive] !== undefined &&
+ S.directives[directive] > 0;
+ }
- discriminant = parseExpression();
+ return next_token;
- expect(')');
+};
- expect('{');
+/* -----[ Parser (constants) ]----- */
- cases = [];
+var UNARY_PREFIX = makePredicate([
+ "typeof",
+ "void",
+ "delete",
+ "--",
+ "++",
+ "!",
+ "~",
+ "-",
+ "+"
+]);
- if (match('}')) {
- lex();
- return {
- type: Syntax.SwitchStatement,
- discriminant: discriminant,
- cases: cases
- };
- }
+var UNARY_POSTFIX = makePredicate([ "--", "++" ]);
- oldInSwitch = state.inSwitch;
- state.inSwitch = true;
- defaultFound = false;
+var ASSIGNMENT = makePredicate([ "=", "+=", "-=", "/=", "*=", "%=", ">>=", "<<=", ">>>=", "|=", "^=", "&=" ]);
- while (index < length) {
- if (match('}')) {
- break;
- }
- clause = parseSwitchCase();
- if (clause.test === null) {
- if (defaultFound) {
- throwError({}, Messages.MultipleDefaultsInSwitch);
- }
- defaultFound = true;
- }
- cases.push(clause);
+var PRECEDENCE = (function(a, ret){
+ for (var i = 0; i < a.length; ++i) {
+ var b = a[i];
+ for (var j = 0; j < b.length; ++j) {
+ ret[b[j]] = i + 1;
}
-
- state.inSwitch = oldInSwitch;
-
- expect('}');
-
- return {
- type: Syntax.SwitchStatement,
- discriminant: discriminant,
- cases: cases
- };
}
+ return ret;
+})(
+ [
+ ["||"],
+ ["&&"],
+ ["|"],
+ ["^"],
+ ["&"],
+ ["==", "===", "!=", "!=="],
+ ["<", ">", "<=", ">=", "in", "instanceof"],
+ [">>", "<<", ">>>"],
+ ["+", "-"],
+ ["*", "/", "%"]
+ ],
+ {}
+);
- // 12.13 The throw statement
-
- function parseThrowStatement() {
- var argument;
-
- expectKeyword('throw');
+var STATEMENTS_WITH_LABELS = array_to_hash([ "for", "do", "while", "switch" ]);
- if (peekLineTerminator()) {
- throwError({}, Messages.NewlineAfterThrow);
- }
+var ATOMIC_START_TOKEN = array_to_hash([ "atom", "num", "string", "regexp", "name" ]);
- argument = parseExpression();
+/* -----[ Parser ]----- */
- consumeSemicolon();
+function parse($TEXT, options) {
- return {
- type: Syntax.ThrowStatement,
- argument: argument
- };
- }
+ options = defaults(options, {
+ bare_returns : false,
+ cli : false,
+ expression : false,
+ filename : null,
+ html5_comments : true,
+ shebang : true,
+ strict : false,
+ toplevel : null,
+ });
- // 12.14 The try statement
+ var S = {
+ input : (typeof $TEXT == "string"
+ ? tokenizer($TEXT, options.filename,
+ options.html5_comments, options.shebang)
+ : $TEXT),
+ token : null,
+ prev : null,
+ peeked : null,
+ in_function : 0,
+ in_directives : true,
+ in_loop : 0,
+ labels : []
+ };
- function parseCatchClause() {
- var param;
+ S.token = next();
- expectKeyword('catch');
+ function is(type, value) {
+ return is_token(S.token, type, value);
+ };
- expect('(');
- if (match(')')) {
- throwUnexpected(lookahead());
- }
+ function peek() { return S.peeked || (S.peeked = S.input()); };
- param = parseVariableIdentifier();
- // 12.14.1
- if (strict && isRestrictedWord(param.name)) {
- throwErrorTolerant({}, Messages.StrictCatchVariable);
+ 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;
+ };
- expect(')');
-
- return {
- type: Syntax.CatchClause,
- param: param,
- body: parseBlock()
- };
- }
+ function prev() {
+ return S.prev;
+ };
- function parseTryStatement() {
- var block, handlers = [], finalizer = null;
+ 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);
+ };
- expectKeyword('try');
+ function token_error(token, msg) {
+ croak(msg, token.line, token.col);
+ };
- block = parseBlock();
+ function unexpected(token) {
+ if (token == null)
+ token = S.token;
+ token_error(token, "Unexpected token: " + token.type + " (" + token.value + ")");
+ };
- if (matchKeyword('catch')) {
- handlers.push(parseCatchClause());
+ 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 + "»");
+ };
- if (matchKeyword('finally')) {
- lex();
- finalizer = parseBlock();
- }
+ function expect(punc) { return expect_token("punc", punc); };
- if (handlers.length === 0 && !finalizer) {
- throwError({}, Messages.NoCatchOrFinally);
- }
+ function can_insert_semicolon() {
+ return !options.strict && (
+ S.token.nlb || is("eof") || is("punc", "}")
+ );
+ };
- return {
- type: Syntax.TryStatement,
- block: block,
- guardedHandlers: [],
- handlers: handlers,
- finalizer: finalizer
- };
- }
-
- // 12.15 The debugger statement
-
- function parseDebuggerStatement() {
- expectKeyword('debugger');
+ function semicolon(optional) {
+ if (is("punc", ";")) next();
+ else if (!optional && !can_insert_semicolon()) unexpected();
+ };
- consumeSemicolon();
+ function parenthesised() {
+ expect("(");
+ var exp = expression(true);
+ expect(")");
+ return exp;
+ };
- return {
- type: Syntax.DebuggerStatement
+ function embed_tokens(parser) {
+ return function() {
+ var start = S.token;
+ var expr = parser();
+ var end = prev();
+ expr.start = start;
+ expr.end = end;
+ return expr;
};
- }
-
- // 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;
- }
+ function handle_regexp() {
+ if (is("operator", "/") || is("operator", "/=")) {
+ S.peeked = null;
+ S.token = S.input(S.token.value.substr(1)); // force regexp
}
+ };
- 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;
+ var statement = embed_tokens(function() {
+ handle_regexp();
+ switch (S.token.type) {
+ case "string":
+ if (S.in_directives) {
+ var token = peek();
+ if (S.token.raw.indexOf("\\") == -1
+ && (token.nlb
+ || is_token(token, "eof")
+ || is_token(token, "punc", ";")
+ || is_token(token, "punc", "}"))) {
+ S.input.add_directive(S.token.value);
+ } else {
+ S.in_directives = false;
+ }
}
- }
-
- expr = parseExpression();
+ var dir = S.in_directives, stat = simple_statement();
+ return dir ? new AST_Directive(stat.body) : stat;
+ case "num":
+ case "regexp":
+ case "operator":
+ case "atom":
+ return simple_statement();
- // 12.12 Labelled Statements
- if ((expr.type === Syntax.Identifier) && match(':')) {
- lex();
+ case "name":
+ return is_token(peek(), "punc", ":")
+ ? labeled_statement()
+ : simple_statement();
- if (Object.prototype.hasOwnProperty.call(state.labelSet, expr.name)) {
- throwError({}, Messages.Redeclaration, 'Label', expr.name);
+ case "punc":
+ switch (S.token.value) {
+ case "{":
+ return new AST_BlockStatement({
+ start : S.token,
+ body : block_(),
+ end : prev()
+ });
+ case "[":
+ case "(":
+ return simple_statement();
+ case ";":
+ S.in_directives = false;
+ next();
+ return new AST_EmptyStatement();
+ default:
+ unexpected();
}
- state.labelSet[expr.name] = true;
- labeledBody = parseStatement();
- delete state.labelSet[expr.name];
+ case "keyword":
+ switch (S.token.value) {
+ case "break":
+ next();
+ return break_cont(AST_Break);
- return {
- type: Syntax.LabeledStatement,
- label: expr,
- body: labeledBody
- };
- }
+ case "continue":
+ next();
+ return break_cont(AST_Continue);
- consumeSemicolon();
+ case "debugger":
+ next();
+ semicolon();
+ return new AST_Debugger();
- return {
- type: Syntax.ExpressionStatement,
- expression: expr
- };
- }
+ case "do":
+ next();
+ var body = in_loop(statement);
+ expect_token("keyword", "while");
+ var condition = parenthesised();
+ semicolon(true);
+ return new AST_Do({
+ body : body,
+ condition : condition
+ });
- // 13 Function Definition
+ case "while":
+ next();
+ return new AST_While({
+ condition : parenthesised(),
+ body : in_loop(statement)
+ });
- function parseFunctionSourceElements() {
- var sourceElement, sourceElements = [], token, directive, firstRestricted,
- oldLabelSet, oldInIteration, oldInSwitch, oldInFunctionBody;
+ case "for":
+ next();
+ return for_();
- expect('{');
+ case "function":
+ next();
+ return function_(AST_Defun);
- while (index < length) {
- token = lookahead();
- if (token.type !== Token.StringLiteral) {
- break;
- }
+ case "if":
+ next();
+ return if_();
- 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;
+ case "return":
+ if (S.in_function == 0 && !options.bare_returns)
+ croak("'return' outside of function");
+ next();
+ var value = null;
+ if (is("punc", ";")) {
+ next();
+ } else if (!can_insert_semicolon()) {
+ value = expression(true);
+ semicolon();
}
- }
- }
-
- oldLabelSet = state.labelSet;
- oldInIteration = state.inIteration;
- oldInSwitch = state.inSwitch;
- oldInFunctionBody = state.inFunctionBody;
-
- state.labelSet = {};
- state.inIteration = false;
- state.inSwitch = false;
- state.inFunctionBody = true;
+ return new AST_Return({
+ value: value
+ });
- while (index < length) {
- if (match('}')) {
- break;
- }
- sourceElement = parseSourceElement();
- if (typeof sourceElement === 'undefined') {
- break;
- }
- sourceElements.push(sourceElement);
- }
+ case "switch":
+ next();
+ return new AST_Switch({
+ expression : parenthesised(),
+ body : in_loop(switch_body_)
+ });
- expect('}');
+ case "throw":
+ next();
+ if (S.token.nlb)
+ croak("Illegal newline after 'throw'");
+ var value = expression(true);
+ semicolon();
+ return new AST_Throw({
+ value: value
+ });
- state.labelSet = oldLabelSet;
- state.inIteration = oldInIteration;
- state.inSwitch = oldInSwitch;
- state.inFunctionBody = oldInFunctionBody;
+ case "try":
+ next();
+ return try_();
- return {
- type: Syntax.BlockStatement,
- body: sourceElements
- };
- }
+ case "var":
+ next();
+ var node = var_();
+ semicolon();
+ return node;
- function parseFunctionDeclaration() {
- var id, param, params = [], body, token, stricted, firstRestricted, message, previousStrict, paramSet;
+ case "const":
+ next();
+ var node = const_();
+ semicolon();
+ return node;
- 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;
+ case "with":
+ if (S.input.has_directive("use strict")) {
+ croak("Strict mode may not include a with statement");
}
- expect(',');
+ next();
+ return new AST_With({
+ expression : parenthesised(),
+ body : statement()
+ });
}
}
+ unexpected();
+ });
- 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;
- }
- }
+ function labeled_statement() {
+ var label = as_symbol(AST_Label);
+ if (find_if(function(l){ return l.name == label.name }, S.labels)) {
+ // ECMA-262, 12.12: An ECMAScript program is considered
+ // syntactically incorrect if it contains a
+ // LabelledStatement that is enclosed by a
+ // LabelledStatement with the same Identifier as label.
+ croak("Label " + label.name + " defined twice");
}
-
- 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(":");
+ S.labels.push(label);
+ var stat = statement();
+ S.labels.pop();
+ if (!(stat instanceof AST_IterationStatement)) {
+ // check for `continue` that refers to this label.
+ // those should be reported as syntax errors.
+ // https://github.com/mishoo/UglifyJS2/issues/287
+ label.references.forEach(function(ref){
+ if (ref instanceof AST_Continue) {
+ ref = ref.label.start;
+ croak("Continue label `" + label.name + "` refers to non-IterationStatement.",
+ ref.line, ref.col, ref.pos);
}
- expect(',');
- }
+ });
}
+ return new AST_LabeledStatement({ body: stat, label: label });
+ };
- expect(')');
+ function simple_statement(tmp) {
+ return new AST_SimpleStatement({ body: (tmp = expression(true), semicolon(), tmp) });
+ };
- previousStrict = strict;
- body = parseFunctionSourceElements();
- if (strict && firstRestricted) {
- throwError(firstRestricted, message);
+ function break_cont(type) {
+ var label = null, ldef;
+ if (!can_insert_semicolon()) {
+ label = as_symbol(AST_LabelRef, true);
}
- if (strict && stricted) {
- throwErrorTolerant(stricted, message);
+ if (label != null) {
+ ldef = find_if(function(l){ return l.name == label.name }, S.labels);
+ if (!ldef)
+ croak("Undefined label " + label.name);
+ label.thedef = ldef;
}
- 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();
+ else if (S.in_loop == 0)
+ croak(type.TYPE + " not inside a loop or switch");
+ semicolon();
+ var stat = new type({ label: label });
+ if (ldef) ldef.references.push(stat);
+ return stat;
+ };
- if (token.type === Token.Keyword) {
- switch (token.value) {
- case 'const':
- case 'let':
- return parseConstLetDeclaration(token.value);
- case 'function':
- return parseFunctionDeclaration();
- default:
- return parseStatement();
+ 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);
+ };
- if (token.type !== Token.EOF) {
- return parseStatement();
- }
- }
-
- function parseSourceElements() {
- var sourceElement, sourceElements = [], token, directive, firstRestricted;
+ 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)
+ });
+ };
- while (index < length) {
- token = lookahead();
- if (token.type !== Token.StringLiteral) {
- break;
- }
+ 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)
+ });
+ };
- 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;
+ var function_ = function(ctor) {
+ var in_statement = ctor === AST_Defun;
+ var name = is("name") ? as_symbol(in_statement ? AST_SymbolDefun : AST_SymbolLambda) : null;
+ if (in_statement && !name)
+ unexpected();
+ expect("(");
+ return new ctor({
+ name: name,
+ argnames: (function(first, a){
+ while (!is("punc", ")")) {
+ if (first) first = false; else expect(",");
+ a.push(as_symbol(AST_SymbolFunarg));
}
- }
- }
-
- 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');
+ next();
+ return a;
+ })(true, []),
+ body: (function(loop, labels){
+ ++S.in_function;
+ S.in_directives = true;
+ S.input.push_directives_stack();
+ S.in_loop = 0;
+ S.labels = [];
+ var a = block_();
+ S.input.pop_directives_stack();
+ --S.in_function;
+ S.in_loop = loop;
+ S.labels = labels;
+ return a;
+ })(S.in_loop, S.labels)
+ });
+ };
- // 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;
- }
+ function if_() {
+ var cond = parenthesised(), body = statement(), belse = null;
+ if (is("keyword", "else")) {
+ next();
+ belse = statement();
}
-
- extra.comments.push({
- type: type,
- value: value,
- range: [start, end],
- loc: loc
+ return new AST_If({
+ condition : cond,
+ body : body,
+ alternative : belse
});
- }
-
- 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 block_() {
+ expect("{");
+ var a = [];
+ while (!is("punc", "}")) {
+ if (is("eof")) unexpected();
+ a.push(statement());
}
- }
-
- function filterCommentLocation() {
- var i, entry, comment, comments = [];
+ next();
+ return a;
+ };
- 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;
+ 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(":");
}
- if (extra.loc) {
- comment.loc = entry.loc;
+ 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);
}
- comments.push(comment);
- }
-
- extra.comments = comments;
- }
-
- function collectToken() {
- var start, loc, token, range, value;
-
- skipComment();
- start = index;
- loc = {
- start: {
- line: lineNumber,
- column: index - lineStart
+ else {
+ if (!cur) unexpected();
+ cur.push(statement());
}
- };
-
- token = extra.advance();
- loc.end = {
- line: lineNumber,
- column: index - lineStart
- };
+ }
+ if (branch) branch.end = prev();
+ next();
+ return a;
+ };
- 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
+ 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()
});
}
-
- 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();
- }
- }
+ if (is("keyword", "finally")) {
+ var start = S.token;
+ next();
+ bfinally = new AST_Finally({
+ start : start,
+ body : block_(),
+ end : prev()
+ });
}
-
- extra.tokens.push({
- type: 'RegularExpression',
- value: regex.literal,
- range: [pos, index],
- loc: loc
+ if (!bcatch && !bfinally)
+ croak("Missing catch/finally blocks");
+ return new AST_Try({
+ body : body,
+ bcatch : bcatch,
+ bfinally : bfinally
});
+ };
- 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);
+ 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;
+ };
- 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])
- };
- }
+ var var_ = function(no_in) {
+ return new AST_Var({
+ start : prev(),
+ definitions : vardefs(no_in, false),
+ end : prev()
+ });
+ };
- function createLocationMarker() {
- var marker = {};
+ var const_ = function() {
+ return new AST_Const({
+ start : prev(),
+ definitions : vardefs(false, true),
+ end : prev()
+ });
+ };
- 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
- }
- };
- }
- };
+ var new_ = function(allow_calls) {
+ 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()
+ }), allow_calls);
+ };
- 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
- }
- };
+ function as_atom_node() {
+ var tok = S.token, ret;
+ switch (tok.type) {
+ case "name":
+ case "keyword":
+ ret = _make_symbol(AST_SymbolRef);
+ break;
+ 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,
+ quote : tok.quote
+ });
+ 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;
}
- };
-
- 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);
+ break;
+ case "operator":
+ if (!is_identifier_string(tok.value)) {
+ croak("Invalid getter/setter name: " + tok.value,
+ tok.line, tok.col, tok.pos);
}
+ ret = _make_symbol(AST_SymbolRef);
+ break;
}
+ next();
+ return ret;
+ };
- 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);
- }
+ var expr_atom = function(allow_calls) {
+ if (is("operator", "new")) {
+ return new_(allow_calls);
}
-
- 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);
- }
+ 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();
}
- return n;
- }
-
- function wrapTrackingFunction(range, loc) {
-
- return function (parseFunction) {
+ if (is("keyword", "function")) {
+ next();
+ var func = function_(AST_Function);
+ 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 isBinary(node) {
- return node.type === Syntax.LogicalExpression ||
- node.type === Syntax.BinaryExpression;
+ 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;
+ };
- function visit(node) {
- var start, end;
+ var array_ = embed_tokens(function() {
+ expect("[");
+ return new AST_Array({
+ elements: expr_list("]", !options.strict, true)
+ });
+ });
- if (isBinary(node.left)) {
- visit(node.left);
- }
- if (isBinary(node.right)) {
- visit(node.right);
- }
+ var create_accessor = embed_tokens(function() {
+ return function_(AST_Accessor);
+ });
- 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];
- }
+ var object_ = embed_tokens(function() {
+ expect("{");
+ var first = true, a = [];
+ while (!is("punc", "}")) {
+ if (first) first = false; else expect(",");
+ if (!options.strict && is("punc", "}"))
+ // allow trailing comma
+ break;
+ var start = S.token;
+ var type = start.type;
+ var name = as_property_name();
+ if (type == "name" && !is("punc", ":")) {
+ var key = new AST_SymbolAccessor({
+ start: S.token,
+ name: as_property_name(),
+ end: prev()
+ });
+ if (name == "get") {
+ a.push(new AST_ObjectGetter({
+ start : start,
+ key : key,
+ value : create_accessor(),
+ end : prev()
+ }));
+ continue;
}
- 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
- };
- }
+ if (name == "set") {
+ a.push(new AST_ObjectSetter({
+ start : start,
+ key : key,
+ value : create_accessor(),
+ end : prev()
+ }));
+ continue;
}
}
-
- 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;
+ expect(":");
+ a.push(new AST_ObjectKeyVal({
+ start : start,
+ quote : start.quote,
+ key : name,
+ value : expression(false),
+ end : prev()
+ }));
}
- }
+ next();
+ return new AST_Object({ properties: a });
+ });
- 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 as_property_name() {
+ var tmp = S.token;
+ switch (tmp.type) {
+ case "operator":
+ if (!KEYWORDS(tmp.value)) unexpected();
+ case "num":
+ case "string":
+ case "name":
+ case "keyword":
+ case "atom":
+ next();
+ return tmp.value;
+ default:
+ unexpected();
}
- }
+ };
- function stringToArray(str) {
- var length = str.length,
- result = [],
- i;
- for (i = 0; i < length; ++i) {
- result[i] = str.charAt(i);
- }
- return result;
- }
+ function as_name() {
+ var tmp = S.token;
+ if (tmp.type != "name") unexpected();
+ next();
+ return tmp.value;
+ };
- 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
- };
+ function _make_symbol(type) {
+ var name = S.token.value;
+ return new (name == "this" ? AST_This : type)({
+ name : String(name),
+ start : S.token,
+ end : S.token
+ });
+ };
- 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 = [];
- }
+ function as_symbol(type, noerror) {
+ if (!is("name")) {
+ if (!noerror) croak("Name expected");
+ return null;
}
+ var sym = _make_symbol(type);
+ next();
+ return sym;
+ };
- 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 = {};
+ 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;
+ };
- return program;
- }
+ var maybe_unary = function(allow_calls) {
+ var start = S.token;
+ if (is("operator") && UNARY_PREFIX(start.value)) {
+ next();
+ handle_regexp();
+ var ex = make_unary(AST_UnaryPrefix, start, 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, val);
+ val.start = start;
+ val.end = S.token;
+ next();
+ }
+ return val;
+ };
- // Sync with package.json.
- exports.version = '1.0.4';
+ function make_unary(ctor, token, expr) {
+ var op = token.value;
+ if ((op == "++" || op == "--") && !is_assignable(expr))
+ croak("Invalid use of " + op + " operator", token.line, token.col, token.pos);
+ return new ctor({ operator: op, expression: expr });
+ };
- exports.parse = parse;
+ 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;
+ };
- // Deep copy.
- exports.Syntax = (function () {
- var name, types = {};
+ function expr_ops(no_in) {
+ return expr_op(maybe_unary(true), 0, no_in);
+ };
- if (typeof Object.create === 'function') {
- types = Object.create(null);
+ 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 : prev()
+ });
}
+ return expr;
+ };
- for (name in Syntax) {
- if (Syntax.hasOwnProperty(name)) {
- types[name] = Syntax[name];
+ function is_assignable(expr) {
+ if (options.cli) return true;
+ return expr instanceof AST_PropAccess || expr instanceof AST_SymbolRef;
+ };
+
+ 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;
+ };
- if (typeof Object.freeze === 'function') {
- Object.freeze(types);
+ 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;
+ };
- return types;
- }());
-
-}));
-/* vim: set sw=4 ts=4 et tw=80 : */
-/**
- * @license Copyright (c) 2012-2014, 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 */
+ function in_loop(cont) {
+ ++S.in_loop;
+ var ret = cont();
+ --S.in_loop;
+ return ret;
+ };
-/*
- * 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;
+ if (options.expression) {
+ return expression(true);
}
-});
-define('uglifyjs/consolidator', ["require", "exports", "module", "./parse-js", "./process"], function(require, exports, module) {
-/**
- * @preserve Copyright 2012 Robert Gust-Bardon .
- * 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 UglifyJS with consolidation of null, Boolean, and String values.
- * Also known as aliasing, this feature has been deprecated in the Closure Compiler since its
- * initial release, where it is unavailable from the CLI. 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.
- * Consolidating literals may worsen the data compression ratio when an encoding
- * transformation is applied. For instance, jQuery 1.7.1 takes 248235 bytes.
- * Building it with
- * UglifyJS v1.2.5 results in 93647 bytes (37.73% of the original) which are
- * then compressed to 33154 bytes (13.36% of the original) using gzip(1). 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).
- * Written in the strict variant
- * of ECMA-262 5.1 Edition. Encoded in UTF-8. Follows Revision 2.28 of the Google JavaScript Style Guide (except for the
- * discouraged use of the {@code function} tag and the {@code namespace} tag).
- * 100% typed for the Closure Compiler Version 1741.
- * Should you find this software useful, please consider a donation.
- * @author follow.me@RGustBardon (Robert Gust-Bardon)
- * @supported Tested with:
- *
- */
+ return (function(){
+ var start = S.token;
+ var body = [];
+ S.input.push_directives_stack();
+ while (!is("eof"))
+ body.push(statement());
+ S.input.pop_directives_stack();
+ 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;
+ })();
-/*global console:false, exports:true, module:false, require:false */
-/*jshint sub:true */
-/**
- * Consolidates null, Boolean, and String values found inside an AST.
- * @param {!TSyntacticCodeUnit} oAbstractSyntaxTree An array-like object
- * representing an AST.
- * @return {!TSyntacticCodeUnit} An array-like object representing an AST 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.>}
- */
- 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.}
- */
- this.aIdentifiers = [];
- /**
- * Prefixed representation Strings of each primitive value that could be
- * consolidated within the elements.
- * @type {!Array.}
- */
- 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.}
- * @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 ASTs 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.}
- */
- oWeights = {
- /**
- * The difference in the number of punctuators required by the bracket
- * notation and the dot notation.
- * '[]'.length - '.'.length
- * @const
- * @type {number}
- */
- N_PROPERTY_ACCESSOR: 1,
- /**
- * The number of punctuators required by a variable declaration with an
- * initialiser.
- * ':'.length + ';'.length
- * @const
- * @type {number}
- */
- N_VARIABLE_DECLARATION: 2,
- /**
- * The number of terminal symbols required to introduce a variable
- * statement (excluding its variable declaration list).
- * 'var '.length
- * @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.
- * '(function(){}());'.length
- * @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 ECMA-262.
- * @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 {@code with} statement.
- * @type {number}
- */
- N_WITH: 0,
- /**
- * Identifies a source element that includes the {@code eval} 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.}
- */
- 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 AST.
- * @type {!TWalker}
- */
- oWalker,
- /**
- * An object encompassing collections of functions used during the
- * traversal of an AST.
- * @namespace
- * @type {!Object.>}
- */
- oWalkers = {
- /**
- * A collection of functions used during the surveyance of source
- * elements.
- * @namespace
- * @type {!Object.}
- */
- 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.} 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 AST 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.} 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.} 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.}
- */
- 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 AST 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 AST 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.}
- */
- aSourceElementsData = [],
- /**
- * The index (in the source text order) of the source element
- * immediately following a Directive Prologue.
- * @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.}
- */
- 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.}
- */
- aVariableDeclarations = [],
- /**
- * Augments a list with a prefixed representation String.
- * @param {!Array.} 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}
- *
- * - -1
- * - if the first primitive value must be placed before
- * the other one,
- * - 0
- * - if the first primitive value may be placed before
- * the other one,
- * - 1
- * - if the first primitive value must not be placed
- * before the other one.
- *
- * @see TSolution.oPrimitiveValues
- */
- cSortPrimitiveValues = function(sPrefixed0, sPrefixed1) {
- /**
- * The difference between:
- *
- * - the difference in the number of terminal symbols
- * between the original source text and the one with the
- * first primitive value consolidated, and
- * - the difference in the number of terminal symbols
- * between the original source text and the one with the
- * second primitive value consolidated.
- *
- * @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.} */ 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.
+ https://github.com/mishoo/UglifyJS2
-------------------------------- (C) ---------------------------------
@@ -9667,8 +17282,7 @@ define('uglifyjs/parse-js', ["exports"], function(exports) {
Distributed under the BSD license:
- Copyright 2010 (c) Mihai Bazon
- Based on parse-js (http://marijn.haverbeke.nl/parse-js/).
+ Copyright 2012 (c) Mihai Bazon
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
@@ -9698,5332 +17312,2262 @@ define('uglifyjs/parse-js', ["exports"], function(exports) {
***********************************************************************/
-/* -----[ 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"
-]);
+"use strict";
-var KEYWORDS_ATOM = array_to_hash([
- "false",
- "null",
- "true",
- "undefined"
-]);
+// Tree transformer helpers.
-var OPERATOR_CHARS = array_to_hash(characters("+-*&%=<>!?|~^"));
+function TreeTransformer(before, after) {
+ TreeWalker.call(this);
+ this.before = before;
+ this.after = after;
+}
+TreeTransformer.prototype = new TreeWalker;
-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;
+(function(undefined){
-var OPERATORS = array_to_hash([
- "in",
- "instanceof",
- "typeof",
- "new",
- "void",
- "delete",
- "++",
- "--",
- "+",
- "-",
- "!",
- "~",
- "&",
- "|",
- "^",
- "*",
- "/",
- "%",
- ">>",
- "<<",
- ">>>",
- "<",
- ">",
- "<=",
- ">=",
- "==",
- "===",
- "!=",
- "!==",
- "?",
- "=",
- "+=",
- "-=",
- "/=",
- "*=",
- "%=",
- ">>=",
- "<<=",
- ">>>=",
- "|=",
- "^=",
- "&=",
- "&&",
- "||"
-]);
+ 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;
+ descend(x, tw);
+ y = tw.after(x, in_list);
+ if (y !== undefined) x = y;
+ }
+ }
+ tw.pop(this);
+ return x;
+ });
+ };
-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"));
+ function do_list(list, tw) {
+ return MAP(list, function(node){
+ return node.transform(tw, true);
+ });
+ };
-var PUNC_BEFORE_EXPRESSION = array_to_hash(characters("[{(,.;:"));
+ _(AST_Node, noop);
-var PUNC_CHARS = array_to_hash(characters("[]{}(),;:"));
+ _(AST_LabeledStatement, function(self, tw){
+ self.label = self.label.transform(tw);
+ self.body = self.body.transform(tw);
+ });
-var REGEXP_MODIFIERS = array_to_hash(characters("gmsiy"));
+ _(AST_SimpleStatement, function(self, tw){
+ self.body = self.body.transform(tw);
+ });
-/* -----[ Tokenizer ]----- */
+ _(AST_Block, function(self, tw){
+ self.body = do_list(self.body, tw);
+ });
-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]")
-};
+ _(AST_DWLoop, function(self, tw){
+ self.condition = self.condition.transform(tw);
+ self.body = self.body.transform(tw);
+ });
-function is_letter(ch) {
- return UNICODE.letter.test(ch);
-};
+ _(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);
+ });
-function is_digit(ch) {
- ch = ch.charCodeAt(0);
- return ch >= 48 && ch <= 57;
-};
+ _(AST_ForIn, function(self, tw){
+ self.init = self.init.transform(tw);
+ self.object = self.object.transform(tw);
+ self.body = self.body.transform(tw);
+ });
-function is_unicode_digit(ch) {
- return UNICODE.digit.test(ch);
-}
+ _(AST_With, function(self, tw){
+ self.expression = self.expression.transform(tw);
+ self.body = self.body.transform(tw);
+ });
-function is_alphanumeric_char(ch) {
- return is_digit(ch) || is_letter(ch);
-};
+ _(AST_Exit, function(self, tw){
+ if (self.value) self.value = self.value.transform(tw);
+ });
-function is_unicode_combining_mark(ch) {
- return UNICODE.combining_mark.test(ch);
-};
+ _(AST_LoopControl, function(self, tw){
+ if (self.label) self.label = self.label.transform(tw);
+ });
-function is_unicode_connector_punctuation(ch) {
- return UNICODE.connector_punctuation.test(ch);
-};
+ _(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);
+ });
-function is_identifier_start(ch) {
- return ch == "$" || ch == "_" || is_letter(ch);
-};
+ _(AST_Switch, function(self, tw){
+ self.expression = self.expression.transform(tw);
+ self.body = do_list(self.body, tw);
+ });
-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
- || ch == "\u200d" // zero-width joiner (in my ECMA-262 PDF, this is also 200c)
- ;
-};
+ _(AST_Case, function(self, tw){
+ self.expression = self.expression.transform(tw);
+ self.body = do_list(self.body, tw);
+ });
-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);
- }
-};
+ _(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);
+ });
-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;
-};
+ _(AST_Catch, function(self, tw){
+ self.argname = self.argname.transform(tw);
+ self.body = do_list(self.body, tw);
+ });
-JS_Parse_Error.prototype.toString = function() {
- return this.message + " (line: " + this.line + ", col: " + this.col + ", pos: " + this.pos + ")" + "\n\n" + this.stack;
-};
+ _(AST_Definitions, function(self, tw){
+ self.definitions = do_list(self.definitions, tw);
+ });
-function js_error(message, line, col, pos) {
- throw new JS_Parse_Error(message, line, col, pos);
-};
+ _(AST_VarDef, function(self, tw){
+ self.name = self.name.transform(tw);
+ if (self.value) self.value = self.value.transform(tw);
+ });
-function is_token(token, type, val) {
- return token.type == type && (val == null || token.value == val);
-};
+ _(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);
+ });
-var EX_EOF = {};
+ _(AST_Call, function(self, tw){
+ self.expression = self.expression.transform(tw);
+ self.args = do_list(self.args, tw);
+ });
-function tokenizer($TEXT) {
+ _(AST_Seq, function(self, tw){
+ self.car = self.car.transform(tw);
+ self.cdr = self.cdr.transform(tw);
+ });
- 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 : []
- };
+ _(AST_Dot, function(self, tw){
+ self.expression = self.expression.transform(tw);
+ });
- function peek() { return S.text.charAt(S.pos); };
+ _(AST_Sub, function(self, tw){
+ self.expression = self.expression.transform(tw);
+ self.property = self.property.transform(tw);
+ });
- 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;
- };
+ _(AST_Unary, function(self, tw){
+ self.expression = self.expression.transform(tw);
+ });
- function eof() {
- return !S.peek();
- };
+ _(AST_Binary, function(self, tw){
+ self.left = self.left.transform(tw);
+ self.right = self.right.transform(tw);
+ });
- function find(what, signal_eof) {
- var pos = S.text.indexOf(what, S.pos);
- if (signal_eof && pos == -1) throw EX_EOF;
- return pos;
- };
+ _(AST_Conditional, function(self, tw){
+ self.condition = self.condition.transform(tw);
+ self.consequent = self.consequent.transform(tw);
+ self.alternative = self.alternative.transform(tw);
+ });
- function start_token() {
- S.tokline = S.line;
- S.tokcol = S.col;
- S.tokpos = S.pos;
- };
+ _(AST_Array, function(self, tw){
+ self.elements = do_list(self.elements, tw);
+ });
- 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;
- };
+ _(AST_Object, function(self, tw){
+ self.properties = do_list(self.properties, tw);
+ });
- function skip_whitespace() {
- while (HOP(WHITESPACE_CHARS, peek()))
- next();
- };
+ _(AST_ObjectProperty, function(self, tw){
+ self.value = self.value.transform(tw);
+ });
- 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);
- });
- };
+ A JavaScript tokenizer / parser / beautifier / compressor.
+ https://github.com/mishoo/UglifyJS2
- 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;
- };
+ -------------------------------- (C) ---------------------------------
- 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 ]);
- });
- };
+ Author: Mihai Bazon
+
+ http://mihai.bazon.net/blog
- 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()));
- };
+ Distributed under the BSD license:
- 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("/");
- };
+ Copyright 2012 (c) Mihai Bazon
- function handle_dot() {
- next();
- return is_digit(peek())
- ? read_num(".")
- : token("punc", ".");
- };
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
- 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);
- };
+ * Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the following
+ disclaimer.
- function with_eof_error(eof_error, cont) {
- try {
- return cont();
- } catch(ex) {
- if (ex === EX_EOF) parse_error(eof_error);
- else throw ex;
- }
- };
+ * 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.
- 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 + "'");
- };
+ 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.
- next_token.context = function(nc) {
- if (nc) S = nc;
- return S;
- };
+ ***********************************************************************/
- return next_token;
+"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.index = index;
+ this.id = SymbolDef.next_id++;
};
-/* -----[ Parser (constants) ]----- */
-
-var UNARY_PREFIX = array_to_hash([
- "typeof",
- "void",
- "delete",
- "--",
- "++",
- "!",
- "~",
- "-",
- "+"
-]);
-
-var UNARY_POSTFIX = array_to_hash([ "--", "++" ]);
+SymbolDef.next_id = 1;
-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
-);
+SymbolDef.prototype = {
+ unmangleable: function(options) {
+ if (!options) options = {};
-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 (this.global && !options.toplevel)
+ || this.undeclared
+ || (!options.eval && (this.scope.uses_eval || this.scope.uses_with))
+ || (options.keep_fnames
+ && (this.orig[0] instanceof AST_SymbolLambda
+ || this.orig[0] instanceof AST_SymbolDefun));
+ },
+ mangle: function(options) {
+ var cache = options.cache && options.cache.props;
+ if (this.global && cache && cache.has(this.name)) {
+ this.mangled_name = cache.get(this.name);
+ }
+ else if (!this.mangled_name && !this.unmangleable(options)) {
+ var s = this.scope;
+ var sym = this.orig[0];
+ if (!options.screw_ie8 && sym instanceof AST_SymbolLambda)
+ s = s.parent_scope;
+ var def;
+ if (this.defun && (def = this.defun.variables.get(this.name))) {
+ this.mangled_name = def.mangled_name || def.name;
+ } else
+ this.mangled_name = s.next_mangled(options, this);
+ if (this.global && cache) {
+ cache.set(this.name, this.mangled_name);
+ }
}
}
- 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()); };
+AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
+ options = defaults(options, {
+ cache: null,
+ screw_ie8: true,
+ });
- function next() {
- S.prev = S.token;
- if (S.peeked) {
- S.token = S.peeked;
- S.peeked = null;
- } else {
- S.token = S.input();
+ // pass 1: setup scope chaining and handle definitions
+ var self = this;
+ var scope = self.parent_scope = null;
+ var labels = new Dictionary();
+ var defun = null;
+ var tw = new TreeWalker(function(node, descend){
+ if (node instanceof AST_Catch) {
+ var save_scope = scope;
+ scope = new AST_Scope(node);
+ scope.init_scope_vars(save_scope);
+ descend();
+ scope = save_scope;
+ return true;
}
- S.in_directives = S.in_directives && (
- S.token.type == "string" || is("punc", ";")
- );
- return S.token;
- };
+ if (node instanceof AST_Scope) {
+ node.init_scope_vars(scope);
+ var save_scope = scope;
+ var save_defun = defun;
+ var save_labels = labels;
+ defun = scope = node;
+ labels = new Dictionary();
+ descend();
+ scope = save_scope;
+ defun = save_defun;
+ labels = save_labels;
+ return true; // don't descend again in TreeWalker
+ }
+ 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; // no descend again
+ }
+ if (node instanceof AST_With) {
+ for (var s = scope; s; s = s.parent_scope)
+ s.uses_with = true;
+ return;
+ }
+ if (node instanceof AST_Symbol) {
+ node.scope = scope;
+ }
+ if (node instanceof AST_Label) {
+ node.thedef = node;
+ node.references = [];
+ }
+ if (node instanceof AST_SymbolLambda) {
+ defun.def_function(node);
+ }
+ else if (node instanceof AST_SymbolDefun) {
+ // Careful here, the scope where this should be defined is
+ // the parent scope. The reason is that we enter a new
+ // scope when we encounter the AST_Defun node (which is
+ // instanceof AST_Scope) but we get to the symbol a bit
+ // later.
+ (node.scope = defun.parent_scope).def_function(node);
+ }
+ else if (node instanceof AST_SymbolVar
+ || node instanceof AST_SymbolConst) {
+ defun.def_variable(node);
+ if (defun !== scope) {
+ node.mark_enclosed(options);
+ var def = scope.find_variable(node);
+ if (node.thedef !== def) {
+ node.thedef = def;
+ node.reference(options);
+ }
+ }
+ }
+ else if (node instanceof AST_SymbolCatch) {
+ scope.def_variable(node).defun = defun;
+ }
+ else 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);
- function prev() {
- return S.prev;
- };
+ // pass 2: find back references and eval
+ 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_LoopControl && node.label) {
+ node.label.thedef.references.push(node);
+ return true;
+ }
+ if (node instanceof AST_SymbolRef) {
+ var name = node.name;
+ 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;
+ }
+ }
+ var sym = node.scope.find_variable(name);
+ if (node.scope instanceof AST_Lambda && name == "arguments") {
+ node.scope.uses_arguments = true;
+ }
+ if (!sym) {
+ sym = self.def_global(node);
+ }
+ node.thedef = sym;
+ node.reference(options);
+ return true;
+ }
+ });
+ self.walk(tw);
- 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);
- };
+ // pass 3: fix up any scoping issue with IE8
+ if (!options.screw_ie8) {
+ self.walk(new TreeWalker(function(node, descend) {
+ if (node instanceof AST_SymbolCatch) {
+ var name = node.name;
+ var refs = node.thedef.references;
+ var scope = node.thedef.defun;
+ var def = scope.find_variable(name) || self.globals.get(name) || scope.def_variable(node);
+ refs.forEach(function(ref) {
+ ref.thedef = def;
+ ref.reference(options);
+ });
+ node.thedef = def;
+ return true;
+ }
+ }));
+ }
- function token_error(token, msg) {
- croak(msg, token.line, token.col);
- };
+ if (options.cache) {
+ this.cname = options.cache.cname;
+ }
+});
- function unexpected(token) {
- if (token == null)
- token = S.token;
- token_error(token, "Unexpected token: " + token.type + " (" + token.value + ")");
- };
+AST_Toplevel.DEFMETHOD("def_global", function(node){
+ var globals = this.globals, name = node.name;
+ if (globals.has(name)) {
+ return globals.get(name);
+ } else {
+ var g = new SymbolDef(this, globals.size(), node);
+ g.undeclared = true;
+ g.global = true;
+ globals.set(name, g);
+ return g;
+ }
+});
- function expect_token(type, val) {
- if (is(type, val)) {
- return next();
- }
- token_error(S.token, "Unexpected token " + S.token.type + ", expected " + type);
- };
+AST_Scope.DEFMETHOD("init_scope_vars", function(parent_scope){
+ this.variables = new Dictionary(); // map name to AST_SymbolVar (variables defined in this scope; includes functions)
+ this.functions = new Dictionary(); // map name to AST_SymbolDefun (functions defined in this scope)
+ this.uses_with = false; // will be set to true if this or some nested scope uses the `with` statement
+ this.uses_eval = false; // will be set to true if this or nested scope uses the global `eval`
+ this.parent_scope = parent_scope; // the parent scope
+ this.enclosed = []; // a list of variables from this or outer scope(s) that are referenced from this or inner scopes
+ this.cname = -1; // the current index for mangling functions/variables
+});
- function expect(punc) { return expect_token("punc", punc); };
+AST_Lambda.DEFMETHOD("init_scope_vars", function(){
+ AST_Scope.prototype.init_scope_vars.apply(this, arguments);
+ this.uses_arguments = false;
+ this.def_variable(new AST_SymbolVar({
+ name: "arguments",
+ start: this.start,
+ end: this.end
+ }));
+});
- function can_insert_semicolon() {
- return !exigent_mode && (
- S.token.nlb || is("eof") || is("punc", "}")
- );
- };
+AST_Symbol.DEFMETHOD("mark_enclosed", function(options) {
+ var def = this.definition();
+ var s = this.scope;
+ while (s) {
+ push_uniq(s.enclosed, def);
+ if (options.keep_fnames) {
+ s.functions.each(function(d) {
+ push_uniq(def.scope.enclosed, d);
+ });
+ }
+ if (s === def.scope) break;
+ s = s.parent_scope;
+ }
+});
- function semicolon() {
- if (is("punc", ";")) next();
- else if (!can_insert_semicolon()) unexpected();
- };
+AST_Symbol.DEFMETHOD("reference", function(options) {
+ this.definition().references.push(this);
+ this.mark_enclosed(options);
+});
- function as() {
- return slice(arguments);
- };
+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));
+});
- function parenthesised() {
- expect("(");
- var ex = expression();
- expect(")");
- return ex;
- };
+AST_Scope.DEFMETHOD("def_function", function(symbol){
+ this.functions.set(symbol.name, this.def_variable(symbol));
+});
- function add_tokens(str, start, end) {
- return str instanceof NodeWithToken ? str : new NodeWithToken(str, start, end);
- };
+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;
+});
- 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;
- };
+AST_Scope.DEFMETHOD("next_mangled", function(options){
+ var ext = this.enclosed;
+ out: while (true) {
+ var m = base54(++this.cname);
+ if (!is_identifier(m)) continue; // skip over "do"
- 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
+ // https://github.com/mishoo/UglifyJS2/issues/242 -- do not
+ // shadow a name excepted from mangling.
+ if (options.except.indexOf(m) >= 0) continue;
+
+ // we must ensure that the mangled name does not shadow a name
+ // from some parent scope that is referenced in this or in
+ // inner scopes.
+ 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;
}
- 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();
+ return m;
+ }
+});
- case "name":
- return is_token(peek(), "punc", ":")
- ? labeled_statement(prog1(S.token.value, next, next))
- : simple_statement();
+AST_Function.DEFMETHOD("next_mangled", function(options, def){
+ // #179, #326
+ // in Safari strict mode, something like (function x(x){...}) is a syntax error;
+ // a function expression's argument cannot shadow the function expression's name
- case "punc":
- switch (S.token.value) {
- case "{":
- return as("block", block_());
- case "[":
- case "(":
- return simple_statement();
- case ";":
- next();
- return as("block");
- default:
- unexpected();
- }
+ var tricky_def = def.orig[0] instanceof AST_SymbolFunarg && this.name && this.name.definition();
- case "keyword":
- switch (prog1(S.token.value, next)) {
- case "break":
- return break_cont("break");
+ // the function's mangled_name is null when keep_fnames is true
+ var tricky_name = tricky_def ? tricky_def.mangled_name || tricky_def.name : null;
- case "continue":
- return break_cont("continue");
+ while (true) {
+ var name = AST_Lambda.prototype.next_mangled.call(this, options, def);
+ if (!tricky_name || tricky_name != name)
+ return name;
+ }
+});
- case "debugger":
- semicolon();
- return as("debugger");
+AST_Symbol.DEFMETHOD("unmangleable", function(options){
+ return this.definition().unmangleable(options);
+});
- case "do":
- return (function(body){
- expect_token("keyword", "while");
- return as("do", prog1(parenthesised, semicolon), body);
- })(in_loop(statement));
+// labels are always mangleable
+AST_Label.DEFMETHOD("unmangleable", function(){
+ return false;
+});
- case "for":
- return for_();
+AST_Symbol.DEFMETHOD("unreferenced", function(){
+ return this.definition().references.length == 0
+ && !(this.scope.uses_eval || this.scope.uses_with);
+});
- case "function":
- return function_(true);
+AST_Symbol.DEFMETHOD("undeclared", function(){
+ return this.definition().undeclared;
+});
- 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));
+AST_LabelRef.DEFMETHOD("undeclared", function(){
+ return false;
+});
- case "switch":
- return as("switch", parenthesised(), switch_block_());
+AST_Label.DEFMETHOD("undeclared", function(){
+ return false;
+});
- case "throw":
- if (S.token.nlb)
- croak("Illegal newline after 'throw'");
- return as("throw", prog1(expression, semicolon));
+AST_Symbol.DEFMETHOD("definition", function(){
+ return this.thedef;
+});
- case "try":
- return try_();
+AST_Symbol.DEFMETHOD("global", function(){
+ return this.definition().global;
+});
- case "var":
- return prog1(var_, semicolon);
+AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options){
+ return defaults(options, {
+ eval : false,
+ except : [],
+ keep_fnames : false,
+ screw_ie8 : true,
+ sort : false, // Ignored. Flag retained for backwards compatibility.
+ toplevel : false,
+ });
+});
- case "const":
- return prog1(const_, semicolon);
+AST_Toplevel.DEFMETHOD("mangle_names", function(options){
+ options = this._default_mangler_options(options);
- case "while":
- return as("while", parenthesised(), in_loop(statement));
+ // Never mangle arguments
+ options.except.push('arguments');
- case "with":
- return as("with", parenthesised(), statement());
+ // We only need to mangle declaration nodes. Special logic wired
+ // into the code generator will display the mangled name if it's
+ // present (and for AST_SymbolRef-s it'll use the mangled name of
+ // the AST_SymbolDeclaration that it points to).
+ var lname = -1;
+ var to_mangle = [];
- default:
- unexpected();
+ if (options.cache) {
+ this.globals.each(function(symbol){
+ if (options.except.indexOf(symbol.name) < 0) {
+ to_mangle.push(symbol);
}
- }
- });
-
- 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;
+ var tw = new TreeWalker(function(node, descend){
+ if (node instanceof AST_LabeledStatement) {
+ // lname is incremented when we get to the AST_Label
+ var save_nesting = lname;
+ descend();
+ lname = save_nesting;
+ return true; // don't descend again in TreeWalker
}
- if (name != null) {
- next();
- if (!member(name, S.labels))
- croak("Label " + name + " without matching loop or statement");
+ 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);
+ }
+ });
+ to_mangle.push.apply(to_mangle, a);
+ return;
}
- 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);
- }
+ if (node instanceof AST_Label) {
+ var name;
+ do name = base54(++lname); while (!is_identifier(name));
+ node.mangled_name = name;
+ return true;
}
- 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();
+ if (options.screw_ie8 && node instanceof AST_SymbolCatch) {
+ to_mangle.push(node.definition());
+ return;
}
- return as("if", cond, body, belse);
- };
+ });
+ this.walk(tw);
+ to_mangle.forEach(function(def){ def.mangle(options) });
- function block_() {
- expect("{");
- var a = [];
- while (!is("punc", "}")) {
- if (is("eof")) unexpected();
- a.push(statement());
- }
- next();
- return a;
- };
+ if (options.cache) {
+ options.cache.cname = this.cname;
+ }
+});
- 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());
- }
+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");
}
- next();
- return a;
+ 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();
+});
- 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();
+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];
}
- return a;
- };
-
- function var_(no_in) {
- return as("var", vardefs(no_in));
};
-
- function const_() {
- return as("const", vardefs());
+ 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];
+ });
};
-
- function new_() {
- var newexp = expr_atom(false), args;
- if (is("punc", "(")) {
- next();
- args = expr_list(")");
- } else {
- args = [];
- }
- return subscripts(as("new", newexp, args), true);
+ base54.reset = reset;
+ reset();
+ base54.get = function(){ return chars };
+ base54.freq = function(){ return frequency };
+ function base54(num) {
+ var ret = "", base = 54;
+ num++;
+ do {
+ num--;
+ ret += String.fromCharCode(chars[num % base]);
+ num = Math.floor(num / base);
+ base = 64;
+ } while (num > 0);
+ return ret;
};
+ return base54;
+})();
- var expr_atom = maybe_embed_tokens(function(allow_calls) {
- if (is("operator", "new")) {
- next();
- return new_();
+AST_Toplevel.DEFMETHOD("scope_warnings", function(options){
+ options = defaults(options, {
+ assign_to_global : true,
+ eval : true,
+ func_arguments : true,
+ nested_defuns : true,
+ undeclared : false, // this makes a lot of noise
+ unreferenced : true,
+ });
+ var tw = new TreeWalker(function(node){
+ if (options.undeclared
+ && node instanceof AST_SymbolRef
+ && node.undeclared())
+ {
+ // XXX: this also warns about JS standard names,
+ // i.e. Object, Array, parseInt etc. Should add a list of
+ // exceptions.
+ 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 (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);
+ 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
+ });
}
- unexpected();
}
- if (is("keyword", "function")) {
- next();
- return subscripts(function_(false), allow_calls);
+ 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 instanceof AST_SymbolCatch)
+ && 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 (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);
+ 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
+ });
}
- unexpected();
});
+ this.walk(tw);
+});
- 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));
- };
+ A JavaScript tokenizer / parser / beautifier / compressor.
+ https://github.com/mishoo/UglifyJS2
- 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);
- };
+ -------------------------------- (C) ---------------------------------
- function as_property_name() {
- switch (S.token.type) {
- case "num":
- case "string":
- return prog1(S.token.value, next);
- }
- return as_name();
- };
+ Author: Mihai Bazon
+
+ http://mihai.bazon.net/blog
- function as_name() {
- switch (S.token.type) {
- case "name":
- case "operator":
- case "keyword":
- case "atom":
- return prog1(S.token.value, next);
- default:
- unexpected();
- }
- };
+ Distributed under the BSD license:
- 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;
- };
+ Copyright 2012 (c) Mihai Bazon
- 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;
- };
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
- function make_unary(tag, op, expr) {
- if ((op == "++" || op == "--") && !is_assignable(expr))
- croak("Invalid use of " + op + " operator");
- return as(tag, op, expr);
- };
+ * Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the following
+ disclaimer.
- 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;
- };
+ * 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.
- function expr_ops(no_in) {
- return expr_op(maybe_unary(true), 0, no_in);
- };
+ 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.
- 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";
- }
- };
+"use strict";
- 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 EXPECT_DIRECTIVE = /^$|[;{][\s\n]*$/;
- 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 is_some_comments(comment) {
+ // multiline comment
+ return comment.type == "comment2" && /@preserve|@license|@cc_on/i.test(comment.value);
+}
- function in_loop(cont) {
- try {
- ++S.in_loop;
- return cont();
- } finally {
- --S.in_loop;
+function OutputStream(options) {
+
+ options = defaults(options, {
+ ascii_only : false,
+ beautify : false,
+ bracketize : false,
+ comments : false,
+ indent_level : 4,
+ indent_start : 0,
+ inline_script : true,
+ keep_quoted_props: false,
+ max_line_len : false,
+ preamble : null,
+ preserve_line : false,
+ quote_keys : false,
+ quote_style : 0,
+ screw_ie8 : true,
+ semicolons : true,
+ shebang : true,
+ source_map : null,
+ space_colon : true,
+ unescape_regexps : false,
+ width : 80,
+ wrap_iife : false,
+ }, true);
+
+ // Convert comment option to RegExp if neccessary and set up comments filter
+ var comment_filter = return_false; // Default case, throw all comments away
+ if (options.comments) {
+ var comments = options.comments;
+ if (typeof options.comments === "string" && /^\/.*\/[a-zA-Z]*$/.test(options.comments)) {
+ var regex_pos = options.comments.lastIndexOf("/");
+ comments = new RegExp(
+ options.comments.substr(1, regex_pos - 1),
+ options.comments.substr(regex_pos + 1)
+ );
}
- };
+ if (comments instanceof RegExp) {
+ comment_filter = function(comment) {
+ return comment.type != "comment5" && comments.test(comment.value);
+ };
+ }
+ else if (typeof comments === "function") {
+ comment_filter = function(comment) {
+ return comment.type != "comment5" && comments(this, comment);
+ };
+ }
+ else if (comments === "some") {
+ comment_filter = is_some_comments;
+ } else { // NOTE includes "all" option
+ comment_filter = return_true;
+ }
+ }
- return as("toplevel", (function(a){
- while (!is("eof"))
- a.push(statement());
- return a;
- })([]));
+ 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(/[\u0000-\u001f\u007f-\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;
+ }
+ });
+ };
-/* -----[ Utilities ]----- */
+ function make_string(str, quote) {
+ var dq = 0, sq = 0;
+ str = str.replace(/[\\\b\f\n\r\v\t\x22\x27\u2028\u2029\0\ufeff]/g,
+ function(s, i){
+ switch (s) {
+ case '"': ++dq; return '"';
+ case "'": ++sq; return "'";
+ case "\\": return "\\\\";
+ case "\n": return "\\n";
+ case "\r": return "\\r";
+ case "\t": return "\\t";
+ case "\b": return "\\b";
+ case "\f": return "\\f";
+ case "\x0B": return options.screw_ie8 ? "\\v" : "\\x0B";
+ case "\u2028": return "\\u2028";
+ case "\u2029": return "\\u2029";
+ case "\ufeff": return "\\ufeff";
+ case "\0":
+ return /[0-7]/.test(str.charAt(i+1)) ? "\\x00" : "\\0";
+ }
+ return s;
+ });
+ function quote_single() {
+ return "'" + str.replace(/\x27/g, "\\'") + "'";
+ }
+ function quote_double() {
+ return '"' + str.replace(/\x22/g, '\\"') + '"';
+ }
+ if (options.ascii_only) str = to_ascii(str);
+ switch (options.quote_style) {
+ case 1:
+ return quote_single();
+ case 2:
+ return quote_double();
+ case 3:
+ return quote == "'" ? quote_single() : quote_double();
+ default:
+ return dq > sq ? quote_single() : quote_double();
+ }
+ };
-function curry(f) {
- var args = slice(arguments, 1);
- return function() { return f.apply(this, args.concat(slice(arguments))); };
-};
+ function encode_string(str, quote) {
+ var ret = make_string(str, quote);
+ if (options.inline_script) {
+ ret = ret.replace(/<\x2fscript([>\/\t\n\f\r ])/gi, "<\\/script$1");
+ ret = ret.replace(/\x3c!--/g, "\\x3c!--");
+ ret = ret.replace(/--\x3e/g, "--\\x3e");
+ }
+ return ret;
+ };
-function prog1(ret) {
- if (ret instanceof Function)
- ret = ret();
- for (var i = 1, n = arguments.length; --n > 0; ++i)
- arguments[i]();
- return ret;
-};
+ function make_name(name) {
+ name = name.toString();
+ if (options.ascii_only)
+ name = to_ascii(name, true);
+ return name;
+ };
-function array_to_hash(a) {
- var ret = {};
- for (var i = 0; i < a.length; ++i)
- ret[a[i]] = true;
- return ret;
-};
+ function make_indent(back) {
+ return repeat_string(" ", options.indent_start + indentation - back * options.indent_level);
+ };
-function slice(a, start) {
- return Array.prototype.slice.call(a, start || 0);
-};
+ /* -----[ beautification/minification ]----- */
-function characters(str) {
- return str.split("");
-};
+ var might_need_space = false;
+ var might_need_semicolon = false;
+ var might_add_newline = 0;
+ var last = "";
+
+ var ensure_line_len = options.max_line_len ? function() {
+ if (current_col > options.max_line_len) {
+ if (might_add_newline) {
+ var left = OUTPUT.slice(0, might_add_newline);
+ var right = OUTPUT.slice(might_add_newline);
+ OUTPUT = left + "\n" + right;
+ current_line++;
+ current_pos++;
+ current_col = right.length;
+ }
+ if (current_col > options.max_line_len) {
+ AST_Node.warn("Output exceeds {max_line_len} characters", options);
+ }
+ }
+ might_add_newline = 0;
+ } : noop;
-function member(name, array) {
- for (var i = array.length; --i >= 0;)
- if (array[i] == name)
- return true;
- return false;
-};
+ var requireSemicolonChars = makePredicate("( [ + * / - , .");
-function HOP(obj, prop) {
- return Object.prototype.hasOwnProperty.call(obj, prop);
-};
+ function print(str) {
+ str = String(str);
+ var ch = str.charAt(0);
+ var prev = last.charAt(last.length - 1);
+ if (might_need_semicolon) {
+ might_need_semicolon = false;
-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;
-};
+ if (prev == ":" && ch == "}" || (!ch || ";}".indexOf(ch) < 0) && prev != ";") {
+ if (options.semicolons || requireSemicolonChars(ch)) {
+ OUTPUT += ";";
+ current_col++;
+ current_pos++;
+ } else {
+ ensure_line_len();
+ OUTPUT += "\n";
+ current_pos++;
+ current_line++;
+ current_col = 0;
-// 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 ]);
+ if (/^\s+$/.test(str)) {
+ // reset the semicolon flag, since we didn't print one
+ // now and might still have to later
+ might_need_semicolon = true;
}
- } 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", "" ]];
}
+
+ if (!options.beautify)
+ might_need_space = false;
}
}
- }, 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) {
-/***********************************************************************
+ if (!options.beautify && options.preserve_line && stack[stack.length - 1]) {
+ var target_line = stack[stack.length - 1].start.line;
+ while (current_line < target_line) {
+ ensure_line_len();
+ OUTPUT += "\n";
+ current_pos++;
+ current_line++;
+ current_col = 0;
+ might_need_space = false;
+ }
+ }
- A JavaScript tokenizer / parser / beautifier / compressor.
+ if (might_need_space) {
+ if ((is_identifier_char(prev)
+ && (is_identifier_char(ch) || ch == "\\"))
+ || (ch == "/" && ch == prev)
+ || ((ch == "+" || ch == "-") && ch == last))
+ {
+ OUTPUT += " ";
+ current_col++;
+ current_pos++;
+ }
+ might_need_space = false;
+ }
+ OUTPUT += str;
+ current_pos += str.length;
+ var a = str.split(/\r?\n/), n = a.length - 1;
+ current_line += n;
+ current_col += a[0].length;
+ if (n > 0) {
+ ensure_line_len();
+ current_col = a[n].length;
+ }
+ last = str;
+ };
- This version is suitable for Node.js. With minimal changes (the
- exports stuff) it should work on any JS platform.
+ var space = options.beautify ? function() {
+ print(" ");
+ } : function() {
+ might_need_space = true;
+ };
- This file implements some AST processors. They work on data built
- by parse-js.
+ var indent = options.beautify ? function(half) {
+ if (options.beautify) {
+ print(make_indent(half ? 0.5 : 0));
+ }
+ } : noop;
- Exported functions:
+ 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() };
- - ast_mangle(ast, options) -- mangles the variable/function names
- in the AST. Returns an AST.
+ var newline = options.beautify ? function() {
+ print("\n");
+ } : options.max_line_len ? function() {
+ ensure_line_len();
+ might_add_newline = OUTPUT.length;
+ } : noop;
- - ast_squeeze(ast) -- employs various optimizations to make the
- final generated code even smaller. Returns an AST.
+ var semicolon = options.beautify ? function() {
+ print(";");
+ } : function() {
+ might_need_semicolon = true;
+ };
- - 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.
+ function force_semicolon() {
+ might_need_semicolon = false;
+ print(";");
+ };
- -------------------------------- (C) ---------------------------------
+ function next_indent() {
+ return indentation + options.indent_level;
+ };
- Author: Mihai Bazon
-
- http://mihai.bazon.net/blog
+ function with_block(cont) {
+ var ret;
+ print("{");
+ newline();
+ with_indent(next_indent(), function(){
+ ret = cont();
+ });
+ indent();
+ print("}");
+ return ret;
+ };
- Distributed under the BSD license:
+ function with_parens(cont) {
+ print("(");
+ //XXX: still nice to have that for argument lists
+ //var ret = with_indent(current_col, cont);
+ var ret = cont();
+ print(")");
+ return ret;
+ };
- Copyright 2010 (c) Mihai Bazon
+ function with_square(cont) {
+ print("[");
+ //var ret = with_indent(current_col, cont);
+ var ret = cont();
+ print("]");
+ return ret;
+ };
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions
- are met:
+ function comma() {
+ print(",");
+ space();
+ };
- * Redistributions of source code must retain the above
- copyright notice, this list of conditions and the following
- disclaimer.
+ function colon() {
+ print(":");
+ if (options.space_colon) space();
+ };
- * 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;
+ var add_mapping = options.source_map ? function(token, name) {
try {
- stack.push(ast);
- return walkers[ast[0]].apply(ast, ast.slice(1));
- } finally {
- stack.pop();
+ 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 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];
+ function get() {
+ if (might_add_newline) {
+ ensure_line_len();
}
- return ret;
+ return OUTPUT;
};
+ var stack = [];
return {
- walk: walk,
- dive: dive,
- with_walkers: with_walkers,
- parent: function() {
- return stack[stack.length - 2]; // last one is current node
+ 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, quote, escape_directive) {
+ var encoded = encode_string(str, quote);
+ if (escape_directive === true && encoded.indexOf("\\") === -1) {
+ // Insert semicolons to break directive prologue
+ if (!EXPECT_DIRECTIVE.test(OUTPUT)) {
+ force_semicolon();
+ }
+ force_semicolon();
+ }
+ print(encoded);
},
- stack: function() {
- return stack;
+ encode_string : encode_string,
+ 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] },
+ comment_filter : comment_filter,
+ 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() },
+ parent : function(n) {
+ return stack[stack.length - 2 - (n || 0)];
}
};
-};
-/* -----[ 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;
+/* -----[ code generators ]----- */
- // case 1.
- prior = this.has_mangled(m);
- if (prior && this.refs[prior.rev_mangled[m]] === prior)
- continue;
+(function(){
- // case 2.
- prior = this.has(m);
- if (prior && prior !== this && this.refs[m] === prior && !prior.has_mangled(m))
- continue;
+ /* -----[ utils ]----- */
- // case 3.
- if (HOP(this.refs, m) && this.refs[m] == null)
- continue;
+ function DEFPRINT(nodetype, generator) {
+ nodetype.DEFMETHOD("_codegen", generator);
+ };
- // I got "do" once. :-/
- if (!is_identifier(m))
- continue;
+ var use_asm = false;
+ var in_directive = false;
- return m;
+ AST_Node.DEFMETHOD("print", function(stream, force_parens){
+ var self = this, generator = self._codegen, prev_use_asm = use_asm;
+ if (self instanceof AST_Directive && self.value == "use asm" && stream.parent() instanceof AST_Scope) {
+ use_asm = true;
}
- },
- 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;
+ function doit() {
+ self.add_comments(stream);
+ self.add_source_map(stream);
+ generator(self, stream);
}
- },
- 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;
- };
+ stream.push_node(self);
+ if (force_parens || self.needs_parens(stream)) {
+ stream.with_parens(doit);
+ } else {
+ doit();
+ }
+ stream.pop_node();
+ if (self instanceof AST_Scope) {
+ use_asm = prev_use_asm;
+ }
+ });
- 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);
- });
+ AST_Node.DEFMETHOD("print_to_string", function(options){
+ var s = OutputStream(options);
+ if (!options) s._readonly = true;
+ this.print(s);
+ return s.get();
+ });
- // the reason why we need an additional pass here is
- // that names can be used prior to their definition.
+ /* -----[ comments ]----- */
- // 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;
+ AST_Node.DEFMETHOD("add_comments", function(output){
+ if (output._readonly) return;
+ var self = this;
+ var start = self.start;
+ if (start && !start._comments_dumped) {
+ start._comments_dumped = true;
+ var comments = start.comments_before || [];
+
+ // XXX: ugly fix for https://github.com/mishoo/UglifyJS2/issues/112
+ // and https://github.com/mishoo/UglifyJS2/issues/372
+ if (self instanceof AST_Exit && self.value) {
+ self.value.walk(new TreeWalker(function(node){
+ if (node.start && node.start.comments_before) {
+ comments = comments.concat(node.start.comments_before);
+ node.start.comments_before = [];
+ }
+ if (node instanceof AST_Function ||
+ node instanceof AST_Array ||
+ node instanceof AST_Object)
+ {
+ return true; // don't go inside.
+ }
+ }));
}
- });
- // 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;
+ if (output.pos() == 0) {
+ if (comments.length > 0 && output.option("shebang") && comments[0].type == "comment5") {
+ output.print("#!" + comments.shift().value + "\n");
+ output.indent();
+ }
+ var preamble = output.option("preamble");
+ if (preamble) {
+ output.print(preamble.replace(/\r\n?|[\n\u2028\u2029]|\s*$/g, "\n"));
}
}
- };
- fixrefs(current_scope);
-
- return ret;
- });
-};
+ comments = comments.filter(output.comment_filter, self);
-/* -----[ mangle names ]----- */
+ // Keep single line comments after nlb, after nlb
+ if (!output.option("beautify") && comments.length > 0 &&
+ /comment[134]/.test(comments[0].type) &&
+ output.col() !== 0 && comments[0].nlb)
+ {
+ output.print("\n");
+ }
-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
+ comments.forEach(function(c){
+ if (/comment[134]/.test(c.type)) {
+ 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 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);
- };
+ /* -----[ PARENTHESES ]----- */
- 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 PARENS(nodetype, func) {
+ if (Array.isArray(nodetype)) {
+ nodetype.forEach(function(nodetype){
+ PARENS(nodetype, func);
+ });
+ } else {
+ nodetype.DEFMETHOD("needs_parens", func);
}
};
- 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 ];
- };
+ PARENS(AST_Node, function(){
+ return false;
+ });
- 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]);
+ // a function expression needs parens around it when it's provably
+ // the first token to appear in a statement.
+ PARENS(AST_Function, function(output){
+ if (first_in_statement(output)) {
+ return true;
}
- for (var i in s.names) if (HOP(s.names, i)) {
- get_mangled(i, true);
+
+ if (output.option('wrap_iife')) {
+ var p = output.parent();
+ return p instanceof AST_Call && p.expression === this;
}
- 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]) ];
- }) ];
- };
+ return false;
+ });
- function _breacont(label) {
- if (label) return [ this[0], scope.labels.get_mangled(label) ];
- };
+ // same goes for an object literal, because otherwise it would be
+ // interpreted as a block of code.
+ PARENS(AST_Object, function(output){
+ return first_in_statement(output);
+ });
- 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));
+ PARENS(AST_Unary, function(output){
+ var p = output.parent();
+ return p instanceof AST_PropAccess && p.expression === this
+ || p instanceof AST_Call && p.expression === this;
});
-};
-
-/* -----[
- - 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;
- };
+ PARENS(AST_Seq, function(output){
+ var p = output.parent();
+ return p instanceof AST_Call // (foo, bar)() or foo(1, (2, 3), 4)
+ || p instanceof AST_Unary // !(foo, bar, baz)
+ || p instanceof AST_Binary // 1 + (2, 3) + 4 ==> 8
+ || p instanceof AST_VarDef // var a = (1, 2), b = a + a; ==> b == 4
+ || p instanceof AST_PropAccess // (1, {foo:2}).foo or (1, {foo:2})["foo"] ==> 2
+ || p instanceof AST_Array // [ 1, (2, 3), 4 ] ==> [ 1, 3, 4 ]
+ || p instanceof AST_ObjectProperty // { foo: (1, 2) }.foo ==> 2
+ || p instanceof AST_Conditional /* (false, true) ? (a = 10, b = 20) : (c = 30)
+ * ==> 20 (side effect, set a := 10 and b := 20) */
+ ;
+ });
- 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;
+ PARENS(AST_Binary, function(output){
+ var p = output.parent();
+ // (foo && bar)()
+ if (p instanceof AST_Call && p.expression === this)
+ return true;
+ // typeof (foo && bar)
+ if (p instanceof AST_Unary)
+ return true;
+ // (foo && bar)["prop"], (foo && bar).prop
+ if (p instanceof AST_PropAccess && p.expression === this)
+ return true;
+ // this deals with precedence: 3 * (2 + 1)
+ 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)) {
+ return true;
}
- 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;
+ PARENS(AST_PropAccess, function(output){
+ var p = output.parent();
+ if (p instanceof AST_New && p.expression === this) {
+ // i.e. new (foo.bar().baz)
+ //
+ // if there's one call into this subtree, then we need
+ // parens around it too, otherwise the call will be
+ // interpreted as passing the arguments to the upper New
+ // expression.
+ try {
+ this.walk(new TreeWalker(function(node){
+ if (node instanceof AST_Call) throw p;
+ }));
+ } catch(ex) {
+ if (ex !== p) throw ex;
+ return true;
+ }
}
});
-};
-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));
- });
-};
+ PARENS(AST_Call, function(output){
+ var p = output.parent(), p1;
+ if (p instanceof AST_New && p.expression === this)
+ return true;
-function ast_squeeze(ast, options) {
- ast = squeeze_1(ast, options);
- ast = squeeze_2(ast, options);
- return ast;
-};
+ // workaround for Safari bug.
+ // https://bugs.webkit.org/show_bug.cgi?id=123506
+ return this.expression instanceof AST_Function
+ && p instanceof AST_PropAccess
+ && p.expression === this
+ && (p1 = output.parent(1)) instanceof AST_Assign
+ && p1.left === p;
+ });
-function squeeze_1(ast, options) {
- options = defaults(options, {
- make_seqs : true,
- dead_code : true,
- no_warnings : false,
- keep_comps : true,
- unsafe : false
+ PARENS(AST_New, function(output){
+ var p = output.parent();
+ if (!need_constructor_parens(this, output)
+ && (p instanceof AST_PropAccess // (new Date).getTime(), (new Date)["getTime"]()
+ || p instanceof AST_Call && p.expression === this)) // (new foo)(bar)
+ return true;
});
- 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) ]);
+ PARENS(AST_Number, function(output){
+ var p = output.parent();
+ if (p instanceof AST_PropAccess && p.expression === this) {
+ var value = this.getValue();
+ if (value < 0 || /^0/.test(make_num(value))) {
+ return true;
}
- 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);
- };
+ PARENS([ AST_Assign, AST_Conditional ], function (output){
+ var p = output.parent();
+ // !(a = false) → true
+ if (p instanceof AST_Unary)
+ return true;
+ // 1 + (a = 2) + 3 → 6, side effect setting a = 2
+ if (p instanceof AST_Binary && !(p instanceof AST_Assign))
+ return true;
+ // (a = func)() —or— new (a = Object)()
+ if (p instanceof AST_Call && p.expression === this)
+ return true;
+ // (a = foo) ? bar : baz
+ if (p instanceof AST_Conditional && p.condition === this)
+ return true;
+ // (a = foo)["prop"] —or— (a = foo).prop
+ if (p instanceof AST_PropAccess && p.expression === this)
+ return true;
+ });
- 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;
- };
+ /* -----[ PRINTERS ]----- */
- function _lambda(name, args, body) {
- return [ this[0], name, args, tighten(body, "lambda") ];
- };
+ DEFPRINT(AST_Directive, function(self, output){
+ output.print_string(self.value, self.quote);
+ output.semicolon();
+ });
+ DEFPRINT(AST_Debugger, function(self, output){
+ output.print("debugger");
+ output.semicolon();
+ });
- // 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 = statements.reduce(function(a, stat){
- if (stat[0] == "block") {
- if (stat[1]) {
- a.push.apply(a, stat[1]);
- }
- } else {
- a.push(stat);
+ function display_body(body, is_toplevel, output, allow_directives) {
+ var last = body.length - 1;
+ in_directive = allow_directives;
+ body.forEach(function(stmt, i){
+ if (in_directive === true && !(stmt instanceof AST_Directive ||
+ stmt instanceof AST_EmptyStatement ||
+ (stmt instanceof AST_SimpleStatement && stmt.body instanceof AST_String)
+ )) {
+ in_directive = false;
}
- 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 (!(stmt instanceof AST_EmptyStatement)) {
+ output.indent();
+ stmt.print(output);
+ if (!(i == last && is_toplevel)) {
+ output.newline();
+ if (is_toplevel) output.newline();
}
- });
- 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" ];
+ if (in_directive === true &&
+ stmt instanceof AST_SimpleStatement &&
+ stmt.body instanceof AST_String
+ ) {
+ in_directive = false;
}
- }, function() {
- return make_real_if(c, t, e);
});
+ in_directive = false;
};
- 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 ];
+ AST_StatementWithBody.DEFMETHOD("_do_print_body", function(output){
+ force_statement(this.body, output);
+ });
- 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) ];
- }
+ DEFPRINT(AST_Statement, function(self, output){
+ self.body.print(output);
+ output.semicolon();
+ });
+ DEFPRINT(AST_Toplevel, function(self, output){
+ display_body(self.body, true, output, true);
+ 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, allow_directives) {
+ if (body.length > 0) output.with_block(function(){
+ display_body(body, false, output, allow_directives);
});
+ else output.print("{}");
};
-
- 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) ] ];
+ 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();
+ make_block(self.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": 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 ]];
+ if (self.condition) {
+ self.condition.print(output);
+ output.print(";");
+ output.space();
+ } else {
+ output.print(";");
}
- },
- "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];
+ if (self.step) {
+ self.step.print(output);
}
- 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))));
+ });
+ output.space();
+ self._do_print_body(output);
});
-};
-
-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));
+ 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);
});
-};
-
-/* -----[ 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;
+ 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);
});
- 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;
+ /* -----[ functions ]----- */
+ 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, true);
});
-};
-
-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
+ DEFPRINT(AST_Lambda, function(self, output){
+ self._do_print(output);
});
- 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 + ")";
+ /* -----[ exits ]----- */
+ AST_Exit.DEFMETHOD("_do_print", function(output, kind){
+ output.print(kind);
+ if (this.value) {
+ output.space();
+ this.value.print(output);
}
- return gen;
- };
+ output.semicolon();
+ });
+ DEFPRINT(AST_Return, function(self, output){
+ self._do_print(output, "return");
+ });
+ DEFPRINT(AST_Throw, function(self, output){
+ self._do_print(output, "throw");
+ });
- 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;
+ /* -----[ loop control ]----- */
+ AST_LoopControl.DEFMETHOD("_do_print", function(output, kind){
+ output.print(kind);
+ if (this.label) {
+ output.space();
+ this.label.print(output);
}
- return best_of([ a[0], best_of(a.slice(1)) ]);
- };
+ 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 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;
+ /* -----[ if ]----- */
+ function make_then(self, output) {
+ var b = self.body;
+ if (output.option("bracketize")
+ || !output.option("screw_ie8") && b instanceof AST_Do)
+ return make_block(b, output);
+ // The squeezer replaces "block"-s that contain only a single
+ // statement with the statement itself; technically, the AST
+ // is correct, but this can create problems when we output an
+ // IF having an ELSE clause where the THEN clause ends in an
+ // IF *without* an ELSE block (then the outer ELSE would refer
+ // to the inner IF). This function checks for this case and
+ // adds the block brackets if needed.
+ if (!b) return output.force_semicolon();
+ while (true) {
+ if (b instanceof AST_If) {
+ if (!b.alternative) {
+ make_block(self.body, output);
+ return;
}
+ b = b.alternative;
}
- }
- 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 (b instanceof AST_StatementWithBody) {
+ b = b.body;
}
- } else if ((m = /^0?\.(0+)(.*)$/.exec(num))) {
- a.push(m[2] + "e-" + (m[1].length + m[2].length),
- str.substr(str.indexOf(".")));
+ else break;
}
- return best_of(a);
+ force_statement(self.body, output);
};
-
- 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;
+ 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();
+ if (self.alternative instanceof AST_If)
+ self.alternative.print(output);
+ else
+ force_statement(self.alternative, output);
+ } else {
+ self._do_print_body(output);
}
- 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;
- };
+ /* -----[ switch ]----- */
+ DEFPRINT(AST_Switch, function(self, output){
+ output.print("switch");
+ output.space();
+ output.with_parens(function(){
+ self.expression.print(output);
+ });
+ output.space();
+ var last = self.body.length - 1;
+ if (last < 0) output.print("{}");
+ else output.with_block(function(){
+ self.body.forEach(function(branch, i){
+ output.indent(true);
+ branch.print(output);
+ if (i < last && branch.body.length > 0)
+ output.newline();
+ });
+ });
+ });
+ AST_SwitchBranch.DEFMETHOD("_do_print_body", function(output){
+ 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);
+ });
- 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;
+ /* -----[ exceptions ]----- */
+ 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);
}
- };
-
- 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);
- }
+ if (self.bfinally) {
+ output.space();
+ self.bfinally.print(output);
}
- 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("}");
- };
+ });
+ 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);
+ });
- 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("}");
- };
+ /* -----[ var/const ]----- */
+ 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 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 parenthesize_for_noin(node, output, noin) {
+ if (!noin) node.print(output);
+ else try {
+ // need to take some precautions here:
+ // https://github.com/mishoo/UglifyJS2/issues/60
+ 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);
+ }
};
-};
-
-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
+ 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);
+ }
+ });
-var MAP;
+ /* -----[ other expressions ]----- */
+ DEFPRINT(AST_Call, function(self, output){
+ self.expression.print(output);
+ if (self instanceof AST_New && !need_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);
+ });
-(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);
- }
+ AST_Seq.DEFMETHOD("_do_print", function(output){
+ this.car.print(output);
+ if (this.cdr) {
+ output.comma();
+ if (output.should_break()) {
+ output.newline();
+ output.indent();
}
- else if (val != skip) {
- if (val instanceof Splice) {
- ret.push.apply(ret, val.v);
- } else {
- ret.push(val);
- }
+ this.cdr.print(output);
+ }
+ });
+ DEFPRINT(AST_Seq, function(self, output){
+ self._do_print(output);
+ // var p = output.parent();
+ // if (p instanceof AST_Statement) {
+ // output.with_indent(output.next_indent(), function(){
+ // self._do_print(output);
+ // });
+ // } else {
+ // 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(".");
}
- };
- 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, aAllowDuplicates) {
- var set = new ArraySet();
- for (var i = 0, len = aArray.length; i < len; i++) {
- set.add(aArray[i], aAllowDuplicates);
- }
- return set;
- };
-
- /**
- * Add the given string to this set.
- *
- * @param String aStr
- */
- ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
- var isDuplicate = this.has(aStr);
- var idx = this._array.length;
- if (!isDuplicate || aAllowDuplicates) {
- this._array.push(aStr);
- }
- if (!isDuplicate) {
- 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;
+ }
+ output.print(".");
+ // the name after dot would be mapped about here.
+ 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)
+ || (/[+-]$/.test(op)
+ && self.expression instanceof AST_UnaryPrefix
+ && /^[+-]/.test(self.expression.operator))) {
+ 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){
+ var op = self.operator;
+ self.left.print(output);
+ if (op[0] == ">" /* ">>" ">>>" ">" ">=" */
+ && self.left instanceof AST_UnaryPostfix
+ && self.left.operator == "--") {
+ // space is mandatory to avoid outputting -->
+ output.print(" ");
+ } else {
+ // the space is optional depending on "beautify"
+ output.space();
+ }
+ output.print(op);
+ if ((op == "<" || op == "<<")
+ && self.right instanceof AST_UnaryPrefix
+ && self.right.operator == "!"
+ && self.right.expression instanceof AST_UnaryPrefix
+ && self.right.expression.operator == "--") {
+ // space is mandatory to avoid outputting ") && S.newline_before) {
- forward(3);
- return skip_line_comment("comment4");
- }
- }
- 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;
-
-};
-
-/* -----[ Parser (constants) ]----- */
-
-var UNARY_PREFIX = makePredicate([
- "typeof",
- "void",
- "delete",
- "--",
- "++",
- "!",
- "~",
- "-",
- "+"
-]);
-
-var UNARY_POSTFIX = makePredicate([ "--", "++" ]);
-
-var ASSIGNMENT = makePredicate([ "=", "+=", "-=", "/=", "*=", "%=", ">>=", "<<=", ">>>=", "|=", "^=", "&=" ]);
-
-var PRECEDENCE = (function(a, ret){
- for (var i = 0; i < a.length; ++i) {
- var b = a[i];
- for (var j = 0; j < b.length; ++j) {
- ret[b[j]] = i + 1;
- }
- }
- 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 parse($TEXT, options) {
-
- options = defaults(options, {
- strict : false,
- filename : null,
- toplevel : null,
- expression : false,
- html5_comments : true,
- });
-
- var S = {
- input : (typeof $TEXT == "string"
- ? tokenizer($TEXT, options.filename,
- options.html5_comments)
- : $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;
- };
- };
-
- function handle_regexp() {
- if (is("operator", "/") || is("operator", "/=")) {
- S.peeked = null;
- S.token = S.input(S.token.value.substr(1)); // force regexp
- }
- };
-
- var statement = embed_tokens(function() {
- var tmp;
- handle_regexp();
- switch (S.token.type) {
- case "string":
- var dir = S.in_directives, stat = simple_statement();
- // XXXv2: decide how to fix directives
- 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_(AST_Defun);
-
- 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)) {
- // ECMA-262, 12.12: An ECMAScript program is considered
- // syntactically incorrect if it contains a
- // LabelledStatement that is enclosed by a
- // LabelledStatement with the same Identifier as label.
- croak("Label " + label.name + " defined twice");
- }
- expect(":");
- S.labels.push(label);
- var stat = statement();
- S.labels.pop();
- if (!(stat instanceof AST_IterationStatement)) {
- // check for `continue` that refers to this label.
- // those should be reported as syntax errors.
- // https://github.com/mishoo/UglifyJS2/issues/287
- label.references.forEach(function(ref){
- if (ref instanceof AST_Continue) {
- ref = ref.label.start;
- croak("Continue label `" + label.name + "` refers to non-IterationStatement.",
- ref.line, ref.col, ref.pos);
- }
- });
- }
- 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, ldef;
- if (!can_insert_semicolon()) {
- label = as_symbol(AST_LabelRef, true);
- }
- if (label != null) {
- ldef = find_if(function(l){ return l.name == label.name }, S.labels);
- if (!ldef)
- croak("Undefined label " + label.name);
- label.thedef = ldef;
- }
- else if (S.in_loop == 0)
- croak(type.TYPE + " not inside a loop or switch");
- semicolon();
- var stat = new type({ label: label });
- if (ldef) ldef.references.push(stat);
- return stat;
- };
-
- 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(ctor) {
- var in_statement = ctor === AST_Defun;
- var name = is("name") ? as_symbol(in_statement ? AST_SymbolDefun : AST_SymbolLambda) : null;
- if (in_statement && !name)
- unexpected();
- expect("(");
- 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":
- case "keyword":
- ret = _make_symbol(AST_SymbolRef);
- break;
- 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_(AST_Function);
- 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", "}"))
- // allow trailing comma
- 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 : as_atom_node(),
- value : function_(AST_Accessor),
- end : prev()
- }));
- continue;
- }
- if (name == "set") {
- a.push(new AST_ObjectSetter({
- start : start,
- key : as_atom_node(),
- value : function_(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 _make_symbol(type) {
- var name = S.token.value;
- return new (name == "this" ? AST_This : type)({
- name : String(name),
- start : S.token,
- end : S.token
- });
- };
-
- function as_symbol(type, noerror) {
- if (!is("name")) {
- if (!noerror) croak("Name expected");
- return null;
- }
- var sym = _make_symbol(type);
- 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();
- handle_regexp();
- 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 : prev()
- });
- }
- 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;
- })();
-
-};
-
-/***********************************************************************
-
- A JavaScript tokenizer / parser / beautifier / compressor.
- https://github.com/mishoo/UglifyJS2
-
- -------------------------------- (C) ---------------------------------
-
- Author: Mihai Bazon
-
- http://mihai.bazon.net/blog
-
- Distributed under the BSD license:
-
- Copyright 2012 (c) Mihai Bazon
-
- 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.
-
- ***********************************************************************/
-
-"use strict";
-
-// Tree transformer helpers.
-
-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){
- self.name = self.name.transform(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);
- });
-
-})();
-
-/***********************************************************************
-
- A JavaScript tokenizer / parser / beautifier / compressor.
- https://github.com/mishoo/UglifyJS2
-
- -------------------------------- (C) ---------------------------------
-
- Author: Mihai Bazon
-
- http://mihai.bazon.net/blog
-
- Distributed under the BSD license:
-
- Copyright 2012 (c) Mihai Bazon
-
- 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.
-
- ***********************************************************************/
-
-"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 (!options.screw_ie8 && this.orig[0] instanceof AST_SymbolLambda)
- s = s.parent_scope;
- this.mangled_name = s.next_mangled(options, this);
- }
- }
-};
-
-AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
- options = defaults(options, {
- screw_ie8: false
- });
-
- // pass 1: setup scope chaining and handle definitions
- var self = this;
- var scope = self.parent_scope = null;
- var defun = null;
- var nesting = 0;
- var tw = new TreeWalker(function(node, descend){
- if (options.screw_ie8 && node instanceof AST_Catch) {
- var save_scope = scope;
- scope = new AST_Scope(node);
- scope.init_scope_vars(nesting);
- scope.parent_scope = save_scope;
- descend();
- scope = save_scope;
- return true;
- }
- if (node instanceof AST_Scope) {
- node.init_scope_vars(nesting);
- var save_scope = node.parent_scope = scope;
- var save_defun = defun;
- defun = scope = node;
- ++nesting; descend(); --nesting;
- scope = save_scope;
- defun = save_defun;
- return true; // don't descend again in TreeWalker
- }
- 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_Symbol) {
- node.scope = scope;
- }
- if (node instanceof AST_SymbolLambda) {
- defun.def_function(node);
- }
- else if (node instanceof AST_SymbolDefun) {
- // Careful here, the scope where this should be defined is
- // the parent scope. The reason is that we enter a new
- // scope when we encounter the AST_Defun node (which is
- // instanceof AST_Scope) but we get to the symbol a bit
- // later.
- (node.scope = defun.parent_scope).def_function(node);
- }
- else if (node instanceof AST_SymbolVar
- || node instanceof AST_SymbolConst) {
- var def = defun.def_variable(node);
- def.constant = node instanceof AST_SymbolConst;
- def.init = tw.parent().value;
- }
- else if (node instanceof AST_SymbolCatch) {
- (options.screw_ie8 ? scope : defun)
- .def_variable(node);
- }
- });
- self.walk(tw);
-
- // pass 2: find back references and eval
- 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_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 (func && 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 = []; // contains the directives defined in this scope, i.e. "use strict"
- this.variables = new Dictionary(); // map name to AST_SymbolVar (variables defined in this scope; includes functions)
- this.functions = new Dictionary(); // map name to AST_SymbolDefun (functions defined in this scope)
- this.uses_with = false; // will be set to true if this or some nested scope uses the `with` statement
- this.uses_eval = false; // will be set to true if this or nested scope uses the global `eval`
- this.parent_scope = null; // the parent scope
- this.enclosed = []; // a list of variables from this or outer scope(s) that are referenced from this or inner scopes
- this.cname = -1; // the current index for mangling functions/variables
- this.nesting = nesting; // the nesting level of this scope (0 means toplevel)
-});
-
-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_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; // skip over "do"
-
- // https://github.com/mishoo/UglifyJS2/issues/242 -- do not
- // shadow a name excepted from mangling.
- if (options.except.indexOf(m) >= 0) continue;
-
- // we must ensure that the mangled name does not shadow a name
- // from some parent scope that is referenced in this or in
- // inner scopes.
- 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_Function.DEFMETHOD("next_mangled", function(options, def){
- // #179, #326
- // in Safari strict mode, something like (function x(x){...}) is a syntax error;
- // a function expression's argument cannot shadow the function expression's name
-
- var tricky_def = def.orig[0] instanceof AST_SymbolFunarg && this.name && this.name.definition();
- while (true) {
- var name = AST_Lambda.prototype.next_mangled.call(this, options, def);
- if (!(tricky_def && tricky_def.mangled_name == name))
- return name;
- }
-});
-
-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);
-});
-
-// property accessors are not mangleable
-AST_SymbolAccessor.DEFMETHOD("unmangleable", function(){
- return true;
-});
-
-// labels are always mangleable
-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);
- // We only need to mangle declaration nodes. Special logic wired
- // into the code generator will display the mangled name if it's
- // present (and for AST_SymbolRef-s it'll use the mangled name of
- // the AST_SymbolDeclaration that it points to).
- var lname = -1;
- var to_mangle = [];
- var tw = new TreeWalker(function(node, descend){
- if (node instanceof AST_LabeledStatement) {
- // lname is incremented when we get to the AST_Label
- var save_nesting = lname;
- descend();
- lname = save_nesting;
- return true; // don't descend again in TreeWalker
- }
- 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, // this makes a lot of noise
- 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())
- {
- // XXX: this also warns about JS standard names,
- // i.e. Object, Array, parseInt etc. Should add a list of
- // exceptions.
- 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);
-});
-
-/***********************************************************************
-
- A JavaScript tokenizer / parser / beautifier / compressor.
- https://github.com/mishoo/UglifyJS2
-
- -------------------------------- (C) ---------------------------------
-
- Author: Mihai Bazon
-
- http://mihai.bazon.net/blog
-
- Distributed under the BSD license:
-
- Copyright 2012 (c) Mihai Bazon
-
- 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.
-
- ***********************************************************************/
-
-"use strict";
-
-function OutputStream(options) {
-
- options = defaults(options, {
- indent_start : 0,
- indent_level : 4,
- quote_keys : false,
- space_colon : true,
- ascii_only : false,
- unescape_regexps : false,
- inline_script : false,
- width : 80,
- max_line_len : 32000,
- beautify : false,
- source_map : null,
- bracketize : false,
- semicolons : true,
- comments : false,
- preserve_line : false,
- screw_ie8 : false,
- preamble : null,
- }, 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 "\\x00";
- }
- 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);
- };
-
- /* -----[ beautification/minification ]----- */
-
- 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 ? 0.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("(");
- //XXX: still nice to have that for argument lists
- //var ret = with_indent(current_col, cont);
- var ret = cont();
- print(")");
- return ret;
- };
-
- function with_square(cont) {
- print("[");
- //var ret = with_indent(current_col, cont);
- 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;
- };
-
- if (options.preamble) {
- print(options.preamble.replace(/\r\n?|[\n\u2028\u2029]|\s*$/g, "\n"));
- }
-
- 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)];
- }
- };
-
-};
-
-/* -----[ code generators ]----- */
-
-(function(){
-
- /* -----[ utils ]----- */
-
- function DEFPRINT(nodetype, generator) {
- nodetype.DEFMETHOD("_codegen", generator);
- };
-
- AST_Node.DEFMETHOD("print", function(stream, force_parens){
- var self = this, generator = self._codegen;
- function doit() {
- self.add_comments(stream);
- self.add_source_map(stream);
- generator(self, stream);
- }
- stream.push_node(self);
- if (force_parens || self.needs_parens(stream)) {
- stream.with_parens(doit);
- } else {
- doit();
- }
- stream.pop_node();
- });
-
- AST_Node.DEFMETHOD("print_to_string", function(options){
- var s = OutputStream(options);
- this.print(s);
- return s.get();
- });
-
- /* -----[ comments ]----- */
-
- 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 || [];
-
- // XXX: ugly fix for https://github.com/mishoo/UglifyJS2/issues/112
- // and https://github.com/mishoo/UglifyJS2/issues/372
- if (self instanceof AST_Exit && self.value) {
- self.value.walk(new TreeWalker(function(node){
- if (node.start && node.start.comments_before) {
- comments = comments.concat(node.start.comments_before);
- node.start.comments_before = [];
- }
- if (node instanceof AST_Function ||
- node instanceof AST_Array ||
- node instanceof AST_Object)
- {
- return true; // don't go inside.
- }
- }));
- }
-
- 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 (/comment[134]/.test(c.type)) {
- 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();
- }
- }
- });
- }
- }
- });
-
- /* -----[ PARENTHESES ]----- */
-
- function PARENS(nodetype, func) {
- nodetype.DEFMETHOD("needs_parens", func);
- };
-
- PARENS(AST_Node, function(){
- return false;
- });
-
- // a function expression needs parens around it when it's provably
- // the first token to appear in a statement.
- PARENS(AST_Function, function(output){
- return first_in_statement(output);
- });
-
- // same goes for an object literal, because otherwise it would be
- // interpreted as a block of code.
- 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 // (foo, bar)() or foo(1, (2, 3), 4)
- || p instanceof AST_Unary // !(foo, bar, baz)
- || p instanceof AST_Binary // 1 + (2, 3) + 4 ==> 8
- || p instanceof AST_VarDef // var a = (1, 2), b = a + a; ==> b == 4
- || p instanceof AST_PropAccess // (1, {foo:2}).foo or (1, {foo:2})["foo"] ==> 2
- || p instanceof AST_Array // [ 1, (2, 3), 4 ] ==> [ 1, 3, 4 ]
- || p instanceof AST_ObjectProperty // { foo: (1, 2) }.foo ==> 2
- || p instanceof AST_Conditional /* (false, true) ? (a = 10, b = 20) : (c = 30)
- * ==> 20 (side effect, set a := 10 and b := 20) */
- ;
- });
-
- PARENS(AST_Binary, function(output){
- var p = output.parent();
- // (foo && bar)()
- if (p instanceof AST_Call && p.expression === this)
- return true;
- // typeof (foo && bar)
- if (p instanceof AST_Unary)
- return true;
- // (foo && bar)["prop"], (foo && bar).prop
- if (p instanceof AST_PropAccess && p.expression === this)
- return true;
- // this deals with precedence: 3 * (2 + 1)
- 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)) {
- return true;
- }
- }
- });
-
- PARENS(AST_PropAccess, function(output){
- var p = output.parent();
- if (p instanceof AST_New && p.expression === this) {
- // i.e. new (foo.bar().baz)
- //
- // if there's one call into this subtree, then we need
- // parens around it too, otherwise the call will be
- // interpreted as passing the arguments to the upper New
- // expression.
- 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(), p1;
- if (p instanceof AST_New && p.expression === this)
- return true;
-
- // workaround for Safari bug.
- // https://bugs.webkit.org/show_bug.cgi?id=123506
- return this.expression instanceof AST_Function
- && p instanceof AST_PropAccess
- && p.expression === this
- && (p1 = output.parent(1)) instanceof AST_Assign
- && p1.left === p;
- });
-
- PARENS(AST_New, function(output){
- var p = output.parent();
- if (no_constructor_parens(this, output)
- && (p instanceof AST_PropAccess // (new Date).getTime(), (new Date)["getTime"]()
- || p instanceof AST_Call && p.expression === this)) // (new foo)(bar)
- 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();
- // !(a = false) → true
- if (p instanceof AST_Unary)
- return true;
- // 1 + (a = 2) + 3 → 6, side effect setting a = 2
- if (p instanceof AST_Binary && !(p instanceof AST_Assign))
- return true;
- // (a = func)() —or— new (a = Object)()
- if (p instanceof AST_Call && p.expression === this)
- return true;
- // (a = foo) ? bar : baz
- if (p instanceof AST_Conditional && p.condition === this)
- return true;
- // (a = foo)["prop"] —or— (a = foo).prop
- 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);
-
- /* -----[ PRINTERS ]----- */
-
- DEFPRINT(AST_Directive, function(self, output){
- output.print_string(self.value);
- output.semicolon();
- });
- DEFPRINT(AST_Debugger, function(self, output){
- output.print("debugger");
- output.semicolon();
- });
-
- /* -----[ statements ]----- */
-
- 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);
+ 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) {
+ if (seqLength(seq) >= compressor.sequences_limit) push_seq();
+ var body = stat.body;
+ if (seq.length > 0) body = body.drop_side_effect_free(compressor);
+ if (body) seq.push(body);
} else {
- parenthesize_for_noin(self.init, output, true);
+ push_seq();
+ ret.push(stat);
}
- 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);
- });
-
- /* -----[ functions ]----- */
- 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);
- });
-
- /* -----[ exits ]----- */
- 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");
- });
-
- /* -----[ loop control ]----- */
- 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");
- });
+ push_seq();
+ ret = sequencesize_2(ret, compressor);
+ CHANGED = ret.length != statements.length;
+ return ret;
+ };
- /* -----[ if ]----- */
- function make_then(self, output) {
- if (output.option("bracketize")) {
- make_block(self.body, output);
- return;
- }
- // The squeezer replaces "block"-s that contain only a single
- // statement with the statement itself; technically, the AST
- // is correct, but this can create problems when we output an
- // IF having an ELSE clause where the THEN clause ends in an
- // IF *without* an ELSE block (then the outer ELSE would refer
- // to the inner IF). This function checks for this case and
- // adds the block brackets if needed.
- if (!self.body)
- return output.force_semicolon();
- if (self.body instanceof AST_Do
- && !output.option("screw_ie8")) {
- // 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
- 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;
+ function seqLength(a) {
+ for (var len = 0, i = 0; i < a.length; ++i) {
+ var stat = a[i];
+ if (stat instanceof AST_Seq) {
+ len += stat.len();
+ } else {
+ len++;
}
- 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);
- }
- });
+ return len;
+ };
- /* -----[ switch ]----- */
- 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();
+ 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.drop_side_effect_free(compressor);
+ 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).transform(compressor));
+ }
+ else if (stat instanceof AST_Switch) {
+ stat.expression = cons_seq(stat.expression);
+ }
+ }
+ ret.push(stat);
+ prev = stat instanceof AST_SimpleStatement ? stat : null;
});
- }
- });
- 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);
- });
+ 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_Var
+ && (!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;
+ }, []);
+ };
- /* -----[ exceptions ]----- */
- 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);
- });
+ };
- /* -----[ var/const ]----- */
- 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 extract_functions_from_statement_array(statements) {
+ var funs = [];
+ for (var i = statements.length - 1; i >= 0; --i) {
+ var stat = statements[i];
+ if (stat instanceof AST_Defun) {
+ statements.splice(i, 1);
+ funs.unshift(stat);
+ }
+ }
+ return funs;
+ }
- function parenthesize_for_noin(node, output, noin) {
- if (!noin) node.print(output);
- else try {
- // need to take some precautions here:
- // https://github.com/mishoo/UglifyJS2/issues/60
- 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);
+ function extract_declarations_from_unreachable_code(compressor, stat, target) {
+ if (!(stat instanceof AST_Defun)) {
+ 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;
+ }
+ }));
};
- 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);
- }
- });
+ function is_undefined(node, compressor) {
+ return node.is_undefined
+ || node instanceof AST_Undefined
+ || node instanceof AST_UnaryPrefix
+ && node.operator == "void"
+ && !node.expression.has_side_effects(compressor);
+ }
- /* -----[ other expressions ]----- */
- 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);
- });
+ // may_throw_on_access()
+ // returns true if this node may be null, undefined or contain `AST_Accessor`
+ (function(def) {
+ AST_Node.DEFMETHOD("may_throw_on_access", function(compressor) {
+ var pure_getters = compressor.option("pure_getters");
+ return !pure_getters || this._throw_on_access(pure_getters);
});
- });
- 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);
- // var p = output.parent();
- // if (p instanceof AST_Statement) {
- // output.with_indent(output.next_indent(), function(){
- // self._do_print(output);
- // });
- // } else {
- // 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(".");
- // the name after dot would be mapped about here.
- 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);
- if (self.operator == "<"
- && self.right instanceof AST_UnaryPrefix
- && self.right.operator == "!"
- && self.right.expression instanceof AST_UnaryPrefix
- && self.right.expression.operator == "--") {
- // space is mandatory to avoid outputting x -= 2
+ self.operator = self.right.operator + "=";
+ self.right = self.right.right;
+ }
+ else if (self.right.right instanceof AST_SymbolRef
+ && self.right.right.name == self.left.name
+ && member(self.right.operator, ASSIGN_OPS_COMMUTATIVE)
+ && !self.right.left.has_side_effects(compressor)) {
+ // x = 2 & x ---> x &= 2
+ self.operator = self.right.operator + "=";
+ self.right = self.right.left;
}
}
- if_break_in_loop(self, compressor);
return self;
});
- OPT(AST_If, function(self, compressor){
+ OPT(AST_Conditional, function(self, compressor){
if (!compressor.option("conditionals")) return self;
- // if condition can be statically determined, warn and drop
- // one of the blocks. note, statically determined implies
- // “has no side effects”; also it doesn't work for cases like
- // `x && true`, though it probably should.
+ 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);
- 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);
- }
+ if (cond !== self.condition) {
+ if (cond) {
+ compressor.warn("Condition always true [{file}:{line},{col}]", self.start);
+ return maintain_this_binding(compressor.parent(), self, self.consequent);
} 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);
- }
+ compressor.warn("Condition always false [{file}:{line},{col}]", self.start);
+ return maintain_this_binding(compressor.parent(), self, self.alternative);
}
}
- 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; // because we already do the switch here.
- self.condition = negated;
- var tmp = self.body;
- self.body = self.alternative || make_node(AST_EmptyStatement);
- self.alternative = tmp;
+ var negated = cond.negate(compressor, first_in_statement(compressor));
+ if (best_of(compressor, cond, negated) === negated) {
+ self = make_node(AST_Conditional, self, {
+ condition: negated,
+ consequent: self.alternative,
+ alternative: self.consequent
+ });
}
- if (is_empty(self.body) && is_empty(self.alternative)) {
- return make_node(AST_SimpleStatement, self.condition, {
- body: self.condition
- }).transform(compressor);
+ var condition = self.condition;
+ var consequent = self.consequent;
+ var alternative = self.alternative;
+ // x?x:y --> x||y
+ if (condition instanceof AST_SymbolRef
+ && consequent instanceof AST_SymbolRef
+ && condition.definition() === consequent.definition()) {
+ return make_node(AST_Binary, self, {
+ operator: "||",
+ left: condition,
+ right: alternative
+ });
}
- 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
+ // if (foo) exp = something; else exp = something_else;
+ // |
+ // v
+ // exp = foo ? something : something_else;
+ if (consequent instanceof AST_Assign
+ && alternative instanceof AST_Assign
+ && consequent.operator == alternative.operator
+ && consequent.left.equivalent_to(alternative.left)
+ && (!self.condition.has_side_effects(compressor)
+ || consequent.operator == "="
+ && !consequent.left.has_side_effects(compressor))) {
+ return 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
})
- }).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);
+ // x ? y(a) : y(b) --> y(x ? a : b)
+ if (consequent instanceof AST_Call
+ && alternative.TYPE === consequent.TYPE
+ && consequent.args.length == 1
+ && alternative.args.length == 1
+ && consequent.expression.equivalent_to(alternative.expression)
+ && !consequent.expression.has_side_effects(compressor)) {
+ consequent.args[0] = make_node(AST_Conditional, self, {
+ condition: self.condition,
+ consequent: consequent.args[0],
+ alternative: alternative.args[0]
+ });
+ return consequent;
+ }
+ // x?y?z:a:a --> x&&y?z:a
+ if (consequent instanceof AST_Conditional
+ && consequent.alternative.equivalent_to(alternative)) {
+ return make_node(AST_Conditional, self, {
+ condition: make_node(AST_Binary, self, {
+ left: self.condition,
+ operator: "&&",
+ right: consequent.condition
+ }),
+ consequent: consequent.consequent,
+ alternative: alternative
+ });
}
- 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);
+ // x ? y : y --> x, y
+ if (consequent.equivalent_to(alternative)) {
+ return make_node(AST_Seq, self, {
+ car: self.condition,
+ cdr: consequent
+ }).optimize(compressor);
+ }
+
+ if (is_true(self.consequent)) {
+ if (is_false(self.alternative)) {
+ // c ? true : false ---> !!c
+ return booleanize(self.condition);
+ }
+ // c ? true : x ---> !!c || x
+ return make_node(AST_Binary, self, {
+ operator: "||",
+ left: booleanize(self.condition),
+ right: self.alternative
+ });
+ }
+ if (is_false(self.consequent)) {
+ if (is_true(self.alternative)) {
+ // c ? false : true ---> !c
+ return booleanize(self.condition.negate(compressor));
+ }
+ // c ? false : x ---> !c && x
+ return make_node(AST_Binary, self, {
+ operator: "&&",
+ left: booleanize(self.condition.negate(compressor)),
+ right: self.alternative
+ });
+ }
+ if (is_true(self.alternative)) {
+ // c ? x : true ---> !c || x
+ return make_node(AST_Binary, self, {
+ operator: "||",
+ left: booleanize(self.condition.negate(compressor)),
+ right: self.consequent
+ });
+ }
+ if (is_false(self.alternative)) {
+ // c ? x : false ---> !!c && x
+ return make_node(AST_Binary, self, {
+ operator: "&&",
+ left: booleanize(self.condition),
+ right: self.consequent
+ });
+ }
+
+ return self;
+
+ function booleanize(node) {
+ if (node.is_boolean()) return node;
+ // !!expression
+ return make_node(AST_UnaryPrefix, node, {
+ operator: "!",
+ expression: node.negate(compressor)
+ });
+ }
+
+ // AST_True or !0
+ function is_true(node) {
+ return node instanceof AST_True
+ || (node instanceof AST_UnaryPrefix
+ && node.operator == "!"
+ && node.expression instanceof AST_Constant
+ && !node.expression.value);
}
- 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);
+ // AST_False or !1
+ function is_false(node) {
+ return node instanceof AST_False
+ || (node instanceof AST_UnaryPrefix
+ && node.operator == "!"
+ && node.expression instanceof AST_Constant
+ && !!node.expression.value);
}
- 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;
+ });
+
+ 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
+ })
+ });
}
- 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);
+ return self;
+ });
+
+ OPT(AST_Sub, function(self, compressor){
+ var prop = self.property;
+ if (prop instanceof AST_String && compressor.option("properties")) {
+ prop = prop.getValue();
+ if (RESERVED_WORDS(prop) ? compressor.option("screw_ie8") : is_identifier_string(prop)) {
+ return make_node(AST_Dot, self, {
+ expression : self.expression,
+ property : prop
+ }).optimize(compressor);
+ }
+ var v = parseFloat(prop);
+ if (!isNaN(v) && v.toString() == prop) {
+ self.property = make_node(AST_Number, self.property, {
+ value: v
+ });
}
}
- 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);
+ var ev = self.evaluate(compressor);
+ if (ev !== self) {
+ ev = make_node_from_constant(ev, self).optimize(compressor);
+ return best_of(compressor, ev, self);
}
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]; // last statement
- 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;
- }
+ OPT(AST_Dot, function(self, compressor){
+ var def = self.resolve_defines(compressor);
+ if (def) {
+ return def.optimize(compressor);
+ }
+ var prop = self.property;
+ if (RESERVED_WORDS(prop) && !compressor.option("screw_ie8")) {
+ return make_node(AST_Sub, self, {
+ expression : self.expression,
+ property : make_node(AST_String, self, {
+ value: prop
+ })
+ }).optimize(compressor);
+ }
+ if (compressor.option("unsafe_proto")
+ && self.expression instanceof AST_Dot
+ && self.expression.property == "prototype") {
+ var exp = self.expression.expression;
+ if (exp instanceof AST_SymbolRef && exp.undeclared()) switch (exp.name) {
+ case "Array":
+ self.expression = make_node(AST_Array, self.expression, {
+ elements: []
+ });
+ break;
+ case "Object":
+ self.expression = make_node(AST_Object, self.expression, {
+ properties: []
+ });
+ break;
+ case "String":
+ self.expression = make_node(AST_String, self.expression, {
+ value: ""
+ });
+ break;
}
- break;
}
- var exp = self.expression.evaluate(compressor);
- out: if (exp.length == 2) try {
- // constant expression
- 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) {
- // no need to descend these node types
- 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) {
- // got a case with non-constant expression, baling out
- 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(); // so that's able to see parent nodes
- self = self.transform(tt);
- } catch(ex) {
- if (ex !== self) throw ex;
+ var ev = self.evaluate(compressor);
+ if (ev !== self) {
+ ev = make_node_from_constant(ev, self).optimize(compressor);
+ return best_of(compressor, ev, self);
}
return self;
});
- OPT(AST_Case, function(self, compressor){
- self.body = tighten_body(self.body, compressor);
+ function literals_in_boolean_context(self, compressor) {
+ if (compressor.option("booleans") && compressor.in_boolean_context()) {
+ return best_of(compressor, self, make_node(AST_Seq, self, {
+ car: self,
+ cdr: make_node(AST_True, self)
+ }).optimize(compressor));
+ }
+ return self;
+ };
+ OPT(AST_Array, literals_in_boolean_context);
+ OPT(AST_Object, literals_in_boolean_context);
+ OPT(AST_RegExp, literals_in_boolean_context);
+
+ OPT(AST_Return, function(self, compressor){
+ if (self.value && is_undefined(self.value, compressor)) {
+ self.value = null;
+ }
return self;
});
- OPT(AST_Try, function(self, compressor){
- self.body = tighten_body(self.body, compressor);
+ OPT(AST_VarDef, function(self, compressor){
+ var defines = compressor.option("global_defs");
+ if (defines && HOP(defines, self.name.name)) {
+ compressor.warn('global_defs ' + self.name.name + ' redefined [{file}:{line},{col}]', self.start);
+ }
return self;
});
- AST_Definitions.DEFMETHOD("remove_initializers", function(){
- this.definitions.forEach(function(def){ def.value = null });
+})();
+
+/***********************************************************************
+
+ A JavaScript tokenizer / parser / beautifier / compressor.
+ https://github.com/mishoo/UglifyJS2
+
+ -------------------------------- (C) ---------------------------------
+
+ Author: Mihai Bazon
+
+ http://mihai.bazon.net/blog
+
+ Distributed under the BSD license:
+
+ Copyright 2012 (c) Mihai Bazon
+
+ 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.
+
+ ***********************************************************************/
+
+"use strict";
+
+// a small wrapper around fitzgen's source-map library
+function SourceMap(options) {
+ options = defaults(options, {
+ file : null,
+ root : null,
+ orig : null,
+
+ orig_line_diff : 0,
+ dest_line_diff : 0,
+ });
+ var generator = new MOZ_SourceMap.SourceMapGenerator({
+ file : options.file,
+ sourceRoot : options.root
});
+ var orig_map = options.orig && new MOZ_SourceMap.SourceMapConsumer(options.orig);
- 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
- }));
+ if (orig_map && Array.isArray(options.orig.sources)) {
+ orig_map._sources.toArray().forEach(function(source) {
+ var sourceContent = orig_map.sourceContentFor(source, true);
+ if (sourceContent) {
+ generator.setSourceContent(source, sourceContent);
}
- return a;
- }, []);
- if (assignments.length == 0) return null;
- return AST_Seq.from_array(assignments);
- });
+ });
+ }
+
+ 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
+ });
+ if (info.source === null) {
+ return;
+ }
+ source = info.source;
+ orig_line = info.line;
+ orig_col = info.column;
+ name = info.name || name;
+ }
+ generator.addMapping({
+ generated : { line: gen_line + options.dest_line_diff, column: gen_col },
+ original : { line: orig_line + options.orig_line_diff, column: orig_col },
+ source : source,
+ name : name
+ });
+ };
+ return {
+ add : add,
+ get : function() { return generator },
+ toString : function() { return JSON.stringify(generator.toJSON()); }
+ };
+};
+
+/***********************************************************************
+
+ A JavaScript tokenizer / parser / beautifier / compressor.
+ https://github.com/mishoo/UglifyJS2
+
+ -------------------------------- (C) ---------------------------------
+
+ Author: Mihai Bazon
+
+ http://mihai.bazon.net/blog
+
+ Distributed under the BSD license:
+
+ Copyright 2012 (c) Mihai Bazon
+
+ 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.
- 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;
- });
+"use strict";
- 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
- }).transform(compressor);
- }
- 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: ""
- });
- if (self.args.length <= 1) return make_node(AST_Binary, self, {
- left: self.args[0],
- operator: "+",
- right: make_node(AST_String, self, { value: "" })
- }).transform(compressor);
- break;
- case "Number":
- if (self.args.length == 0) return make_node(AST_Number, self, {
- value: 0
- });
- if (self.args.length == 1) return make_node(AST_UnaryPrefix, self, {
- expression: self.args[0],
- operator: "+"
- }).transform(compressor);
- case "Boolean":
- if (self.args.length == 0) return make_node(AST_False, self);
- if (self.args.length == 1) return make_node(AST_UnaryPrefix, self, {
- expression: make_node(AST_UnaryPrefix, null, {
- expression: self.args[0],
- operator: "!"
- }),
- operator: "!"
- }).transform(compressor);
- break;
- case "Function":
- if (all(self.args, function(x){ return x instanceof AST_String })) {
- // quite a corner-case, but we can handle it:
- // https://github.com/mishoo/UglifyJS2/issues/203
- // if the code argument is a constant, then we can minify it.
- 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({ screw_ie8: compressor.option("screw_ie8") });
- var comp = new Compressor(compressor.options);
- ast = ast.transform(comp);
- ast.figure_out_scope({ screw_ie8: compressor.option("screw_ie8") });
- ast.mangle_names();
- var fun;
- try {
- ast.walk(new TreeWalker(function(node){
- if (node instanceof AST_Lambda) {
- fun = node;
- throw ast;
- }
- }));
- } catch(ex) {
- if (ex !== ast) throw ex;
- };
- 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);
- throw 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);
- }
- else if (exp instanceof AST_Dot && exp.expression instanceof AST_Array && exp.property == "join") EXIT: {
- var separator = self.args.length == 0 ? "," : self.args[0].evaluate(compressor)[1];
- if (separator == null) break EXIT; // not a constant
- var elements = exp.expression.elements.reduce(function(a, el){
- el = el.evaluate(compressor);
- if (a.length == 0 || el.length == 1) {
- a.push(el);
- } else {
- var last = a[a.length - 1];
- if (last.length == 2) {
- // it's a constant
- var val = "" + last[1] + separator + el[1];
- a[a.length - 1] = [ make_node_from_constant(compressor, val, last[0]), val ];
- } else {
- a.push(el);
- }
- }
- return a;
- }, []);
- if (elements.length == 0) return make_node(AST_String, self, { value: "" });
- if (elements.length == 1) return elements[0][0];
- if (separator == "") {
- var first;
- if (elements[0][0] instanceof AST_String
- || elements[1][0] instanceof AST_String) {
- first = elements.shift()[0];
- } else {
- first = make_node(AST_String, self, { value: "" });
- }
- return elements.reduce(function(prev, el){
- return make_node(AST_Binary, el[0], {
- operator : "+",
- left : prev,
- right : el[0],
- });
- }, first).transform(compressor);
- }
- // need this awkward cloning to not affect original element
- // best_of will decide which one to get through.
- var node = self.clone();
- node.expression = node.expression.clone();
- node.expression.expression = node.expression.expression.clone();
- node.expression.expression.elements = elements.map(function(el){
- return el[0];
+(function(){
+
+ var normalize_directives = function(body) {
+ var in_directive = true;
+
+ for (var i = 0; i < body.length; i++) {
+ if (in_directive && body[i] instanceof AST_Statement && body[i].body instanceof AST_String) {
+ body[i] = new AST_Directive({
+ start: body[i].start,
+ end: body[i].end,
+ value: body[i].body.value
});
- return best_of(self, node);
+ } else if (in_directive && !(body[i] instanceof AST_Statement && body[i].body instanceof AST_String)) {
+ in_directive = false;
}
}
- if (compressor.option("side_effects")) {
- if (self.expression instanceof AST_Function
- && self.args.length == 0
- && !AST_Block.prototype.has_side_effects.call(self.expression, compressor)) {
- return make_node(AST_Undefined, self).transform(compressor);
+
+ return body;
+ };
+
+ var MOZ_TO_ME = {
+ Program: function(M) {
+ return new AST_Toplevel({
+ start: my_start_token(M),
+ end: my_end_token(M),
+ body: normalize_directives(M.body.map(from_moz))
+ });
+ },
+ FunctionDeclaration: function(M) {
+ return new AST_Defun({
+ start: my_start_token(M),
+ end: my_end_token(M),
+ name: from_moz(M.id),
+ argnames: M.params.map(from_moz),
+ body: normalize_directives(from_moz(M.body).body)
+ });
+ },
+ FunctionExpression: function(M) {
+ return new AST_Function({
+ start: my_start_token(M),
+ end: my_end_token(M),
+ name: from_moz(M.id),
+ argnames: M.params.map(from_moz),
+ body: normalize_directives(from_moz(M.body).body)
+ });
+ },
+ ExpressionStatement: function(M) {
+ return new AST_SimpleStatement({
+ start: my_start_token(M),
+ end: my_end_token(M),
+ body: from_moz(M.expression)
+ });
+ },
+ TryStatement: function(M) {
+ var handlers = M.handlers || [M.handler];
+ if (handlers.length > 1 || M.guardedHandlers && M.guardedHandlers.length) {
+ throw new Error("Multiple catch clauses are not supported.");
}
- }
- if (compressor.option("drop_console")) {
- if (self.expression instanceof AST_PropAccess &&
- self.expression.expression instanceof AST_SymbolRef &&
- self.expression.expression.name == "console" &&
- self.expression.expression.undeclared()) {
- return make_node(AST_Undefined, self).transform(compressor);
+ return new AST_Try({
+ start : my_start_token(M),
+ end : my_end_token(M),
+ body : from_moz(M.block).body,
+ bcatch : from_moz(handlers[0]),
+ bfinally : M.finalizer ? new AST_Finally(from_moz(M.finalizer)) : null
+ });
+ },
+ Property: function(M) {
+ var key = M.key;
+ var args = {
+ start : my_start_token(key),
+ end : my_end_token(M.value),
+ key : key.type == "Identifier" ? key.name : key.value,
+ value : from_moz(M.value)
+ };
+ if (M.kind == "init") return new AST_ObjectKeyVal(args);
+ args.key = new AST_SymbolAccessor({
+ name: args.key
+ });
+ args.value = new AST_Accessor(args.value);
+ if (M.kind == "get") return new AST_ObjectGetter(args);
+ if (M.kind == "set") return new AST_ObjectSetter(args);
+ },
+ ArrayExpression: function(M) {
+ return new AST_Array({
+ start : my_start_token(M),
+ end : my_end_token(M),
+ elements : M.elements.map(function(elem){
+ return elem === null ? new AST_Hole() : from_moz(elem);
+ })
+ });
+ },
+ ObjectExpression: function(M) {
+ return new AST_Object({
+ start : my_start_token(M),
+ end : my_end_token(M),
+ properties : M.properties.map(function(prop){
+ prop.type = "Property";
+ return from_moz(prop)
+ })
+ });
+ },
+ 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)
+ });
+ },
+ VariableDeclaration: function(M) {
+ return new (M.kind === "const" ? AST_Const : AST_Var)({
+ start : my_start_token(M),
+ end : my_end_token(M),
+ definitions : M.declarations.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:
+ var rx = M.regex;
+ if (rx && rx.pattern) {
+ // RegExpLiteral as per ESTree AST spec
+ args.value = new RegExp(rx.pattern, rx.flags).toString();
+ } else {
+ // support legacy RegExp
+ args.value = M.regex && M.raw ? M.raw : val;
+ }
+ return new AST_RegExp(args);
}
+ },
+ Identifier: function(M) {
+ var p = FROM_MOZ_STACK[FROM_MOZ_STACK.length - 2];
+ return new ( 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
+ });
}
- return self.evaluate(compressor)[0];
+ };
+
+ MOZ_TO_ME.UpdateExpression =
+ MOZ_TO_ME.UnaryExpression = function To_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)
+ });
+ };
+
+ map("EmptyStatement", AST_EmptyStatement);
+ map("BlockStatement", AST_BlockStatement, "body@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("VariableDeclarator", AST_VarDef, "id>name, init>value");
+ map("CatchClause", AST_Catch, "param>argname, body%body");
+
+ map("ThisExpression", AST_This);
+ map("BinaryExpression", AST_Binary, "operator=operator, left>left, right>right");
+ map("LogicalExpression", AST_Binary, "operator=operator, left>left, right>right");
+ map("AssignmentExpression", AST_Assign, "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");
+
+ def_to_moz(AST_Toplevel, function To_Moz_Program(M) {
+ return to_moz_scope("Program", M);
});
- 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);
- }
- }
+ def_to_moz(AST_Defun, function To_Moz_FunctionDeclaration(M) {
+ return {
+ type: "FunctionDeclaration",
+ id: to_moz(M.name),
+ params: M.argnames.map(to_moz),
+ body: to_moz_scope("BlockStatement", M)
}
- return self;
});
- OPT(AST_Seq, function(self, compressor){
- if (!compressor.option("side_effects"))
- return self;
- if (!self.car.has_side_effects(compressor)) {
- // we shouldn't compress (1,eval)(something) to
- // eval(something) because that changes the meaning of
- // eval (becomes lexical instead of global).
- 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(compressor)) {
- if (self.car.left.equivalent_to(self.cdr)) {
- return self.car;
- }
- if (self.cdr instanceof AST_Call
- && self.cdr.expression.equivalent_to(self.car.left)) {
- self.cdr.expression = self.car;
- return self.cdr;
- }
- }
- if (!self.car.has_side_effects(compressor)
- && !self.cdr.has_side_effects(compressor)
- && self.car.equivalent_to(self.cdr)) {
- return self.car;
- }
- }
- if (self.cdr instanceof AST_UnaryPrefix
- && self.cdr.operator == "void"
- && !self.cdr.expression.has_side_effects(compressor)) {
- self.cdr.operator = self.car;
- return self.cdr;
- }
- if (self.cdr instanceof AST_Undefined) {
- return make_node(AST_UnaryPrefix, self, {
- operator : "void",
- expression : self.car
- });
+ def_to_moz(AST_Function, function To_Moz_FunctionExpression(M) {
+ return {
+ type: "FunctionExpression",
+ id: to_moz(M.name),
+ params: M.argnames.map(to_moz),
+ body: to_moz_scope("BlockStatement", M)
}
- 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;
+ def_to_moz(AST_Directive, function To_Moz_Directive(M) {
+ return {
+ type: "ExpressionStatement",
+ expression: {
+ type: "Literal",
+ value: M.value
}
- }
- return this;
+ };
});
- OPT(AST_UnaryPostfix, function(self, compressor){
- return self.lift_sequences(compressor);
+ def_to_moz(AST_SimpleStatement, function To_Moz_ExpressionStatement(M) {
+ return {
+ type: "ExpressionStatement",
+ expression: to_moz(M.body)
+ };
});
- 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 == "!") {
- // !!foo ==> foo, if we're in boolean context
- return e.expression;
- }
- break;
- case "typeof":
- // typeof always returns a non-empty string, thus it's
- // always true in booleans
- 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];
+ def_to_moz(AST_SwitchBranch, function To_Moz_SwitchCase(M) {
+ return {
+ type: "SwitchCase",
+ test: to_moz(M.expression),
+ consequent: M.body.map(to_moz)
+ };
});
- function has_side_effects_or_prop_access(node, compressor) {
- var save_pure_getters = compressor.option("pure_getters");
- compressor.options.pure_getters = false;
- var ret = node.has_side_effects(compressor);
- compressor.options.pure_getters = save_pure_getters;
- return ret;
- }
+ def_to_moz(AST_Try, function To_Moz_TryStatement(M) {
+ return {
+ type: "TryStatement",
+ block: to_moz_block(M),
+ handler: to_moz(M.bcatch),
+ guardedHandlers: [],
+ finalizer: to_moz(M.bfinally)
+ };
+ });
- 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 instanceof AST_Assign
- && !has_side_effects_or_prop_access(this.left, compressor)) {
- 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;
+ def_to_moz(AST_Catch, function To_Moz_CatchClause(M) {
+ return {
+ type: "CatchClause",
+ param: to_moz(M.argname),
+ guard: null,
+ body: to_moz_block(M)
+ };
});
- var commutativeOperators = makePredicate("== === != !== * & | ^");
+ def_to_moz(AST_Definitions, function To_Moz_VariableDeclaration(M) {
+ return {
+ type: "VariableDeclaration",
+ kind: M instanceof AST_Const ? "const" : "var",
+ declarations: M.definitions.map(to_moz)
+ };
+ });
- OPT(AST_Binary, function(self, compressor){
- var reverse = compressor.has_directive("use asm") ? noop
- : function(op, force) {
- if (force || !(self.left.has_side_effects(compressor) || self.right.has_side_effects(compressor))) {
- 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)) {
- // if right is a constant, whatever side effects the
- // left side might have could not influence the
- // result. hence, force switch.
+ def_to_moz(AST_Seq, function To_Moz_SequenceExpression(M) {
+ return {
+ type: "SequenceExpression",
+ expressions: M.to_array().map(to_moz)
+ };
+ });
- if (!(self.left instanceof AST_Binary
- && PRECEDENCE[self.left.operator] >= PRECEDENCE[self.operator])) {
- reverse(null, true);
- }
- }
- if (/^[!=]==?$/.test(self.operator)) {
- if (self.left instanceof AST_SymbolRef && self.right instanceof AST_Conditional) {
- if (self.right.consequent instanceof AST_SymbolRef
- && self.right.consequent.definition() === self.left.definition()) {
- if (/^==/.test(self.operator)) return self.right.condition;
- if (/^!=/.test(self.operator)) return self.right.condition.negate(compressor);
- }
- if (self.right.alternative instanceof AST_SymbolRef
- && self.right.alternative.definition() === self.left.definition()) {
- if (/^==/.test(self.operator)) return self.right.condition.negate(compressor);
- if (/^!=/.test(self.operator)) return self.right.condition;
- }
- }
- if (self.right instanceof AST_SymbolRef && self.left instanceof AST_Conditional) {
- if (self.left.consequent instanceof AST_SymbolRef
- && self.left.consequent.definition() === self.right.definition()) {
- if (/^==/.test(self.operator)) return self.left.condition;
- if (/^!=/.test(self.operator)) return self.left.condition.negate(compressor);
- }
- if (self.left.alternative instanceof AST_SymbolRef
- && self.left.alternative.definition() === self.right.definition()) {
- if (/^==/.test(self.operator)) return self.left.condition.negate(compressor);
- if (/^!=/.test(self.operator)) return self.left.condition;
- }
- }
- }
- }
- 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);
- }
- // XXX: intentionally falling down to the next case
- 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;
- }
- 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;
- }
- if (compressor.option("evaluate")) {
- if (self.operator == "+") {
- if (self.left instanceof AST_Constant
- && self.right instanceof AST_Binary
- && self.right.operator == "+"
- && self.right.left instanceof AST_Constant
- && self.right.is_string(compressor)) {
- self = make_node(AST_Binary, self, {
- operator: "+",
- left: make_node(AST_String, null, {
- value: "" + self.left.getValue() + self.right.left.getValue(),
- start: self.left.start,
- end: self.right.left.end
- }),
- right: self.right.right
- });
- }
- if (self.right instanceof AST_Constant
- && self.left instanceof AST_Binary
- && self.left.operator == "+"
- && self.left.right instanceof AST_Constant
- && self.left.is_string(compressor)) {
- self = make_node(AST_Binary, self, {
- operator: "+",
- left: self.left.left,
- right: make_node(AST_String, null, {
- value: "" + self.left.right.getValue() + self.right.getValue(),
- start: self.left.right.start,
- end: self.right.end
- })
- });
- }
- if (self.left instanceof AST_Binary
- && self.left.operator == "+"
- && self.left.is_string(compressor)
- && self.left.right instanceof AST_Constant
- && self.right instanceof AST_Binary
- && self.right.operator == "+"
- && self.right.left instanceof AST_Constant
- && self.right.is_string(compressor)) {
- self = make_node(AST_Binary, self, {
- operator: "+",
- left: make_node(AST_Binary, self.left, {
- operator: "+",
- left: self.left.left,
- right: make_node(AST_String, null, {
- value: "" + self.left.right.getValue() + self.right.left.getValue(),
- start: self.left.right.start,
- end: self.right.left.end
- })
- }),
- right: self.right.right
- });
- }
- }
- }
- // x * (y * z) ==> x * y * z
- if (self.right instanceof AST_Binary
- && self.right.operator == self.operator
- && (self.operator == "*" || self.operator == "&&" || self.operator == "||"))
- {
- self.left = make_node(AST_Binary, self.left, {
- operator : self.operator,
- left : self.left,
- right : self.right.left
- });
- self.right = self.right.right;
- return self.transform(compressor);
- }
- return self.evaluate(compressor)[0];
+ def_to_moz(AST_PropAccess, function To_Moz_MemberExpression(M) {
+ var isComputed = M instanceof AST_Sub;
+ return {
+ type: "MemberExpression",
+ object: to_moz(M.expression),
+ computed: isComputed,
+ property: isComputed ? to_moz(M.property) : {type: "Identifier", name: M.property}
+ };
});
- 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;
+ def_to_moz(AST_Unary, function To_Moz_Unary(M) {
+ return {
+ type: M.operator == "++" || M.operator == "--" ? "UpdateExpression" : "UnaryExpression",
+ operator: M.operator,
+ prefix: M instanceof AST_UnaryPrefix,
+ argument: to_moz(M.expression)
+ };
+ });
+
+ def_to_moz(AST_Binary, function To_Moz_BinaryExpression(M) {
+ return {
+ type: M.operator == "&&" || M.operator == "||" ? "LogicalExpression" : "BinaryExpression",
+ left: to_moz(M.left),
+ operator: M.operator,
+ right: to_moz(M.right)
+ };
+ });
+
+ def_to_moz(AST_Array, function To_Moz_ArrayExpression(M) {
+ return {
+ type: "ArrayExpression",
+ elements: M.elements.map(to_moz)
+ };
});
- 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;
+ def_to_moz(AST_Object, function To_Moz_ObjectExpression(M) {
+ return {
+ type: "ObjectExpression",
+ properties: M.properties.map(to_moz)
+ };
});
- 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;
+ def_to_moz(AST_ObjectProperty, function To_Moz_Property(M) {
+ var key = {
+ type: "Literal",
+ value: M.key instanceof AST_SymbolAccessor ? M.key.name : M.key
+ };
+ var kind;
+ if (M instanceof AST_ObjectKeyVal) {
+ kind = "init";
+ } else
+ if (M instanceof AST_ObjectGetter) {
+ kind = "get";
+ } else
+ if (M instanceof AST_ObjectSetter) {
+ kind = "set";
}
- return self;
+ return {
+ type: "Property",
+ kind: kind,
+ key: key,
+ value: to_moz(M.value)
+ };
});
- 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)
- ) {
- /*
- * Stuff like this:
- * if (foo) exp = something; else exp = something_else;
- * ==>
- * exp = foo ? something : something_else;
- */
- return 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
- })
- });
- }
- if (consequent instanceof AST_Call
- && alternative.TYPE === consequent.TYPE
- && consequent.args.length == alternative.args.length
- && consequent.expression.equivalent_to(alternative.expression)) {
- if (consequent.args.length == 0) {
- return make_node(AST_Seq, self, {
- car: self.condition,
- cdr: consequent
- });
- }
- if (consequent.args.length == 1) {
- consequent.args[0] = make_node(AST_Conditional, self, {
- condition: self.condition,
- consequent: consequent.args[0],
- alternative: alternative.args[0]
- });
- return consequent;
- }
- }
- return self;
+ def_to_moz(AST_Symbol, function To_Moz_Identifier(M) {
+ var def = M.definition();
+ return {
+ type: "Identifier",
+ name: def ? def.mangled_name || def.name : M.name
+ };
});
- 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
- });
+ def_to_moz(AST_RegExp, function To_Moz_RegExpLiteral(M) {
+ var value = M.value;
+ return {
+ type: "Literal",
+ value: value,
+ raw: value.toString(),
+ regex: {
+ pattern: value.source,
+ flags: value.toString().match(/[gimuy]*$/)[0]
}
- 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 (RESERVED_WORDS(prop) ? compressor.option("screw_ie8") : is_identifier_string(prop)) {
- return make_node(AST_Dot, self, {
- expression : self.expression,
- property : prop
- });
- }
- var v = parseFloat(prop);
- if (!isNaN(v) && v.toString() == prop) {
- self.property = make_node(AST_Number, self.property, {
- value: v
- });
- }
+ def_to_moz(AST_Constant, function To_Moz_Literal(M) {
+ var value = M.value;
+ if (typeof value === 'number' && (value < 0 || (value === 0 && 1 / value < 0))) {
+ return {
+ type: "UnaryExpression",
+ operator: "-",
+ prefix: true,
+ argument: {
+ type: "Literal",
+ value: -value,
+ raw: M.start.raw
+ }
+ };
}
- return self;
+ return {
+ type: "Literal",
+ value: value,
+ raw: M.start.raw
+ };
});
- 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);
+ def_to_moz(AST_Atom, function To_Moz_Atom(M) {
+ return {
+ type: "Identifier",
+ name: String(M.value)
+ };
+ });
-})();
+ AST_Boolean.DEFMETHOD("to_mozilla_ast", AST_Constant.prototype.to_mozilla_ast);
+ AST_Null.DEFMETHOD("to_mozilla_ast", AST_Constant.prototype.to_mozilla_ast);
+ AST_Hole.DEFMETHOD("to_mozilla_ast", function To_Moz_ArrayHole() { return null });
-/***********************************************************************
+ AST_Block.DEFMETHOD("to_mozilla_ast", AST_BlockStatement.prototype.to_mozilla_ast);
+ AST_Lambda.DEFMETHOD("to_mozilla_ast", AST_Function.prototype.to_mozilla_ast);
- A JavaScript tokenizer / parser / beautifier / compressor.
- https://github.com/mishoo/UglifyJS2
+ /* -----[ tools ]----- */
- -------------------------------- (C) ---------------------------------
+ function raw_token(moznode) {
+ if (moznode.type == "Literal") {
+ return moznode.raw != null ? moznode.raw : moznode.value + "";
+ }
+ }
- Author: Mihai Bazon
-
- http://mihai.bazon.net/blog
+ function my_start_token(moznode) {
+ var loc = moznode.loc, start = loc && loc.start;
+ var range = moznode.range;
+ return new AST_Token({
+ file : loc && loc.source,
+ line : start && start.line,
+ col : start && start.column,
+ pos : range ? range[0] : moznode.start,
+ endline : start && start.line,
+ endcol : start && start.column,
+ endpos : range ? range[0] : moznode.start,
+ raw : raw_token(moznode),
+ });
+ };
- Distributed under the BSD license:
+ function my_end_token(moznode) {
+ var loc = moznode.loc, end = loc && loc.end;
+ var range = moznode.range;
+ return new AST_Token({
+ file : loc && loc.source,
+ line : end && end.line,
+ col : end && end.column,
+ pos : range ? range[1] : moznode.end,
+ endline : end && end.line,
+ endcol : end && end.column,
+ endpos : range ? range[1] : moznode.end,
+ raw : raw_token(moznode),
+ });
+ };
- Copyright 2012 (c) Mihai Bazon
+ function map(moztype, mytype, propmap) {
+ var moz_to_me = "function From_Moz_" + moztype + "(M){\n";
+ moz_to_me += "return new U2." + mytype.name + "({\n" +
+ "start: my_start_token(M),\n" +
+ "end: my_end_token(M)";
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions
- are met:
+ var me_to_moz = "function To_Moz_" + moztype + "(M){\n";
+ me_to_moz += "return {\n" +
+ "type: " + JSON.stringify(moztype);
- * Redistributions of source code must retain the above
- copyright notice, this list of conditions and the following
- disclaimer.
+ 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[1], how = m[2], my = m[3];
+ moz_to_me += ",\n" + my + ": ";
+ me_to_moz += ",\n" + moz + ": ";
+ switch (how) {
+ case "@":
+ moz_to_me += "M." + moz + ".map(from_moz)";
+ me_to_moz += "M." + my + ".map(to_moz)";
+ break;
+ case ">":
+ moz_to_me += "from_moz(M." + moz + ")";
+ me_to_moz += "to_moz(M." + my + ")";
+ break;
+ case "=":
+ moz_to_me += "M." + moz;
+ me_to_moz += "M." + my;
+ break;
+ case "%":
+ moz_to_me += "from_moz(M." + moz + ").body";
+ me_to_moz += "to_moz_block(M)";
+ break;
+ default:
+ throw new Error("Can't understand operator in propmap: " + prop);
+ }
+ });
- * 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.
+ moz_to_me += "\n})\n}";
+ me_to_moz += "\n}\n}";
- 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.
+ //moz_to_me = parse(moz_to_me).print_to_string({ beautify: true });
+ //me_to_moz = parse(me_to_moz).print_to_string({ beautify: true });
+ //console.log(moz_to_me);
- ***********************************************************************/
+ moz_to_me = new Function("U2", "my_start_token", "my_end_token", "from_moz", "return(" + moz_to_me + ")")(
+ exports, my_start_token, my_end_token, from_moz
+ );
+ me_to_moz = new Function("to_moz", "to_moz_block", "to_moz_scope", "return(" + me_to_moz + ")")(
+ to_moz, to_moz_block, to_moz_scope
+ );
+ MOZ_TO_ME[moztype] = moz_to_me;
+ def_to_moz(mytype, me_to_moz);
+ };
-"use strict";
+ var FROM_MOZ_STACK = null;
-// a small wrapper around fitzgen's source-map library
-function SourceMap(options) {
- options = defaults(options, {
- file : null,
- root : null,
- orig : 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;
+ };
- orig_line_diff : 0,
- dest_line_diff : 0,
- });
- 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;
+ 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;
+ };
+
+ function set_moz_loc(mynode, moznode, myparent) {
+ var start = mynode.start;
+ var end = mynode.end;
+ if (start.pos != null && end.endpos != null) {
+ moznode.range = [start.pos, end.endpos];
}
- generator.addMapping({
- generated : { line: gen_line + options.dest_line_diff, column: gen_col },
- original : { line: orig_line + options.orig_line_diff, column: orig_col },
- source : source,
- name : name
+ if (start.line) {
+ moznode.loc = {
+ start: {line: start.line, column: start.col},
+ end: end.endline ? {line: end.endline, column: end.endcol} : null
+ };
+ if (start.file) {
+ moznode.loc.source = start.file;
+ }
+ }
+ return moznode;
+ };
+
+ function def_to_moz(mytype, handler) {
+ mytype.DEFMETHOD("to_mozilla_ast", function() {
+ return set_moz_loc(this, handler(this));
});
};
- return {
- add : add,
- get : function() { return generator },
- toString : function() { return generator.toString() }
+
+ function to_moz(node) {
+ return node != null ? node.to_mozilla_ast() : null;
};
-};
+
+ function to_moz_block(node) {
+ return {
+ type: "BlockStatement",
+ body: node.body.map(to_moz)
+ };
+ };
+
+ function to_moz_scope(type, node) {
+ var body = node.body.map(to_moz);
+ if (node.body[0] instanceof AST_SimpleStatement && node.body[0].body instanceof AST_String) {
+ body.unshift(to_moz(new AST_EmptyStatement(node.body[0])));
+ }
+ return {
+ type: type,
+ body: body
+ };
+ };
+})();
/***********************************************************************
@@ -22344,300 +24426,393 @@ function SourceMap(options) {
"use strict";
-(function(){
+function find_builtins() {
+ // NaN will be included due to Number.NaN
+ var a = [
+ "null",
+ "true",
+ "false",
+ "Infinity",
+ "-Infinity",
+ "undefined",
+ ];
+ [ Object, Array, Function, Number,
+ String, Boolean, Error, Math,
+ Date, RegExp
+ ].forEach(function(ctor){
+ Object.getOwnPropertyNames(ctor).map(add);
+ if (ctor.prototype) {
+ Object.getOwnPropertyNames(ctor.prototype).map(add);
+ }
+ });
+ function add(name) {
+ push_uniq(a, name);
+ }
+ return a;
+}
- 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 mangle_properties(ast, options) {
+ options = defaults(options, {
+ cache: null,
+ debug: false,
+ ignore_quoted: false,
+ only_cache: false,
+ regex: null,
+ reserved: null,
+ });
+
+ var reserved = options.reserved;
+ if (reserved == null)
+ reserved = find_builtins();
+
+ var cache = options.cache;
+ if (cache == null) {
+ cache = {
+ cname: -1,
+ props: new Dictionary()
+ };
+ }
+
+ var regex = options.regex;
+ var ignore_quoted = options.ignore_quoted;
+
+ // note debug is either false (disabled), or a string of the debug suffix to use (enabled).
+ // note debug may be enabled as an empty string, which is falsey. Also treat passing 'true'
+ // the same as passing an empty string.
+ var debug = (options.debug !== false);
+ var debug_name_suffix;
+ if (debug) {
+ debug_name_suffix = (options.debug === true ? "" : options.debug);
+ }
+
+ var names_to_mangle = [];
+ var unmangleable = [];
+ var ignored = {};
+
+ // step 1: find candidates to mangle
+ ast.walk(new TreeWalker(function(node){
+ if (node instanceof AST_ObjectKeyVal) {
+ add(node.key, ignore_quoted && node.quote);
}
- };
+ else if (node instanceof AST_ObjectProperty) {
+ // setter or getter, since KeyVal is handled above
+ add(node.key.name);
+ }
+ else if (node instanceof AST_Dot) {
+ add(node.property);
+ }
+ else if (node instanceof AST_Sub) {
+ addStrings(node.property, ignore_quoted);
+ }
+ }));
- 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)
- });
- };
+ // step 2: transform the tree, renaming properties
+ return ast.transform(new TreeTransformer(function(node){
+ if (node instanceof AST_ObjectKeyVal) {
+ if (!(ignore_quoted && node.quote))
+ node.key = mangle(node.key);
+ }
+ else if (node instanceof AST_ObjectProperty) {
+ // setter or getter
+ node.key.name = mangle(node.key.name);
+ }
+ else if (node instanceof AST_Dot) {
+ node.property = mangle(node.property);
+ }
+ else if (node instanceof AST_Sub) {
+ if (!ignore_quoted)
+ node.property = mangleStrings(node.property);
+ }
+ // else if (node instanceof AST_String) {
+ // if (should_mangle(node.value)) {
+ // AST_Node.warn(
+ // "Found \"{prop}\" property candidate for mangling in an arbitrary string [{file}:{line},{col}]", {
+ // file : node.start.file,
+ // line : node.start.line,
+ // col : node.start.col,
+ // prop : node.value
+ // }
+ // );
+ // }
+ // }
+ }));
- var ME_TO_MOZ = {};
+ // only function declarations after this line
- 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");
+ function can_mangle(name) {
+ if (unmangleable.indexOf(name) >= 0) return false;
+ if (reserved.indexOf(name) >= 0) return false;
+ if (options.only_cache) {
+ return cache.props.has(name);
+ }
+ if (/^-?[0-9]+(\.[0-9]+)?(e[+-][0-9]+)?$/.test(name)) return false;
+ return true;
+ }
- 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 should_mangle(name) {
+ if (ignore_quoted && name in ignored) return false;
+ if (regex && !regex.test(name)) return false;
+ if (reserved.indexOf(name) >= 0) return false;
+ return cache.props.has(name)
+ || names_to_mangle.indexOf(name) >= 0;
+ }
- /* -----[ tools ]----- */
+ function add(name, ignore) {
+ if (ignore) {
+ ignored[name] = true;
+ return;
+ }
- 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
- });
- };
+ if (can_mangle(name))
+ push_uniq(names_to_mangle, name);
- 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
- });
- };
+ if (!should_mangle(name)) {
+ push_uniq(unmangleable, name);
+ }
+ }
- 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)";
+ function mangle(name) {
+ if (!should_mangle(name)) {
+ return name;
+ }
- 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})}";
+ var mangled = cache.props.get(name);
+ if (!mangled) {
+ if (debug) {
+ // debug mode: use a prefix and suffix to preserve readability, e.g. o.foo -> o._$foo$NNN_.
+ var debug_mangled = "_$" + name + "$" + debug_name_suffix + "_";
- // moz_to_me = parse(moz_to_me).print_to_string({ beautify: true });
- // console.log(moz_to_me);
+ if (can_mangle(debug_mangled) && !(ignore_quoted && debug_mangled in ignored)) {
+ mangled = debug_mangled;
+ }
+ }
- 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;
- };
+ // either debug mode is off, or it is on and we could not use the mangled name
+ if (!mangled) {
+ // note can_mangle() does not check if the name collides with the 'ignored' set
+ // (filled with quoted properties when ignore_quoted set). Make sure we add this
+ // check so we don't collide with a quoted name.
+ do {
+ mangled = base54(++cache.cname);
+ } while (!can_mangle(mangled) || (ignore_quoted && mangled in ignored));
+ }
- var FROM_MOZ_STACK = null;
+ cache.props.set(name, mangled);
+ }
+ return mangled;
+ }
- 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;
- };
+ function addStrings(node, ignore) {
+ var out = {};
+ try {
+ (function walk(node){
+ node.walk(new TreeWalker(function(node){
+ if (node instanceof AST_Seq) {
+ walk(node.cdr);
+ return true;
+ }
+ if (node instanceof AST_String) {
+ add(node.value, ignore);
+ return true;
+ }
+ if (node instanceof AST_Conditional) {
+ walk(node.consequent);
+ walk(node.alternative);
+ return true;
+ }
+ throw out;
+ }));
+ })(node);
+ } catch(ex) {
+ if (ex !== out) throw ex;
+ }
+ }
- 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;
- };
+ function mangleStrings(node) {
+ return node.transform(new TreeTransformer(function(node){
+ if (node instanceof AST_Seq) {
+ node.cdr = mangleStrings(node.cdr);
+ }
+ else if (node instanceof AST_String) {
+ node.value = mangle(node.value);
+ }
+ else if (node instanceof AST_Conditional) {
+ node.consequent = mangleStrings(node.consequent);
+ node.alternative = mangleStrings(node.alternative);
+ }
+ return node;
+ }));
+ }
-})();
+}
+
+exports["Compressor"] = Compressor;
+exports["DefaultsError"] = DefaultsError;
+exports["Dictionary"] = Dictionary;
+exports["JS_Parse_Error"] = JS_Parse_Error;
+exports["MAP"] = MAP;
+exports["OutputStream"] = OutputStream;
+exports["SourceMap"] = SourceMap;
+exports["TreeTransformer"] = TreeTransformer;
+exports["TreeWalker"] = TreeWalker;
+exports["base54"] = base54;
+exports["defaults"] = defaults;
+exports["mangle_properties"] = mangle_properties;
+exports["merge"] = merge;
+exports["parse"] = parse;
+exports["push_uniq"] = push_uniq;
+exports["string_template"] = string_template;
+exports["tokenizer"] = tokenizer;
+exports["is_identifier"] = is_identifier;
+exports["SymbolDef"] = SymbolDef;
+
+AST_Node.warn_function = function(txt) { logger.error("uglifyjs WARN: " + txt); };
+
+exports.AST_Node.warn_function = function(txt) {
+ console.error("WARN: %s", txt);
+};
+
+function read_source_map(code) {
+ var match = /\n\/\/# sourceMappingURL=data:application\/json(;.*?)?;base64,(.*)/.exec(code);
+ if (!match) {
+ exports.AST_Node.warn("inline source map not found");
+ return null;
+ }
+ return JSON.parse(new Buffer(match[2], "base64"));
+}
-AST_Node.warn_function = function(txt) { logger.error("uglifyjs2 WARN: " + txt); };
exports.minify = function(files, options, name) {
- options = defaults(options, {
- spidermonkey : false,
- outSourceMap : null,
- sourceRoot : null,
- inSourceMap : null,
- fromString : false,
- warnings : false,
- mangle : {},
- output : null,
- compress : {}
+ options = exports.defaults(options, {
+ compress : {},
+ fromString : false,
+ inSourceMap : null,
+ mangle : {},
+ mangleProperties : false,
+ nameCache : null,
+ outFileName : null,
+ output : null,
+ outSourceMap : null,
+ parse : {},
+ sourceMapInline : false,
+ sourceMapUrl : null,
+ sourceRoot : null,
+ spidermonkey : false,
+ warnings : false,
});
- base54.reset();
+ exports.base54.reset();
+
+ var inMap = options.inSourceMap;
+ if (typeof inMap == "string" && inMap != "inline") {
+ inMap = JSON.parse(rjsFile.readFile(inMap, "utf8"));
+ }
// 1. parse
- var toplevel = null;
+ var toplevel = null,
+ sourcesContent = {};
if (options.spidermonkey) {
- toplevel = AST_Node.from_mozilla_ast(files);
+ if (inMap == "inline") {
+ throw new Error("inline source map only works with built-in parser");
+ }
+ toplevel = exports.AST_Node.from_mozilla_ast(files);
} else {
- if (typeof files == "string")
- files = [ files ];
- files.forEach(function(file){
+ var addFile = function(file, fileUrl) {
var code = options.fromString
? file
: rjsFile.readFile(file, "utf8");
- toplevel = parse(code, {
- filename: options.fromString ? name : file,
- toplevel: toplevel
+ if (inMap == "inline") {
+ inMap = read_source_map(code);
+ }
+ sourcesContent[fileUrl] = code;
+ toplevel = exports.parse(code, {
+ filename: fileUrl,
+ toplevel: toplevel,
+ bare_returns: options.parse ? options.parse.bare_returns : undefined
});
+ }
+ if (!options.fromString) {
+ files = exports.simple_glob(files);
+ if (inMap == "inline" && files.length > 1) {
+ throw new Error("inline source map only works with singular input");
+ }
+ }
+ [].concat(files).forEach(function (files, i) {
+ if (typeof files === 'string') {
+ addFile(files, options.fromString ? i : files);
+ } else {
+ for (var fileUrl in files) {
+ addFile(files[fileUrl], fileUrl);
+ }
+ }
});
}
+ if (options.wrap) {
+ toplevel = toplevel.wrap_commonjs(options.wrap, options.exportAll);
+ }
// 2. compress
if (options.compress) {
var compress = { warnings: options.warnings };
- merge(compress, options.compress);
- toplevel.figure_out_scope();
- var sq = Compressor(compress);
- toplevel = toplevel.transform(sq);
+ exports.merge(compress, options.compress);
+ toplevel.figure_out_scope(options.mangle);
+ var sq = exports.Compressor(compress);
+ toplevel = sq.compress(toplevel);
+ }
+
+ // 3. mangle properties
+ if (options.mangleProperties || options.nameCache) {
+ options.mangleProperties.cache = exports.readNameCache(options.nameCache, "props");
+ toplevel = exports.mangle_properties(toplevel, options.mangleProperties);
+ exports.writeNameCache(options.nameCache, "props", options.mangleProperties.cache);
}
- // 3. mangle
+ // 4. mangle
if (options.mangle) {
- toplevel.figure_out_scope();
- toplevel.compute_char_frequency();
+ toplevel.figure_out_scope(options.mangle);
+ toplevel.compute_char_frequency(options.mangle);
toplevel.mangle_names(options.mangle);
}
- // 4. output
- var inMap = options.inSourceMap;
- var output = {};
- if (typeof options.inSourceMap == "string") {
- inMap = rjsFile.readFile(options.inSourceMap, "utf8");
- }
- if (options.outSourceMap) {
- output.source_map = SourceMap({
- file: options.outSourceMap,
+ // 5. output
+ var output = { max_line_len: 32000 };
+ if (options.outSourceMap || options.sourceMapInline) {
+ output.source_map = exports.SourceMap({
+ // prefer outFileName, otherwise use outSourceMap without .map suffix
+ file: options.outFileName || (typeof options.outSourceMap === 'string' ? options.outSourceMap.replace(/\.map$/i, '') : null),
orig: inMap,
root: options.sourceRoot
});
+ if (options.sourceMapIncludeSources) {
+ for (var file in sourcesContent) {
+ if (sourcesContent.hasOwnProperty(file)) {
+ output.source_map.get().setSourceContent(file, sourcesContent[file]);
+ }
+ }
+ }
+
}
if (options.output) {
- merge(output, options.output);
+ exports.merge(output, options.output);
}
- var stream = OutputStream(output);
+ var stream = exports.OutputStream(output);
toplevel.print(stream);
+
+
+ var source_map = output.source_map;
+ if (source_map) {
+ source_map = source_map + "";
+ }
+
+ var mappingUrlPrefix = "\n//# sourceMappingURL=";
+ if (options.sourceMapInline) {
+ stream += mappingUrlPrefix + "data:application/json;charset=utf-8;base64," + new Buffer(source_map).toString("base64");
+ } else if (options.outSourceMap && typeof options.outSourceMap === "string" && options.sourceMapUrl !== false) {
+ stream += mappingUrlPrefix + (typeof options.sourceMapUrl === "string" ? options.sourceMapUrl : options.outSourceMap);
+ }
+
return {
code : stream + "",
- map : output.source_map + ""
+ map : source_map
};
};
@@ -22652,11 +24827,11 @@ exports.minify = function(files, options, name) {
// if (ctor.SUBCLASSES.length > 0) ret.sub = sub;
// return ret;
// }
-// return doitem(AST_Node).sub;
+// return doitem(exports.AST_Node).sub;
// }
exports.describe_ast = function() {
- var out = OutputStream({ beautify: true });
+ var out = exports.OutputStream({ beautify: true });
function doitem(ctor) {
out.print("AST_" + ctor.TYPE);
var props = ctor.SELF_PROPS.filter(function(prop){
@@ -22675,29 +24850,114 @@ exports.describe_ast = function() {
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();
- });
+ if (ctor.SUBCLASSES.length > 0) {
+ out.space();
+ out.with_block(function(){
+ ctor.SUBCLASSES.forEach(function(ctor, i){
+ out.indent();
+ doitem(ctor);
+ out.newline();
+ });
+ });
+ }
+ };
+ doitem(exports.AST_Node);
+ return out + "";
+};
+
+function readReservedFile(filename, reserved) {
+ if (!reserved) {
+ reserved = { vars: [], props: [] };
+ }
+ var data = rjsFile.readFile(filename, "utf8");
+ data = JSON.parse(data);
+ if (data.vars) {
+ data.vars.forEach(function(name){
+ exports.push_uniq(reserved.vars, name);
+ });
+ }
+ if (data.props) {
+ data.props.forEach(function(name){
+ exports.push_uniq(reserved.props, name);
+ });
+ }
+ return reserved;
+}
+
+exports.readReservedFile = readReservedFile;
+
+exports.readDefaultReservedFile = function(reserved) {
+ return readReservedFile(require.resolve("./domprops.json"), reserved);
+};
+
+exports.readNameCache = function(filename, key) {
+ var cache = null;
+ if (filename) {
+ try {
+ var cache = rjsFile.readFile(filename, "utf8");
+ cache = JSON.parse(cache)[key];
+ if (!cache) throw "init";
+ cache.props = exports.Dictionary.fromObject(cache.props);
+ } catch(ex) {
+ cache = {
+ cname: -1,
+ props: new exports.Dictionary()
+ };
+ }
+ }
+ return cache;
+};
+
+exports.writeNameCache = function(filename, key, cache) {
+ if (filename) {
+ var data;
+ try {
+ data = rjsFile.readFile(filename, "utf8");
+ data = JSON.parse(data);
+ } catch(ex) {
+ data = {};
+ }
+ data[key] = {
+ cname: cache.cname,
+ props: cache.props.toObject()
+ };
+ rjsFile.writeFile(filename, JSON.stringify(data, null, 2), "utf8");
+ }
+};
+
+// A file glob function that only supports "*" and "?" wildcards in the basename.
+// Example: "foo/bar/*baz??.*.js"
+// Argument `glob` may be a string or an array of strings.
+// Returns an array of strings. Garbage in, garbage out.
+exports.simple_glob = function simple_glob(glob) {
+ if (Array.isArray(glob)) {
+ return [].concat.apply([], glob.map(simple_glob));
+ }
+ if (glob.match(/\*|\?/)) {
+ var dir = path.dirname(glob);
+ try {
+ var entries = fs.readdirSync(dir);
+ } catch (ex) {}
+ if (entries) {
+ var pattern = "^" + path.basename(glob)
+ .replace(/[.+^$[\]\\(){}]/g, "\\$&")
+ .replace(/\*/g, "[^/\\\\]*")
+ .replace(/\?/g, "[^/\\\\]") + "$";
+ var mod = process.platform === "win32" ? "i" : "";
+ var rx = new RegExp(pattern, mod);
+ var results = entries.filter(function(name) {
+ return rx.test(name);
+ }).map(function(name) {
+ return path.join(dir, name);
});
+ if (results.length) return results;
}
- };
- doitem(AST_Node);
- return out + "";
+ }
+ return [ glob ];
};
});
-/**
- * @license Copyright (c) 2010-2014, 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 */
@@ -22718,11 +24978,15 @@ define('parse', ['./esprimaAdapter', 'lang'], function (esprima, lang) {
//This string is saved off because JSLint complains
//about obj.arguments use, as 'reserved word'
- var argPropName = 'arguments';
+ var argPropName = 'arguments',
+ //Default object to use for "scope" checking for UMD identifiers.
+ emptyScope = {},
+ mixin = lang.mixin,
+ hasProp = lang.hasProp;
//From an esprima example for traversing its ast.
function traverse(object, visitor) {
- var key, child;
+ var child;
if (!object) {
return;
@@ -22731,13 +24995,11 @@ define('parse', ['./esprimaAdapter', 'lang'], function (esprima, lang) {
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;
- }
+ for (var i = 0, keys = Object.keys(object); i < keys.length; i++) {
+ child = object[keys[i]];
+ if (typeof child === 'object' && child !== null) {
+ if (traverse(child, visitor) === false) {
+ return false;
}
}
}
@@ -22747,7 +25009,7 @@ define('parse', ['./esprimaAdapter', 'lang'], function (esprima, lang) {
//stops that subtree analysis, not the rest of tree
//visiting.
function traverseBroad(object, visitor) {
- var key, child;
+ var child;
if (!object) {
return;
@@ -22756,12 +25018,10 @@ define('parse', ['./esprimaAdapter', 'lang'], function (esprima, lang) {
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) {
- traverseBroad(child, visitor);
- }
+ for (var i = 0, keys = Object.keys(object); i < keys.length; i++) {
+ child = object[key];
+ if (typeof child === 'object' && child !== null) {
+ traverseBroad(child, visitor);
}
}
}
@@ -22793,6 +25053,13 @@ define('parse', ['./esprimaAdapter', 'lang'], function (esprima, lang) {
return deps.length ? deps : undefined;
}
+ // Detects regular or arrow function expressions as the desired expression
+ // type.
+ function isFnExpression(node) {
+ return (node && (node.type === 'FunctionExpression' ||
+ node.type === 'ArrowFunctionExpression'));
+ }
+
/**
* Main parse function. Returns a string of any valid require or
* define/require.def calls as part of one JavaScript source string.
@@ -22820,7 +25087,7 @@ define('parse', ['./esprimaAdapter', 'lang'], function (esprima, lang) {
needsDefine = true,
astRoot = esprima.parse(fileContents);
- parse.recurse(astRoot, function (callName, config, name, deps) {
+ parse.recurse(astRoot, function (callName, config, name, deps, node, factoryIdentifier, fnExpScope) {
if (!deps) {
deps = [];
}
@@ -22840,6 +25107,10 @@ define('parse', ['./esprimaAdapter', 'lang'], function (esprima, lang) {
});
}
+ if (callName === 'define' && factoryIdentifier && hasProp(fnExpScope, factoryIdentifier)) {
+ return factoryIdentifier;
+ }
+
//If define was found, no need to dive deeper, unless
//the config explicitly wants to dig deeper.
return !!options.findNestedDependencies;
@@ -22882,6 +25153,7 @@ define('parse', ['./esprimaAdapter', 'lang'], function (esprima, lang) {
parse.traverse = traverse;
parse.traverseBroad = traverseBroad;
+ parse.isFnExpression = isFnExpression;
/**
* Handles parsing a file recursively for require calls.
@@ -22889,14 +25161,18 @@ define('parse', ['./esprimaAdapter', 'lang'], function (esprima, lang) {
* @param {Function} onMatch function to call on a parse match.
* @param {Object} [options] This is normally the build config options if
* it is passed.
+ * @param {Object} [fnExpScope] holds list of function expresssion
+ * argument identifiers, set up internally, not passed in
*/
- parse.recurse = function (object, onMatch, options) {
+ parse.recurse = function (object, onMatch, options, fnExpScope) {
//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,
+ var keys, child, result, i, params, param, tempObject,
hasHas = options && options.has;
+ fnExpScope = fnExpScope || emptyScope;
+
if (!object) {
return;
}
@@ -22907,23 +25183,70 @@ define('parse', ['./esprimaAdapter', 'lang'], function (esprima, lang) {
object.test.type === 'Literal') {
if (object.test.value) {
//Take the if branch
- this.recurse(object.consequent, onMatch, options);
+ this.recurse(object.consequent, onMatch, options, fnExpScope);
} else {
//Take the else branch
- this.recurse(object.alternate, onMatch, options);
+ this.recurse(object.alternate, onMatch, options, fnExpScope);
}
} else {
- if (this.parseNode(object, onMatch) === false) {
+ result = this.parseNode(object, onMatch, fnExpScope);
+ if (result === false) {
return;
+ } else if (typeof result === 'string') {
+ return result;
+ }
+
+ //Build up a "scope" object that informs nested recurse calls if
+ //the define call references an identifier that is likely a UMD
+ //wrapped function expression argument.
+ //Catch (function(a) {... wrappers
+ if (object.type === 'ExpressionStatement' && object.expression &&
+ object.expression.type === 'CallExpression' && object.expression.callee &&
+ isFnExpression(object.expression.callee)) {
+ tempObject = object.expression.callee;
+ }
+ // Catch !function(a) {... wrappers
+ if (object.type === 'UnaryExpression' && object.argument &&
+ object.argument.type === 'CallExpression' && object.argument.callee &&
+ isFnExpression(object.argument.callee)) {
+ tempObject = object.argument.callee;
+ }
+ if (tempObject && tempObject.params && tempObject.params.length) {
+ params = tempObject.params;
+ fnExpScope = mixin({}, fnExpScope, true);
+ for (i = 0; i < params.length; i++) {
+ param = params[i];
+ if (param.type === 'Identifier') {
+ fnExpScope[param.name] = true;
+ }
+ }
}
- for (key in object) {
- if (object.hasOwnProperty(key)) {
- child = object[key];
- if (typeof child === 'object' && child !== null) {
- this.recurse(child, onMatch, options);
+
+ for (i = 0, keys = Object.keys(object); i < keys.length; i++) {
+ child = object[keys[i]];
+ if (typeof child === 'object' && child !== null) {
+ result = this.recurse(child, onMatch, options, fnExpScope);
+ if (typeof result === 'string' && hasProp(fnExpScope, result)) {
+ //The result was still in fnExpScope so break. Otherwise,
+ //was a return from a a tree that had a UMD definition,
+ //but now out of that scope so keep siblings.
+ break;
}
}
}
+
+ //Check for an identifier for a factory function identifier being
+ //passed in as a function expression, indicating a UMD-type of
+ //wrapping.
+ if (typeof result === 'string') {
+ if (hasProp(fnExpScope, result)) {
+ //result still in scope, keep jumping out indicating the
+ //identifier still in use.
+ return result;
+ }
+
+ return;
+ }
}
};
@@ -22935,18 +25258,56 @@ define('parse', ['./esprimaAdapter', 'lang'], function (esprima, lang) {
* @returns {Boolean}
*/
parse.definesRequire = function (fileName, fileContents) {
- var found = false;
+ var foundDefine = false,
+ foundDefineAmd = false;
traverse(esprima.parse(fileContents), function (node) {
- if (parse.hasDefineAmd(node)) {
- found = true;
+ // Look for a top level declaration of a define, like
+ // var requirejs, require, define, off Program body.
+ if (node.type === 'Program' && node.body && node.body.length) {
+ foundDefine = node.body.some(function(bodyNode) {
+ // var define
+ if (bodyNode.type === 'VariableDeclaration') {
+ var decls = bodyNode.declarations;
+ if (decls) {
+ var hasVarDefine = decls.some(function(declNode) {
+ return (declNode.type === 'VariableDeclarator' &&
+ declNode.id &&
+ declNode.id.type === 'Identifier' &&
+ declNode.id.name === 'define');
+ });
+ if (hasVarDefine) {
+ return true;
+ }
+ }
+ }
+
+ // function define() {}
+ if (bodyNode.type === 'FunctionDeclaration' &&
+ bodyNode.id &&
+ bodyNode.id.type === 'Identifier' &&
+ bodyNode.id.name === 'define') {
+ return true;
+ }
+
+
+
+
+
+
+ });
+ }
+
+ // Need define variable found first, before detecting define.amd.
+ if (foundDefine && parse.hasDefineAmd(node)) {
+ foundDefineAmd = true;
//Stop traversal
return false;
}
});
- return found;
+ return foundDefine && foundDefineAmd;
};
/**
@@ -23015,15 +25376,14 @@ define('parse', ['./esprimaAdapter', 'lang'], function (esprima, lang) {
//Just the factory function passed to define
arg0 = node[argPropName][0];
- if (arg0 && arg0.type === 'FunctionExpression') {
+ if (isFnExpression(arg0)) {
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') {
+ if (arg0.type === 'Literal' && isFnExpression(arg1)) {
match = arg1;
return false;
}
@@ -23277,6 +25637,33 @@ define('parse', ['./esprimaAdapter', 'lang'], function (esprima, lang) {
return name;
};
+ /**
+ * Finds all the named define module IDs in a file.
+ */
+ parse.getAllNamedDefines = function (fileContents, excludeMap) {
+ var names = [];
+ parse.recurse(esprima.parse(fileContents),
+ function (callName, config, name, deps, node, factoryIdentifier, fnExpScope) {
+ if (callName === 'define' && name) {
+ if (!excludeMap.hasOwnProperty(name)) {
+ names.push(name);
+ }
+ }
+
+ //If a UMD definition that points to a factory that is an Identifier,
+ //indicate processing should not traverse inside the UMD definition.
+ if (callName === 'define' && factoryIdentifier && hasProp(fnExpScope, factoryIdentifier)) {
+ return factoryIdentifier;
+ }
+
+ //If define was found, no need to dive deeper, unless
+ //the config explicitly wants to dig deeper.
+ return true;
+ }, {});
+
+ return names;
+ };
+
/**
* Determines if define(), require({}|[]) or requirejs was called in the
* file. Also finds out if define() is declared and if define.amd is called.
@@ -23347,6 +25734,11 @@ define('parse', ['./esprimaAdapter', 'lang'], function (esprima, lang) {
} else if (exp.left.object.name === 'exports' &&
exp.left.property) {
type = 'exports';
+ } else if (exp.left.object.type === 'MemberExpression' &&
+ exp.left.object.object.name === 'module' &&
+ exp.left.object.property.name === 'exports' &&
+ exp.left.object.property.type === 'Identifier') {
+ type = 'moduleExports';
}
} else if (node && node.type === 'CallExpression' && node.callee &&
@@ -23397,19 +25789,23 @@ define('parse', ['./esprimaAdapter', 'lang'], function (esprima, lang) {
* @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.
+ * @param {Object} fnExpScope an object whose keys are all function
+ * expression identifiers that should be in scope. Useful for UMD wrapper
+ * detection to avoid parsing more into the wrapped UMD code.
*
* @returns {String} a JS source string with the valid require/define call.
* Otherwise null.
*/
- parse.parseNode = function (node, onMatch) {
+ parse.parseNode = function (node, onMatch, fnExpScope) {
var name, deps, cjsDeps, arg, factory, exp, refsDefine, bodyNode,
args = node && node[argPropName],
- callName = parse.hasRequire(node);
+ callName = parse.hasRequire(node),
+ isUmd = false;
if (callName === 'require' || callName === 'requirejs') {
//A plain require/requirejs call
arg = node[argPropName] && node[argPropName][0];
- if (arg.type !== 'ArrayExpression') {
+ if (arg && arg.type !== 'ArrayExpression') {
if (arg.type === 'ObjectExpression') {
//A config call, try the second arg.
arg = node[argPropName][1];
@@ -23432,39 +25828,54 @@ define('parse', ['./esprimaAdapter', 'lang'], function (esprima, lang) {
factory = deps;
deps = name;
name = null;
- } else if (name.type === 'FunctionExpression') {
+ } else if (isFnExpression(name)) {
//Just the factory, no name or deps
factory = name;
name = deps = null;
+ } else if (name.type === 'Identifier' && args.length === 1 &&
+ hasProp(fnExpScope, name.name)) {
+ //define(e) where e is a UMD identifier for the factory
+ //function.
+ isUmd = true;
+ factory = name;
+ name = 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') {
+ if (isFnExpression(deps)) {
//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;
+ } else if (deps.type === 'Identifier') {
+ if (args.length === 2) {
+ //define('id', factory)
+ deps = factory = null;
+ } else if (args.length === 3 && isFnExpression(factory)) {
+ //define('id', depsIdentifier, factory)
+ //Since identifier, cannot know the deps, but do not
+ //error out, assume they are taken care of outside of
+ //static parsing.
+ deps = null;
+ }
}
}
if (deps && deps.type === 'ArrayExpression') {
deps = getValidDeps(deps);
- } else if (factory && factory.type === 'FunctionExpression') {
+ } else if (isFnExpression(factory)) {
//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) {
+ } else if (deps || (factory && !isUmd)) {
//Does not match the shape of an AMD call.
return;
}
@@ -23474,9 +25885,11 @@ define('parse', ['./esprimaAdapter', 'lang'], function (esprima, lang) {
name = name.value;
}
- return onMatch("define", null, name, deps, node);
+ return onMatch("define", null, name, deps, node,
+ (factory && factory.type === 'Identifier' ? factory.name : undefined),
+ fnExpScope);
} else if (node.type === 'CallExpression' && node.callee &&
- node.callee.type === 'FunctionExpression' &&
+ isFnExpression(node.callee) &&
node.callee.body && node.callee.body.body &&
node.callee.body.body.length === 1 &&
node.callee.body.body[0].type === 'IfStatement') {
@@ -23501,7 +25914,8 @@ define('parse', ['./esprimaAdapter', 'lang'], function (esprima, lang) {
});
if (refsDefine) {
- return onMatch("define", null, null, null, exp.expression);
+ return onMatch("define", null, null, null, exp.expression,
+ exp.expression.arguments[0].name, fnExpScope);
}
}
}
@@ -23618,12 +26032,6 @@ define('parse', ['./esprimaAdapter', 'lang'], function (esprima, lang) {
return parse;
});
-/**
- * @license Copyright (c) 2012-2014, 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'],
@@ -23727,7 +26135,7 @@ function (esprima, parse, logger, lang) {
//to limit impact of false positives.
needsId = true;
depAction = 'empty';
- } else if (firstArg.type === 'FunctionExpression') {
+ } else if (parse.isFnExpression(firstArg)) {
//define(function(){})
factoryNode = firstArg;
needsId = true;
@@ -23767,7 +26175,7 @@ function (esprima, parse, logger, lang) {
//Already has an ID.
needsId = false;
if (args.length === 2 &&
- args[1].type === 'FunctionExpression') {
+ parse.isFnExpression(args[1])) {
//Needs dependency scanning.
factoryNode = args[1];
depAction = 'scan';
@@ -24062,12 +26470,6 @@ function (esprima, parse, logger, lang) {
return transform;
});
-/**
- * @license Copyright (c) 2010-2014, 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 */
@@ -24095,21 +26497,23 @@ define('pragma', ['parse', 'logger'], function (parse, logger) {
var pragma = {
conditionalRegExp: /(exclude|include)Start\s*\(\s*["'](\w+)["']\s*,(.*)\)/,
- useStrictRegExp: /['"]use strict['"];/g,
+ useStrictRegExp: /(^|[^{]\r?\n)['"]use strict['"];/g,
hasRegExp: /has\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
configRegExp: /(^|[^\.])(requirejs|require)(\.config)\s*\(/g,
nsWrapRegExp: /\/\*requirejs namespace: true \*\//,
apiDefRegExp: /var requirejs,\s*require,\s*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,
+ defineCheckRegExp: /typeof(\s+|\s*\(\s*)define(\s*\))?\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,
+ 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,
+ defineTernaryRegExp: /typeof\s+define\s*===?\s*['"]function["']\s*&&\s*define\s*\.\s*amd\s*\?\s*define/,
+ defineExistsRegExp: /\s+typeof\s+define\s*!==?\s*['"]undefined["']\s*/,
+ defineExistsAndAmdRegExp: /typeof\s+define\s*!==?\s*['"]undefined["']\s*&&\s*define\s*\.\s*amd\s*/,
+ 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, '');
+ return config.useStrict ? contents : contents.replace(pragma.useStrictRegExp, '$1');
},
namespace: function (fileContents, ns, onLifecycleName) {
@@ -24132,6 +26536,10 @@ define('pragma', ['parse', 'logger'], function (parse, logger) {
fileContents = fileContents.replace(pragma.defineHasRegExp,
"typeof " + ns + ".define === 'function' && typeof " + ns + ".define.amd === 'object' && " + ns + ".define.amd");
+ //Namespace async.js define use:
+ fileContents = fileContents.replace(pragma.defineExistsAndAmdRegExp,
+ "typeof " + ns + ".define !== 'undefined' && " + ns + ".define.amd");
+
//Namespace define checks.
//Do these ones last, since they are a subset of the more specific
//checks above.
@@ -24141,6 +26549,8 @@ define('pragma', ['parse', 'logger'], function (parse, logger) {
"typeof " + ns + ".define === 'function' && " + ns + ".define['amd']");
fileContents = fileContents.replace(pragma.defineTypeFirstCheckRegExp,
"'function' === typeof " + ns + ".define && " + ns + ".define.amd");
+ fileContents = fileContents.replace(pragma.defineExistsRegExp,
+ "typeof " + ns + ".define !== 'undefined'");
//Check for require.js with the require/define definitions
if (pragma.apiDefRegExp.test(fileContents) &&
@@ -24328,13 +26738,8 @@ define('pragma', ['parse', 'logger'], function (parse, logger) {
return pragma;
});
-if(env === 'browser') {
-/**
- * @license Copyright (c) 2010-2014, The Dojo Foundation All Rights Reserved.
- * Available via the MIT or new BSD license.
- * see: http://github.com/jrburke/requirejs for details
- */
+if(env === 'browser') {
/*jslint strict: false */
/*global define: false */
@@ -24343,12 +26748,6 @@ define('browser/optimize', {});
}
if(env === 'node') {
-/**
- * @license Copyright (c) 2010-2014, 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 */
@@ -24357,12 +26756,6 @@ define('node/optimize', {});
}
if(env === 'rhino') {
-/**
- * @license Copyright (c) 2010-2014, 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 */
@@ -24403,8 +26796,20 @@ define('rhino/optimize', ['logger', 'env!env/file'], function (logger, file) {
//Bind to Closure compiler, but if it is not available, do not sweat it.
try {
+ // Try older closure compiler that worked on Java 6
JSSourceFilefromCode = java.lang.Class.forName('com.google.javascript.jscomp.JSSourceFile').getMethod('fromCode', [java.lang.String, java.lang.String]);
- } catch (e) {}
+ } catch (e) {
+ try {
+ // Try for newer closure compiler that needs Java 7+
+ JSSourceFilefromCode = java.lang.Class.forName('com.google.javascript.jscomp.SourceFile').getMethod('fromCode', [java.lang.String, java.lang.String]);
+ } catch (e) {
+ try {
+ // Try Nashorn style
+ var stringClass = Java.type("java.lang.String").class;
+ JSSourceFilefromCode = Java.type("com.google.javascript.jscomp.SourceFile").class.getMethod("fromCode", [stringClass, stringClass]);
+ } catch (e) {}
+ }
+ }
//Helper for closure compiler, because of weird Java-JavaScript interactions.
function closurefromCode(filename, content) {
@@ -24442,7 +26847,8 @@ define('rhino/optimize', ['logger', 'env!env/file'], function (logger, file) {
//Set up source input
jsSourceFile = closurefromCode(String(fileName), String(fileContents)),
sourceListArray = new java.util.ArrayList(),
- options, option, FLAG_compilation_level, compiler,
+ externList = new java.util.ArrayList(),
+ options, option, FLAG_compilation_level, compiler, externExportsPath,
Compiler = Packages.com.google.javascript.jscomp.Compiler,
CommandLineRunner = Packages.com.google.javascript.jscomp.CommandLineRunner;
@@ -24472,6 +26878,14 @@ define('rhino/optimize', ['logger', 'env!env/file'], function (logger, file) {
options.setSourceMapOutputPath(fileName + ".map");
}
+ //If we need to pass an externs file to Closure so that it does not create aliases
+ //for certain symbols, do so here.
+ externList.addAll(CommandLineRunner.getDefaultExterns());
+ if (config.externExportsPath) {
+ externExportsPath = config.externExportsPath;
+ externList.add(jscomp.SourceFile.fromFile(externExportsPath));
+ }
+
//Trigger the compiler
Compiler.setLoggingLevel(Packages.java.util.logging.Level[config.loggingLevel || 'WARNING']);
compiler = new Compiler();
@@ -24480,7 +26894,7 @@ define('rhino/optimize', ['logger', 'env!env/file'], function (logger, file) {
//accepting the getDefaultExterns return value (a List) also wants the sources as a List
sourceListArray.add(jsSourceFile);
- result = compiler.compile(CommandLineRunner.getDefaultExterns(), sourceListArray, options);
+ result = compiler.compile(externList, sourceListArray, options);
if (result.success) {
optimized = String(compiler.toSource());
@@ -24533,20 +26947,14 @@ define('rhino/optimize', ['logger', 'env!env/file'], function (logger, file) {
if(env === 'xpconnect') {
define('xpconnect/optimize', {});
}
-/**
- * @license Copyright (c) 2010-2014, 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',
+ 'pragma', 'uglifyjs',
'source-map'],
function (lang, logger, envOptimize, file, parse,
- pragma, uglify, uglify2,
+ pragma, uglify,
sourceMap) {
'use strict';
@@ -24554,8 +26962,10 @@ function (lang, logger, envOptimize, file, parse,
cssImportRegExp = /\@import\s+(url\()?\s*([^);]+)\s*(\))?([\w, ]*)(;)?/ig,
cssCommentImportRegExp = /\/\*[^\*]*@import[^\*]*\*\//g,
cssUrlRegExp = /\url\(\s*([^\)]+)\s*\)?/g,
+ protocolRegExp = /^\w+:/,
SourceMapGenerator = sourceMap.SourceMapGenerator,
- SourceMapConsumer =sourceMap.SourceMapConsumer;
+ SourceMapConsumer = sourceMap.SourceMapConsumer,
+ es5PlusGuidance = 'If the source uses ES2015 or later syntax, please pass "optimize: \'none\'" to r.js and use an ES2015+ compatible minifier after running r.js. The included UglifyJS only understands ES5 or earlier syntax.';
/**
* If an URL from a CSS url value contains start/end quotes, remove them.
@@ -24578,7 +26988,7 @@ function (lang, logger, envOptimize, file, parse,
function fixCssUrlPaths(fileName, path, contents, cssPrefix) {
return contents.replace(cssUrlRegExp, function (fullMatch, urlMatch) {
- var colonIndex, firstChar, parts, i,
+ var firstChar, hasProtocol, parts, i,
fixedUrlMatch = cleanCssUrlQuotes(urlMatch);
fixedUrlMatch = fixedUrlMatch.replace(lang.backSlashRegExp, "/");
@@ -24586,12 +26996,11 @@ function (lang, logger, envOptimize, file, parse,
//Only do the work for relative URLs. Skip things that start with / or #, or have
//a protocol.
firstChar = fixedUrlMatch.charAt(0);
- colonIndex = fixedUrlMatch.indexOf(":");
- if (firstChar !== "/" && firstChar !== "#" && (colonIndex === -1 || colonIndex > fixedUrlMatch.indexOf("/"))) {
+ hasProtocol = protocolRegExp.test(fixedUrlMatch);
+ if (firstChar !== "/" && firstChar !== "#" && !hasProtocol) {
//It is a relative URL, tack on the cssPrefix and path prefix
urlMatch = cssPrefix + path + fixedUrlMatch;
-
- } else {
+ } else if (!hasProtocol) {
logger.trace(fileName + "\n URL not a relative URL, skipping: " + urlMatch);
}
@@ -24788,6 +27197,11 @@ function (lang, logger, envOptimize, file, parse,
}
}
+ if (config.generateSourceMaps && licenseContents) {
+ optConfig.preamble = licenseContents;
+ licenseContents = '';
+ }
+
fileContents = licenseContents + optFunc(fileName,
fileContents,
outFileName,
@@ -24944,40 +27358,6 @@ function (lang, logger, envOptimize, file, parse,
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',
@@ -24989,8 +27369,13 @@ function (lang, logger, envOptimize, file, parse,
uconfig.fromString = true;
+ if (config.preamble) {
+ uconfig.output = {preamble: config.preamble};
+ }
+
+
if (config.generateSourceMaps && (outFileName || config._buildSourceMap)) {
- uconfig.outSourceMap = baseName;
+ uconfig.outSourceMap = baseName + '.map';
if (config._buildSourceMap) {
existingMap = JSON.parse(config._buildSourceMap);
@@ -25001,19 +27386,14 @@ function (lang, logger, envOptimize, file, parse,
}
}
- logger.trace("Uglify2 file: " + fileName);
+ logger.trace("Uglify file: " + fileName);
try {
//var tempContents = fileContents.replace(/\/\/\# sourceMappingURL=.*$/, '');
- result = uglify2.minify(fileContents, uconfig, baseName + '.src.js');
+ result = uglify.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 if (!config._buildSourceMap) {
+ if (!existingMap && !config._buildSourceMap) {
file.saveFile(outFileName + '.src.js', fileContents);
}
@@ -25023,13 +27403,16 @@ function (lang, logger, envOptimize, file, parse,
config._buildSourceMap = resultMap;
} else {
file.saveFile(outFileName + '.map', resultMap);
- fileContents += "\n//# sourceMappingURL=" + baseName + ".map";
}
} else {
fileContents = result.code;
}
} catch (e) {
- throw new Error('Cannot uglify2 file: ' + fileName + '. Skipping it. Error is:\n' + e.toString());
+ var errorString = e.toString();
+ var isSyntaxError = /SyntaxError/.test(errorString);
+ throw new Error('Cannot uglify file: ' + fileName +
+ '. Skipping it. Error is:\n' + errorString +
+ (isSyntaxError ? '\n\n' + es5PlusGuidance : ''));
}
return fileContents;
}
@@ -25038,11 +27421,6 @@ function (lang, logger, envOptimize, file, parse,
return optimize;
});
-/**
- * @license RequireJS Copyright (c) 2010-2014, 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.
*/
@@ -25068,7 +27446,18 @@ define('requirePatch', [ 'env!env/file', 'pragma', 'parse', 'lang', 'logger', 'c
var allowRun = true,
hasProp = lang.hasProp,
falseProp = lang.falseProp,
- getOwn = lang.getOwn;
+ getOwn = lang.getOwn,
+ // Used to strip out use strict from toString()'d functions for the
+ // shim config since they will explicitly want to not be bound by strict,
+ // but some envs, explicitly xpcshell, adds a use strict.
+ useStrictRegExp = /['"]use strict['"];/g,
+ //Absolute path if starts with /, \, or x:
+ absoluteUrlRegExp = /^[\/\\]|^\w:/;
+
+ //Turn off throwing on resolution conflict, that was just an older prim
+ //idea about finding errors early, but does not comply with how promises
+ //should operate.
+ prim.hideResolutionConflict = true;
//This method should be called when the patches to require should take hold.
return function () {
@@ -25130,8 +27519,10 @@ define('requirePatch', [ 'env!env/file', 'pragma', 'parse', 'lang', 'logger', 'c
};
function normalizeUrlWithBase(context, moduleName, url) {
- //Adjust the URL if it was not transformed to use baseUrl.
- if (require.jsExtRegExp.test(moduleName)) {
+ //Adjust the URL if it was not transformed to use baseUrl, but only
+ //if the URL is not already an absolute path.
+ if (require.jsExtRegExp.test(moduleName) &&
+ !absoluteUrlRegExp.test(url)) {
url = (context.config.dir || context.config.dirBaseUrl) + url;
}
return url;
@@ -25175,7 +27566,8 @@ define('requirePatch', [ 'env!env/file', 'pragma', 'parse', 'lang', 'logger', 'c
}
if (value.init) {
- str += '(' + value.init.toString() + '.apply(this, arguments))';
+ str += '(' + value.init.toString()
+ .replace(useStrictRegExp, '') + '.apply(this, arguments))';
}
if (value.init && value.exports) {
str += ' || ';
@@ -25192,7 +27584,8 @@ define('requirePatch', [ 'env!env/file', 'pragma', 'parse', 'lang', 'logger', 'c
' return function () {\n' +
' var ret, fn;\n' +
(value.init ?
- (' fn = ' + value.init.toString() + ';\n' +
+ (' fn = ' + value.init.toString()
+ .replace(useStrictRegExp, '') + ';\n' +
' ret = fn.apply(global, arguments);\n') : '') +
(value.exports ?
' return ret || global.' + value.exports + ';\n' :
@@ -25214,7 +27607,7 @@ define('requirePatch', [ 'env!env/file', 'pragma', 'parse', 'lang', 'logger', 'c
if (mod && !mod.defined) {
if (parentId && getOwn(needFullExec, parentId)) {
- needFullExec[id] = true;
+ needFullExec[id] = depMap;
}
} else if ((getOwn(needFullExec, id) && falseProp(fullExec, id)) ||
@@ -25400,7 +27793,8 @@ define('requirePatch', [ 'env!env/file', 'pragma', 'parse', 'lang', 'logger', 'c
lang.each(depMaps, lang.bind(this, function (depMap) {
if (typeof depMap === 'string') {
depMap = context.makeModuleMap(depMap,
- (this.map.isDefine ? this.map : this.map.parentMap));
+ (this.map.isDefine ? this.map : this.map.parentMap),
+ false, true);
}
if (!context.fullExec[depMap.id]) {
@@ -25419,7 +27813,7 @@ define('requirePatch', [ 'env!env/file', 'pragma', 'parse', 'lang', 'logger', 'c
pluginMod = getOwn(context.registry, pluginId);
context.plugins[pluginId] = true;
- context.needFullExec[pluginId] = true;
+ context.needFullExec[pluginId] = map;
//If the module is not waiting to finish being defined,
//undef it and start over, to get full execution.
@@ -25496,13 +27890,26 @@ define('requirePatch', [ 'env!env/file', 'pragma', 'parse', 'lang', 'logger', 'c
var id = map.id,
url;
+ // Fix up any maps that need to be normalized as part of the fullExec
+ // plumbing for plugins to participate in the build.
+ if (context.plugins && lang.hasProp(context.plugins, id)) {
+ lang.eachProp(context.needFullExec, function(value, prop) {
+ // For plugin entries themselves, they do not have a map
+ // value in needFullExec, just a "true" entry.
+ if (value !== true && value.prefix === id && value.unnormalized) {
+ var map = context.makeModuleMap(value.originalName, value.parentMap);
+ context.needFullExec[map.id] = map;
+ }
+ });
+ }
+
//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;
+ context.fullExec[id] = map;
}
//A plugin.
@@ -25537,12 +27944,6 @@ define('requirePatch', [ 'env!env/file', 'pragma', 'parse', 'lang', 'logger', 'c
};
};
});
-/**
- * @license RequireJS Copyright (c) 2010-2014, 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 */
@@ -25641,14 +28042,8 @@ define('commonJs', ['env!env/file', 'parse'], function (file, parse) {
return commonJs;
});
-/**
- * @license Copyright (c) 2010-2014, 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 */
+/*global define, requirejs, java, process, console */
define('build', function (require) {
@@ -25666,13 +28061,22 @@ define('build', function (require) {
requirePatch = require('requirePatch'),
env = require('env'),
commonJs = require('commonJs'),
- SourceMapGenerator = require('source-map/source-map-generator'),
+ SourceMapGenerator = require('source-map').SourceMapGenerator,
hasProp = lang.hasProp,
getOwn = lang.getOwn,
falseProp = lang.falseProp,
endsWithSemiColonRegExp = /;\s*$/,
endsWithSlashRegExp = /[\/\\]$/,
- resourceIsModuleIdRegExp = /^[\w\/\\\.]+$/;
+ resourceIsModuleIdRegExp = /^[\w\/\\\.]+$/,
+ deepCopyProps = {
+ layer: true
+ };
+
+ //Deep copy a config object, but do not copy over the "layer" property,
+ //as it can be a deeply nested structure with a full requirejs context.
+ function copyConfig(obj) {
+ return lang.deeplikeCopy(obj, deepCopyProps);
+ }
prim.nextTick = function (fn) {
fn();
@@ -25713,6 +28117,9 @@ define('build', function (require) {
optimizeAllPluginResources: false,
findNestedDependencies: false,
preserveLicenseComments: true,
+ writeBuildTxt: true,
+ //Some builds can take a while, up the default limit.
+ waitSeconds: 30,
//By default, all files/directories are copied, unless
//they match this regexp, by default just excludes .folders
dirExclusionRegExp: file.dirExclusionRegExp,
@@ -25740,6 +28147,13 @@ define('build', function (require) {
return dirName;
}
+ function endsWithNewLine(text) {
+ if (text.charAt(text.length - 1) !== "\n") {
+ text += "\n";
+ }
+ return text;
+ }
+
//Method used by plugin writeFile calls, defined up here to avoid
//jslint warning about "making a function in a loop".
function makeWriteFile(namespace, layer) {
@@ -25756,6 +28170,75 @@ define('build', function (require) {
return writeFile;
}
+ /**
+ * Appends singleContents to fileContents and returns the result. If a sourceMapGenerator
+ * is provided, adds singleContents to the source map.
+ *
+ * @param {string} fileContents - The file contents to which to append singleContents
+ * @param {string} singleContents - The additional contents to append to fileContents
+ * @param {string} path - An absolute path of a file whose name to use in the source map.
+ * The file need not actually exist if the code in singleContents is generated.
+ * @param {{out: ?string, baseUrl: ?string}} config - The build configuration object.
+ * @param {?{_buildPath: ?string}} module - An object with module information.
+ * @param {?SourceMapGenerator} sourceMapGenerator - An instance of Mozilla's SourceMapGenerator,
+ * or null if no source map is being generated.
+ * @returns {string} fileContents with singleContents appended
+ */
+ function appendToFileContents(fileContents, singleContents, path, config, module, sourceMapGenerator) {
+ var refPath, sourceMapPath, resourcePath, pluginId, sourceMapLineNumber, lineCount, parts, i;
+ if (sourceMapGenerator) {
+ if (config.out) {
+ refPath = config.baseUrl;
+ } else if (module && module._buildPath) {
+ refPath = module._buildPath;
+ } else {
+ refPath = "";
+ }
+ parts = path.split('!');
+ if (parts.length === 1) {
+ //Not a plugin resource, fix the path
+ sourceMapPath = build.makeRelativeFilePath(refPath, path);
+ } else {
+ //Plugin resource. If it looks like just a plugin
+ //followed by a module ID, pull off the plugin
+ //and put it at the end of the name, otherwise
+ //just leave it alone.
+ pluginId = parts.shift();
+ resourcePath = parts.join('!');
+ if (resourceIsModuleIdRegExp.test(resourcePath)) {
+ sourceMapPath = build.makeRelativeFilePath(refPath, require.toUrl(resourcePath)) +
+ '!' + pluginId;
+ } else {
+ sourceMapPath = path;
+ }
+ }
+
+ sourceMapLineNumber = fileContents.split('\n').length - 1;
+ lineCount = singleContents.split('\n').length;
+ for (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);
+ }
+ fileContents += singleContents;
+ return fileContents;
+ }
+
/**
* 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),
@@ -25906,7 +28389,7 @@ define('build', function (require) {
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, "/");
+ buildPaths[prop] = paths[prop] === 'empty:' ? 'empty:' : prop;
//Make sure source path is fully formed with baseUrl,
//if it is a relative URL.
@@ -25995,14 +28478,16 @@ define('build', function (require) {
//would result in modifying source. This condition can happen
//with some more tricky paths: config and appDir/baseUrl
//setting, which is a sign of incorrect config.
- if (module._buildPath === module._sourcePath) {
+ if (module._buildPath === module._sourcePath &&
+ !config.allowSourceOverwrites) {
throw new Error('Module ID \'' + module.name +
'\' has a source path that is same as output path: ' +
module._sourcePath +
'. Stopping, config is malformed.');
}
- if (!module.create) {
+ // Copy the file, but only if it is not provided in rawText.
+ if (!module.create && (!config.rawText || !lang.hasProp(config.rawText, module.name))) {
file.copyFile(module._sourcePath, module._buildPath);
}
}
@@ -26017,7 +28502,7 @@ define('build', function (require) {
buildFileContents += optimize.css(config.dir, config);
}
}).then(function() {
- baseConfig = lang.deeplikeCopy(require.s.contexts._.config);
+ baseConfig = copyConfig(require.s.contexts._.config);
}).then(function () {
var actions = [];
@@ -26124,17 +28609,36 @@ define('build', function (require) {
}));
}
}).then(function () {
- var moduleName, outOrigSourceMap;
+ var moduleName, outOrigSourceMap,
+ bundlesConfig = {},
+ bundlesConfigOutFile = config.bundlesConfigOutFile;
+
if (modules) {
//Now move the build layers to their final position.
modules.forEach(function (module) {
- var finalPath = module._buildPath;
+ var entryConfig,
+ finalPath = module._buildPath;
+
if (finalPath !== 'FUNCTION') {
if (file.exists(finalPath)) {
file.deleteFile(finalPath);
}
file.renameFile(finalPath + '-temp', finalPath);
+ //If bundles config should be written out, scan the
+ //built file for module IDs. Favor doing this reparse
+ //since tracking the IDs as the file is built has some
+ //edge cases around files that had more than one ID in
+ //them already, and likely loader plugin-written contents.
+ if (bundlesConfigOutFile) {
+ entryConfig = bundlesConfig[module.name] = [];
+ var bundleContents = file.readFile(finalPath);
+ var excludeMap = {};
+ excludeMap[module.name] = true;
+ var parsedIds = parse.getAllNamedDefines(bundleContents, excludeMap);
+ entryConfig.push.apply(entryConfig, parsedIds);
+ }
+
//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.
@@ -26161,6 +28665,24 @@ define('build', function (require) {
config.onModuleBundleComplete(module.onCompleteData);
}
});
+
+ //Write out bundles config, if it is wanted.
+ if (bundlesConfigOutFile) {
+ var text = file.readFile(bundlesConfigOutFile);
+ text = transform.modifyConfig(text, function (config) {
+ if (!config.bundles) {
+ config.bundles = {};
+ }
+
+ lang.eachProp(bundlesConfig, function (value, prop) {
+ config.bundles[prop] = value;
+ });
+
+ return config;
+ });
+
+ file.saveUtf8File(bundlesConfigOutFile, text);
+ }
}
//If removeCombined in play, remove any empty directories that
@@ -26327,7 +28849,9 @@ define('build', function (require) {
//All module layers are done, write out the build.txt file.
- file.saveUtf8File(config.dir + "build.txt", buildFileContents);
+ if (config.writeBuildTxt) {
+ file.saveUtf8File(config.dir + "build.txt", buildFileContents);
+ }
}
//If just have one CSS file to optimize, do that here.
@@ -26382,7 +28906,8 @@ define('build', function (require) {
uglify2: true,
closure: true,
map: true,
- throwWhen: true
+ throwWhen: true,
+ rawText: true
};
build.hasDotPropMatch = function (prop) {
@@ -26412,7 +28937,10 @@ define('build', function (require) {
"excludeShallow": true,
"insertRequire": true,
"stubModules": true,
- "deps": true
+ "deps": true,
+ "mainConfigFile": true,
+ "wrap.startFile": true,
+ "wrap.endFile": true
};
for (i = 0; i < ary.length; i++) {
@@ -26506,8 +29034,10 @@ define('build', function (require) {
}
}
- build.makeAbsObject(["out", "cssIn"], config, absFilePath);
+ build.makeAbsObject((config.out === "stdout" ? ["cssIn"] : ["out", "cssIn"]),
+ config, absFilePath);
build.makeAbsObject(["startFile", "endFile"], config.wrap, absFilePath);
+ build.makeAbsObject(["externExportsPath"], config.closure, absFilePath);
};
/**
@@ -26578,7 +29108,20 @@ define('build', function (require) {
if (typeof value === 'object' && value &&
!isArray && !lang.isFunction(value) &&
!lang.isRegExp(value)) {
- target[prop] = lang.mixin({}, target[prop], value, true);
+
+ // TODO: need to generalize this work, maybe also reuse
+ // the work done in requirejs configure, perhaps move to
+ // just a deep copy/merge overall. However, given the
+ // amount of observable change, wait for a dot release.
+ // This change is in relation to #645
+ if (prop === 'map') {
+ if (!target.map) {
+ target.map = {};
+ }
+ lang.deepMix(target.map, source.map);
+ } else {
+ target[prop] = lang.mixin({}, target[prop], value, true);
+ }
} else if (isArray) {
if (!skipArrays) {
// Some config, like packages, are arrays. For those,
@@ -26607,22 +29150,37 @@ define('build', function (require) {
* 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';
+ function flattenWrapFile(config, keyName, absFilePath) {
+ var wrap = config.wrap,
+ keyFileName = keyName + 'File',
+ keyMapName = '__' + keyName + 'Map';
if (typeof wrap[keyName] !== 'string' && wrap[keyFileName]) {
wrap[keyName] = '';
if (typeof wrap[keyFileName] === 'string') {
wrap[keyFileName] = [wrap[keyFileName]];
}
+ wrap[keyMapName] = [];
wrap[keyFileName].forEach(function (fileName) {
- wrap[keyName] += (wrap[keyName] ? '\n' : '') +
- file.readFile(build.makeAbsPath(fileName, absFilePath));
+ var absPath = build.makeAbsPath(fileName, absFilePath),
+ fileText = endsWithNewLine(file.readFile(absPath));
+ wrap[keyMapName].push(function (fileContents, cfg, sourceMapGenerator) {
+ return appendToFileContents(fileContents, fileText, absPath, cfg, null, sourceMapGenerator);
+ });
+ wrap[keyName] += fileText;
});
} else if (wrap[keyName] === null || wrap[keyName] === undefined) {
//Allow missing one, just set to empty string.
wrap[keyName] = '';
- } else if (typeof wrap[keyName] !== 'string') {
+ } else if (typeof wrap[keyName] === 'string') {
+ wrap[keyName] = endsWithNewLine(wrap[keyName]);
+ wrap[keyMapName] = [
+ function (fileContents, cfg, sourceMapGenerator) {
+ var absPath = build.makeAbsPath("config-wrap-" + keyName + "-default.js", absFilePath);
+ return appendToFileContents(fileContents, wrap[keyName], absPath, cfg, null, sourceMapGenerator);
+ }
+ ];
+ } else {
throw new Error('wrap.' + keyName + ' or wrap.' + keyFileName + ' malformed');
}
}
@@ -26634,12 +29192,27 @@ define('build', function (require) {
if (config.wrap === true) {
//Use default values.
config.wrap = {
- start: '(function () {',
- end: '}());'
+ start: '(function () {\n',
+ end: '}());',
+ __startMap: [
+ function (fileContents, cfg, sourceMapGenerator) {
+ return appendToFileContents(fileContents, "(function () {\n",
+ build.makeAbsPath("config-wrap-start-default.js",
+ absFilePath), cfg, null,
+ sourceMapGenerator);
+ }
+ ],
+ __endMap: [
+ function (fileContents, cfg, sourceMapGenerator) {
+ return appendToFileContents(fileContents, "}());",
+ build.makeAbsPath("config-wrap-end-default.js", absFilePath),
+ cfg, null, sourceMapGenerator);
+ }
+ ]
};
} else {
- flattenWrapFile(config.wrap, 'start', absFilePath);
- flattenWrapFile(config.wrap, 'end', absFilePath);
+ flattenWrapFile(config, 'start', absFilePath);
+ flattenWrapFile(config, 'end', absFilePath);
}
}
} catch (wrapError) {
@@ -26694,6 +29267,14 @@ define('build', function (require) {
//Load build file options.
buildFileContents = file.readFile(buildFile);
try {
+ //Be a bit lenient in the file ending in a ; or ending with
+ //a //# sourceMappingUrl comment, mostly for compiled languages
+ //that create a config, like typescript.
+ buildFileContents = buildFileContents
+ .replace(/\/\/\#[^\n\r]+[\n\r]*$/, '')
+ .trim()
+ .replace(/;$/, '');
+
buildFileConfig = eval("(" + buildFileContents + ")");
build.makeAbsConfig(buildFileConfig, absFilePath);
@@ -26789,6 +29370,29 @@ define('build', function (require) {
config.dirBaseUrl = endsWithSlash(config.dirBaseUrl);
}
+ if (config.bundlesConfigOutFile) {
+ if (!config.dir) {
+ throw new Error('bundlesConfigOutFile can only be used with optimizations ' +
+ 'that use "dir".');
+ }
+ config.bundlesConfigOutFile = build.makeAbsPath(config.bundlesConfigOutFile, config.dir);
+ }
+
+ //If out=stdout, write output to STDOUT instead of a file.
+ if (config.out && config.out === 'stdout') {
+ config.out = function (content) {
+ var e = env.get();
+ if (e === 'rhino') {
+ var out = new java.io.PrintStream(java.lang.System.out, true, 'UTF-8');
+ out.println(content);
+ } else if (e === 'node') {
+ process.stdout.write(content, 'utf8');
+ } else {
+ console.log(content);
+ }
+ };
+ }
+
//Check for errors in config
if (config.main) {
throw new Error('"main" passed as an option, but the ' +
@@ -26826,11 +29430,12 @@ define('build', function (require) {
}
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' +
+ ' Use "out" if you are targeting a single file' +
' 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
@@ -26857,17 +29462,27 @@ define('build', function (require) {
' to insert in to a require([]) call.');
}
+ //Support older configs with uglify2 settings, but now that uglify1 has
+ //been removed, just translate it to 'uglify' settings.
+ if (config.optimize === 'uglify2') {
+ config.optimize = 'uglify';
+ }
+ if (config.uglify2) {
+ config.uglify = config.uglify2;
+ delete config.uglify2;
+ }
+
if (config.generateSourceMaps) {
- if (config.preserveLicenseComments && config.optimize !== 'none') {
+ if (config.preserveLicenseComments && !(config.optimize === 'none' || config.optimize === 'uglify')) {
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: ' +
+ 'generateSourceMaps together, unless optimize is set ' +
+ 'to \'uglify\'. Either explicitly 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') {
+ config.optimize !== 'uglify') {
//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.
@@ -26926,10 +29541,15 @@ define('build', function (require) {
config.cssPrefix = '';
}
- //Cycle through modules and combine any local stubModules with
- //global values.
+ //Cycle through modules and normalize
if (config.modules && config.modules.length) {
config.modules.forEach(function (mod) {
+ if (lang.isArray(mod) || typeof mod === 'string' || !mod) {
+ throw new Error('modules config item is malformed: it should' +
+ ' be an object with a \'name\' property.');
+ }
+
+ //Combine any local stubModules with global values.
if (config.stubModules) {
mod.stubModules = config.stubModules.concat(mod.stubModules || []);
}
@@ -26943,6 +29563,12 @@ define('build', function (require) {
});
}
+ // Legacy command support, which allowed a single string ID
+ // for include.
+ if (typeof mod.include === 'string') {
+ mod.include = [mod.include];
+ }
+
//Allow wrap config in overrides, but normalize it.
if (mod.override) {
normalizeWrapConfig(mod.override, absFilePath);
@@ -26983,7 +29609,19 @@ define('build', function (require) {
file.exclusionRegExp = config.dirExclusionRegExp;
}
+ //Track the deps, but in a different key, so that they are not loaded
+ //as part of config seeding before all config is in play (#648). Was
+ //going to merge this in with "include", but include is added after
+ //the "name" target. To preserve what r.js has done previously, make
+ //sure "deps" comes before the "name".
+ if (config.deps) {
+ config._depsInclude = config.deps;
+ }
+
+
//Remove things that may cause problems in the build.
+ //deps already merged above
+ delete config.deps;
delete config.jQuery;
delete config.enforceDefine;
delete config.urlArgs;
@@ -27055,12 +29693,13 @@ define('build', function (require) {
//Put back basic config, use a fresh object for it.
if (baseLoaderConfig) {
- require(lang.deeplikeCopy(baseLoaderConfig));
+ require(copyConfig(baseLoaderConfig));
}
logger.trace("\nTracing dependencies for: " + (module.name ||
(typeof module.out === 'function' ? 'FUNCTION' : module.out)));
- include = module.name && !module.create ? [module.name] : [];
+ include = config._depsInclude || [];
+ include = include.concat(module.name && !module.create ? [module.name] : []);
if (module.include) {
include = include.concat(module.include);
}
@@ -27070,7 +29709,7 @@ define('build', function (require) {
if (baseLoaderConfig) {
override = build.createOverrideConfig(baseLoaderConfig, module.override);
} else {
- override = lang.deeplikeCopy(module.override);
+ override = copyConfig(module.override);
}
require(override);
}
@@ -27099,7 +29738,7 @@ define('build', function (require) {
var hasError = false;
if (syncChecks[env.get()]) {
try {
- build.checkForErrors(context);
+ build.checkForErrors(context, layer);
} catch (e) {
hasError = true;
deferred.reject(e);
@@ -27119,22 +29758,22 @@ define('build', function (require) {
// issue, the require never completes, need to check for errors
// here.
if (syncChecks[env.get()]) {
- build.checkForErrors(context);
+ build.checkForErrors(context, layer);
}
return deferred.promise.then(function () {
//Reset config
if (module.override && baseLoaderConfig) {
- require(lang.deeplikeCopy(baseLoaderConfig));
+ require(copyConfig(baseLoaderConfig));
}
- build.checkForErrors(context);
+ build.checkForErrors(context, layer);
return layer;
});
};
- build.checkForErrors = function (context) {
+ build.checkForErrors = function (context, layer) {
//Check to see if it all loaded. If not, then throw, and give
//a message on what is left.
var id, prop, mod, idParts, pluginId, pluginResources,
@@ -27186,8 +29825,9 @@ define('build', function (require) {
}
//Look for plugins that did not call load()
-
- if (idParts.length > 1) {
+ //But skip plugin IDs that were already inlined and called
+ //define() with a name.
+ if (!hasProp(layer.modulesWithNames, id) && idParts.length > 1) {
if (falseProp(failedPluginMap, pluginId)) {
failedPluginIds.push(pluginId);
}
@@ -27239,8 +29879,8 @@ define('build', function (require) {
};
build.createOverrideConfig = function (config, override) {
- var cfg = lang.deeplikeCopy(config),
- oride = lang.deeplikeCopy(override);
+ var cfg = copyConfig(config),
+ oride = copyConfig(override);
lang.eachProp(oride, function (value, prop) {
if (hasProp(build.objProps, prop)) {
@@ -27278,12 +29918,13 @@ define('build', function (require) {
return prim().start(function () {
var reqIndex, currContents, fileForSourceMap,
- moduleName, shim, packageMain, packageName,
+ moduleName, shim, packageName,
parts, builder, writeApi,
namespace, namespaceWithDot, stubModulesByName,
context = layer.context,
onLayerEnds = [],
- onLayerEndAdded = {};
+ onLayerEndAdded = {},
+ pkgsMainMap = {};
//Use override settings, particularly for pragmas
//Do this before the var readings since it reads config values.
@@ -27317,32 +29958,42 @@ define('build', function (require) {
if (config.generateSourceMaps) {
sourceMapBase = config.dir || config.baseUrl;
- fileForSourceMap = module._buildPath === 'FUNCTION' ?
- (module.name || module.include[0] || 'FUNCTION') + '.build.js' :
- module._buildPath.replace(sourceMapBase, '');
- sourceMapGenerator = new SourceMapGenerator.SourceMapGenerator({
+ if (module._buildPath === 'FUNCTION') {
+ fileForSourceMap = (module.name || module.include[0] || 'FUNCTION') + '.build.js';
+ } else if (config.out) {
+ fileForSourceMap = module._buildPath.split('/').pop();
+ } else {
+ fileForSourceMap = module._buildPath.replace(sourceMapBase, '');
+ }
+ sourceMapGenerator = new SourceMapGenerator({
file: fileForSourceMap
});
}
+ //Create a reverse lookup for packages main module IDs to their package
+ //names, useful for knowing when to write out define() package main ID
+ //adapters.
+ lang.eachProp(layer.context.config.pkgs, function(value, prop) {
+ pkgsMainMap[value] = prop;
+ });
+
//Write the built module to disk, and build up the build output.
fileContents = "";
+ if (config.wrap && config.wrap.__startMap) {
+ config.wrap.__startMap.forEach(function (wrapFunction) {
+ fileContents = wrapFunction(fileContents, config, sourceMapGenerator);
+ });
+ }
+
return prim.serial(layer.buildFilePaths.map(function (path) {
return function () {
- var lineCount,
- singleContents = '';
+ var singleContents = '';
moduleName = layer.buildFileToModule[path];
- packageName = moduleName.split('/').shift();
-
- //If the moduleName is for a package main, then update it to the
- //real main value.
- packageMain = layer.context.config.pkgs &&
- getOwn(layer.context.config.pkgs, packageName);
- if (packageMain !== moduleName) {
- // Not a match, clear packageMain
- packageMain = undefined;
- }
+
+ //If the moduleName is a package main, then hold on to the
+ //packageName in case an adapter needs to be written.
+ packageName = getOwn(pkgsMainMap, moduleName);
return prim().start(function () {
//Figure out if the module is a result of a build plugin, and if so,
@@ -27371,7 +30022,11 @@ define('build', function (require) {
singleContents = config.onBuildWrite(moduleName, path, singleContents);
}
};
- builder.write(parts.prefix, parts.name, writeApi);
+
+ builder.write(parts.prefix, parts.name, writeApi, {
+ name: module.onCompleteData.name,
+ path: module.onCompleteData.path
+ });
}
return;
} else {
@@ -27404,7 +30059,7 @@ define('build', function (require) {
currContents = config.onBuildRead(moduleName, path, currContents);
}
- if (packageMain) {
+ if (packageName) {
hasPackageName = (packageName === parse.getNamedDefine(currContents));
}
@@ -27416,7 +30071,7 @@ define('build', function (require) {
useSourceUrl: config.useSourceUrl
});
- if (packageMain && !hasPackageName) {
+ if (packageName && !hasPackageName) {
currContents = addSemiColon(currContents, config) + '\n';
currContents += namespaceWithDot + "define('" +
packageName + "', ['" + moduleName +
@@ -27433,9 +30088,7 @@ define('build', function (require) {
});
}
}).then(function () {
- var refPath, pluginId, resourcePath,
- sourceMapPath, sourceMapLineNumber,
- shortPath = path.replace(config.dir, "");
+ var shimDeps, shortPath = path.replace(config.dir, "");
module.onCompleteData.included.push(shortPath);
buildFileContents += shortPath + "\n";
@@ -27445,24 +30098,29 @@ define('build', function (require) {
//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) || (packageMain && getOwn(config.shim, moduleName) || getOwn(config.shim, packageName)));
+ shim = config.shim && (getOwn(config.shim, moduleName) || (packageName && getOwn(config.shim, packageName)));
if (shim) {
+ shimDeps = lang.isArray(shim) ? shim : shim.deps;
if (config.wrapShim) {
- singleContents = '(function(root) {' +
- '\n' + namespaceWithDot + 'define("' + moduleName + '", ' +
- (shim.deps && shim.deps.length ?
- build.makeJsArrayString(shim.deps) + ', ' : '[], ') +
+
+ singleContents = '(function(root) {\n' +
+ namespaceWithDot + 'define("' + moduleName + '", ' +
+ (shimDeps && shimDeps.length ?
+ build.makeJsArrayString(shimDeps) + ', ' : '[], ') +
'function() {\n' +
- ' return (function() {\n' +
+ ' return (function() {\n' +
singleContents +
- (shim.exportsFn ? shim.exportsFn() : '') +
- ' }).apply(root, arguments);\n' +
- ' });\n' +
+ // Start with a \n in case last line is a comment
+ // in the singleContents, like a sourceURL comment.
+ '\n' + (shim.exportsFn ? shim.exportsFn() : '') +
+ '\n' +
+ ' }).apply(root, arguments);\n' +
+ '});\n' +
'}(this));\n';
} else {
singleContents += '\n' + namespaceWithDot + 'define("' + moduleName + '", ' +
- (shim.deps && shim.deps.length ?
- build.makeJsArrayString(shim.deps) + ', ' : '') +
+ (shimDeps && shimDeps.length ?
+ build.makeJsArrayString(shimDeps) + ', ' : '') +
(shim.exportsFn ? shim.exportsFn() : 'function(){}') +
');\n';
}
@@ -27477,58 +30135,14 @@ define('build', function (require) {
//for concatenation would cause an error otherwise.
singleContents += '\n';
- //Add to the source map
- if (sourceMapGenerator) {
- refPath = config.out ? config.baseUrl : module._buildPath;
- parts = path.split('!');
- if (parts.length === 1) {
- //Not a plugin resource, fix the path
- sourceMapPath = build.makeRelativeFilePath(refPath, path);
- } else {
- //Plugin resource. If it looks like just a plugin
- //followed by a module ID, pull off the plugin
- //and put it at the end of the name, otherwise
- //just leave it alone.
- pluginId = parts.shift();
- resourcePath = parts.join('!');
- if (resourceIsModuleIdRegExp.test(resourcePath)) {
- sourceMapPath = build.makeRelativeFilePath(refPath, require.toUrl(resourcePath)) +
- '!' + pluginId;
- } else {
- sourceMapPath = 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;
+ //Add to the source map and to the final contents
+ fileContents = appendToFileContents(fileContents, singleContents, path, config, module,
+ sourceMapGenerator);
});
};
})).then(function () {
if (onLayerEnds.length) {
- onLayerEnds.forEach(function (builder) {
+ onLayerEnds.forEach(function (builder, index) {
var path;
if (typeof module.out === 'string') {
path = module.out;
@@ -27536,7 +30150,9 @@ define('build', function (require) {
path = module._buildPath;
}
builder.onLayerEnd(function (input) {
- fileContents += "\n" + addSemiColon(input, config);
+ fileContents =
+ appendToFileContents(fileContents, "\n" + addSemiColon(input, config),
+ 'onLayerEnd' + index + '.js', config, module, sourceMapGenerator);
}, {
name: module.name,
path: path
@@ -27549,21 +30165,30 @@ define('build', function (require) {
//a module definition for it in case the
//built file is used with enforceDefine
//(#432)
- fileContents += '\n' + namespaceWithDot + 'define("' + module.name + '", function(){});\n';
+ fileContents =
+ appendToFileContents(fileContents, '\n' + namespaceWithDot + 'define("' + module.name +
+ '", function(){});\n', 'module-create.js', config, module,
+ sourceMapGenerator);
}
//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';
+ fileContents =
+ appendToFileContents(fileContents, '\n' + namespaceWithDot + 'require(["' + module.insertRequire.join('", "') +
+ '"]);\n', 'module-insertRequire.js', config, module,
+ sourceMapGenerator);
}
});
}).then(function () {
+ if (config.wrap && config.wrap.__endMap) {
+ config.wrap.__endMap.forEach(function (wrapFunction) {
+ fileContents = wrapFunction(fileContents, config, sourceMapGenerator);
+ });
+ }
return {
- text: config.wrap ?
- config.wrap.start + fileContents + config.wrap.end :
- fileContents,
+ text: fileContents,
buildText: buildFileContents,
sourceMap: sourceMapGenerator ?
JSON.stringify(sourceMapGenerator.toJSON(), null, ' ') :
@@ -27735,13 +30360,7 @@ define('build', function (require) {
//Do the optimizer work.
loadLib();
- /**
- * @license Copyright (c) 2010-2014, 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.
*/
@@ -27769,7 +30388,7 @@ function (args, quit, logger, build) {
} else if (commandOption === 'v') {
console.log('r.js: ' + version +
', RequireJS: ' + this.requirejsVars.require.version +
- ', UglifyJS2: 2.4.12, UglifyJS: 1.3.4');
+ ', UglifyJS: 2.8.29');
} else if (commandOption === 'convert') {
loadLib();
diff --git a/www/js/lib/require.js b/www/js/lib/require.js
index 24b061e..78490f9 100644
--- a/www/js/lib/require.js
+++ b/www/js/lib/require.js
@@ -1,7 +1,6 @@
/** vim: et:ts=4:sw=4:sts=4
- * @license RequireJS 2.1.11 Copyright (c) 2010-2014, The Dojo Foundation All Rights Reserved.
- * Available via the MIT or new BSD license.
- * see: http://github.com/jrburke/requirejs for details
+ * @license RequireJS 2.3.6 Copyright jQuery Foundation and other contributors.
+ * Released under MIT license, https://github.com/requirejs/requirejs/blob/master/LICENSE
*/
//Not using strict: uneven strict support in browsers, #392, and causes
//problems with requirejs.exec()/transpiler plugins that may not be strict.
@@ -9,19 +8,17 @@
/*global window, navigator, document, importScripts, setTimeout, opera */
var requirejs, require, define;
-(function (global) {
+(function (global, setTimeout) {
var req, s, head, baseElement, dataMain, src,
interactiveScript, currentlyAddingScript, mainScript, subPath,
- version = '2.1.11',
- commentRegExp = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/mg,
+ version = '2.3.6',
+ 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' && typeof navigator !== 'undefined' && window.document),
isWebWorker = !isBrowser && typeof importScripts !== 'undefined',
//PS3 indicates loaded and complete, but need to wait for complete
@@ -38,6 +35,11 @@ var requirejs, require, define;
globalDefQueue = [],
useInteractive = false;
+ //Could match something like ')//comment', do not lose the prefix to comment.
+ function commentReplace(match, singlePrefix) {
+ return singlePrefix || '';
+ }
+
function isFunction(it) {
return ostring.call(it) === '[object Function]';
}
@@ -163,7 +165,7 @@ var requirejs, require, define;
* @returns {Error}
*/
function makeError(id, msg, err, requireModules) {
- var e = new Error(msg + '\nhttp://requirejs.org/docs/errors.html#' + id);
+ var e = new Error(msg + '\nhttps://requirejs.org/docs/errors.html#' + id);
e.requireType = id;
e.requireModules = requireModules;
if (err) {
@@ -180,7 +182,7 @@ var requirejs, require, define;
if (typeof requirejs !== 'undefined') {
if (isFunction(requirejs)) {
- //Do not overwrite and existing requirejs instance.
+ //Do not overwrite an existing requirejs instance.
return;
}
cfg = requirejs;
@@ -232,21 +234,20 @@ var requirejs, require, define;
* @param {Array} ary the array of path segments.
*/
function trimDots(ary) {
- var i, part, length = ary.length;
- for (i = 0; i < length; i++) {
+ var i, part;
+ for (i = 0; i < ary.length; i++) {
part = ary[i];
if (part === '.') {
ary.splice(i, 1);
i -= 1;
} else if (part === '..') {
- if (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;
+ // If at the start, or previous value is still ..,
+ // keep them so that when converted to a path it may
+ // still work when converted to a path, even though
+ // as an ID it is less than ideal. In larger point
+ // releases, may be better to just kick out an error.
+ if (i === 0 || (i === 1 && ary[2] === '..') || ary[i - 1] === '..') {
+ continue;
} else if (i > 0) {
ary.splice(i - 1, 2);
i -= 2;
@@ -267,43 +268,37 @@ var requirejs, require, define;
*/
function normalize(name, baseName, applyMap) {
var pkgMain, mapValue, nameParts, i, j, nameSegment, lastIndex,
- foundMap, foundI, foundStarMap, starI,
- baseParts = baseName && baseName.split('/'),
- normalizedBaseParts = baseParts,
+ foundMap, foundI, foundStarMap, starI, normalizedBaseParts,
+ baseParts = (baseName && baseName.split('/')),
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 (name) {
+ name = name.split('/');
+ lastIndex = name.length - 1;
+
+ // If wanting node ID compatibility, strip .js from end
+ // of IDs. Have to do this here, and not in nameToUrl
+ // because node allows either .js or non .js to map
+ // to same file.
+ if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
+ name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
+ }
+
+ // Starts with a '.' so need the baseName
+ if (name[0].charAt(0) === '.' && baseParts) {
//Convert baseName to array, and lop off the last part,
//so that . matches that 'directory' and not name of the baseName's
//module. For instance, baseName of 'one/two/three', maps to
//'one/two/three.js', but we want the directory, 'one/two' for
//this normalization.
normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
- name = name.split('/');
- lastIndex = name.length - 1;
-
- // If wanting node ID compatibility, strip .js from end
- // of IDs. Have to do this here, and not in nameToUrl
- // because node allows either .js or non .js to map
- // to same file.
- if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
- name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
- }
-
name = normalizedBaseParts.concat(name);
- trimDots(name);
- name = name.join('/');
- } 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);
}
+
+ trimDots(name);
+ name = name.join('/');
}
//Apply map config if available.
@@ -379,7 +374,13 @@ var requirejs, require, define;
//retry
pathConfig.shift();
context.require.undef(id);
- context.require([id]);
+
+ //Custom require that does not do map translation, since
+ //ID is "absolute", already mapped/resolved.
+ context.makeRequire(null, {
+ skipMap: true
+ })([id]);
+
return true;
}
}
@@ -439,13 +440,24 @@ var requirejs, require, define;
//Account for relative paths if there is a base name.
if (name) {
if (prefix) {
- if (pluginModule && pluginModule.normalize) {
+ if (isNormalized) {
+ normalizedName = name;
+ } else if (pluginModule && pluginModule.normalize) {
//Plugin is loaded, use its normalize method.
normalizedName = pluginModule.normalize(name, function (name) {
return normalize(name, parentName, applyMap);
});
} else {
- normalizedName = normalize(name, parentName, applyMap);
+ // If nested plugin references, then do not try to
+ // normalize, as it will not normalize correctly. This
+ // places a restriction on resourceIds, and the longer
+ // term solution is not to normalize until plugins are
+ // loaded and all normalizations to allow for async
+ // loading of a loader plugin. But for now, fixes the
+ // common uses. Details in #1131
+ normalizedName = name.indexOf('!') === -1 ?
+ normalize(name, parentName, applyMap) :
+ name;
}
} else {
//A regular module.
@@ -546,11 +558,13 @@ var requirejs, require, define;
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, 0].concat(globalDefQueue));
+ each(globalDefQueue, function(queueItem) {
+ var id = queueItem[0];
+ if (typeof id === 'string') {
+ context.defQueueMap[id] = true;
+ }
+ defQueue.push(queueItem);
+ });
globalDefQueue = [];
}
}
@@ -581,7 +595,7 @@ var requirejs, require, define;
id: mod.map.id,
uri: mod.map.url,
config: function () {
- return getOwn(config.config, mod.map.id) || {};
+ return getOwn(config.config, mod.map.id) || {};
},
exports: mod.exports || (mod.exports = {})
});
@@ -837,7 +851,10 @@ var requirejs, require, define;
factory = this.factory;
if (!this.inited) {
- this.fetch();
+ // Only fetch if not already in the defQueue.
+ if (!hasProp(context.defQueueMap, id)) {
+ this.fetch();
+ }
} else if (this.error) {
this.emit('error', this.error);
} else if (!this.defining) {
@@ -897,7 +914,11 @@ var requirejs, require, define;
defined[id] = exports;
if (req.onResourceLoad) {
- req.onResourceLoad(context, this.map, this.depMaps);
+ var resLoadMaps = [];
+ each(this.depMaps, function (depMap) {
+ resLoadMaps.push(depMap.normalizedMap || depMap);
+ });
+ req.onResourceLoad(context, this.map, resLoadMaps);
}
}
@@ -953,9 +974,11 @@ var requirejs, require, define;
//prefix and name should already be normalized, no need
//for applying map config again either.
normalizedMap = makeModuleMap(map.prefix + '!' + name,
- this.map.parentMap);
+ this.map.parentMap,
+ true);
on(normalizedMap,
'defined', bind(this, function (value) {
+ this.map.normalizedMap = normalizedMap;
this.init([], function () { return value; }, null, {
enabled: true,
ignore: true
@@ -1109,12 +1132,22 @@ var requirejs, require, define;
this.depCount += 1;
on(depMap, 'defined', bind(this, function (depExports) {
+ if (this.undefed) {
+ return;
+ }
this.defineDep(i, depExports);
this.check();
}));
if (this.errback) {
on(depMap, 'error', bind(this, this.errback));
+ } else if (this.events.error) {
+ // No direct errback on this module, but something
+ // else is listening for errors, so be sure to
+ // propagate the error correctly.
+ on(depMap, 'error', bind(this, function(err) {
+ this.emit('error', err);
+ }));
}
}
@@ -1218,13 +1251,15 @@ var requirejs, require, define;
while (defQueue.length) {
args = defQueue.shift();
if (args[0] === null) {
- return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' + args[args.length - 1]));
+ return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' +
+ args[args.length - 1]));
} else {
//args are id, deps, factory. Should be normalized by the
//define() function.
callGetModule(args);
}
}
+ context.defQueueMap = {};
}
context = {
@@ -1234,6 +1269,7 @@ var requirejs, require, define;
defined: defined,
urlFetched: urlFetched,
defQueue: defQueue,
+ defQueueMap: {},
Module: Module,
makeModuleMap: makeModuleMap,
nextTick: req.nextTick,
@@ -1251,6 +1287,14 @@ var requirejs, require, define;
}
}
+ // Convert old style urlArgs string to a function.
+ if (typeof cfg.urlArgs === 'string') {
+ var urlArgs = cfg.urlArgs;
+ cfg.urlArgs = function(id, url) {
+ return (url.indexOf('?') === -1 ? '?' : '&') + urlArgs;
+ };
+ }
+
//Save off the paths since they require special processing,
//they are additive.
var shim = config.shim,
@@ -1305,7 +1349,7 @@ var requirejs, require, define;
each(cfg.packages, function (pkgObj) {
var location, name;
- pkgObj = typeof pkgObj === 'string' ? { name: pkgObj } : pkgObj;
+ pkgObj = typeof pkgObj === 'string' ? {name: pkgObj} : pkgObj;
name = pkgObj.name;
location = pkgObj.location;
@@ -1332,7 +1376,7 @@ var requirejs, require, define;
//late to modify them, and ignore unnormalized ones
//since they are transient.
if (!mod.inited && !mod.map.unnormalized) {
- mod.map = makeModuleMap(id);
+ mod.map = makeModuleMap(id, null, true);
}
});
@@ -1468,6 +1512,7 @@ var requirejs, require, define;
var map = makeModuleMap(id, relMap, true),
mod = getOwn(registry, id);
+ mod.undefed = true;
removeScript(id);
delete defined[id];
@@ -1478,10 +1523,11 @@ var requirejs, require, define;
//in array so that the splices do not
//mess up the iteration.
eachReverse(defQueue, function(args, i) {
- if(args[0] === id) {
+ if (args[0] === id) {
defQueue.splice(i, 1);
}
});
+ delete context.defQueueMap[id];
if (mod) {
//Hold on to listeners in case the
@@ -1543,6 +1589,7 @@ var requirejs, require, define;
callGetModule(args);
}
+ context.defQueueMap = {};
//Do this after the cycle of callGetModule in case the result
//of those calls/init calls changes the registry.
@@ -1624,13 +1671,12 @@ var requirejs, require, define;
//Join the path parts together, then figure out if baseUrl is needed.
url = syms.join('/');
- url += (ext || (/^data\:|\?/.test(url) || skipExt ? '' : '.js'));
+ url += (ext || (/^data\:|^blob\:|\?/.test(url) || skipExt ? '' : '.js'));
url = (url.charAt(0) === '/' || url.match(/^[\w\+\.\-]+:/) ? '' : config.baseUrl) + url;
}
- return config.urlArgs ? url +
- ((url.indexOf('?') === -1 ? '?' : '&') +
- config.urlArgs) : url;
+ return config.urlArgs && !/^blob\:/.test(url) ?
+ url + config.urlArgs(moduleName, url) : url;
},
//Delegates to req.load. Broken out as a separate function to
@@ -1678,7 +1724,21 @@ var requirejs, require, define;
onScriptError: function (evt) {
var data = getScriptData(evt);
if (!hasPathFallback(data.id)) {
- return onError(makeError('scripterror', 'Script error for: ' + data.id, evt, [data.id]));
+ var parents = [];
+ eachProp(registry, function(value, key) {
+ if (key.indexOf('_@r') !== 0) {
+ each(value.depMaps, function(depMap) {
+ if (depMap.id === data.id) {
+ parents.push(key);
+ return true;
+ }
+ });
+ }
+ });
+ return onError(makeError('scripterror', 'Script error for "' + data.id +
+ (parents.length ?
+ '", needed by: ' + parents.join(', ') :
+ '"'), evt, [data.id]));
}
}
};
@@ -1852,11 +1912,11 @@ var requirejs, require, define;
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
+ //read https://github.com/requirejs/requirejs/issues/187
//if we can NOT find [native code] then it must NOT natively supported.
//in IE8, node.attachEvent does not have toString()
//Note the test for "[native code" with no closing brace, see:
- //https://github.com/jrburke/requirejs/issues/273
+ //https://github.com/requirejs/requirejs/issues/273
!(node.attachEvent.toString && node.attachEvent.toString().indexOf('[native code') < 0) &&
!isOpera) {
//Probably IE. IE (at least 6-8) do not fire
@@ -1884,6 +1944,12 @@ var requirejs, require, define;
}
node.src = url;
+ //Calling onNodeCreated after all properties on the node have been
+ //set, but before it is placed in the DOM.
+ if (config.onNodeCreated) {
+ config.onNodeCreated(node, config, moduleName, url);
+ }
+
//For some cache cases in IE 6-8, the script executes before the end
//of the appendChild execution, so to tie an anonymous define
//call to the module name (which is stored on the node), hold on
@@ -1902,9 +1968,14 @@ var requirejs, require, define;
//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.
+ //are in play, the expectation is that a build has been done so
+ //that only one script needs to be loaded anyway. This may need
+ //to be reevaluated if other use cases become common.
+
+ // Post a task to the event loop to work around a bug in WebKit
+ // where the worker gets garbage-collected after calling
+ // importScripts(): https://webkit.org/b/153317
+ setTimeout(function() {}, 0);
importScripts(url);
//Account for anonymous modules
@@ -1950,8 +2021,10 @@ var requirejs, require, define;
//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) {
+ //Set final baseUrl if there is not already an explicit one,
+ //but only do so if the data-main value is not a loader plugin
+ //module ID.
+ if (!cfg.baseUrl && mainScript.indexOf('!') === -1) {
//Pull off the directory of data-main for use as the
//baseUrl.
src = mainScript.split('/');
@@ -1965,7 +2038,7 @@ var requirejs, require, define;
//like a module name.
mainScript = mainScript.replace(jsSuffixRegExp, '');
- //If mainScript is still a path, fall back to dataMain
+ //If mainScript is still a path, fall back to dataMain
if (req.jsExtRegExp.test(mainScript)) {
mainScript = dataMain;
}
@@ -2012,7 +2085,7 @@ var requirejs, require, define;
if (callback.length) {
callback
.toString()
- .replace(commentRegExp, '')
+ .replace(commentRegExp, commentReplace)
.replace(cjsRequireRegExp, function (match, dep) {
deps.push(dep);
});
@@ -2044,14 +2117,18 @@ var requirejs, require, define;
//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]);
+ if (context) {
+ context.defQueue.push([name, deps, callback]);
+ context.defQueueMap[name] = true;
+ } else {
+ globalDefQueue.push([name, deps, callback]);
+ }
};
define.amd = {
jQuery: true
};
-
/**
* Executes the text. Normally just uses eval, but can be modified
* to use a better, environment-specific call. Only used for transpiling
@@ -2065,4 +2142,4 @@ var requirejs, require, define;
//Set up with config info.
req(cfg);
-}(this));
+}(this, (typeof setTimeout === 'undefined' ? undefined : setTimeout)));