| // Generated by CommonJS Everywhere 0.9.7 |
| (function (global) { |
| function require(file, parentModule) { |
| if ({}.hasOwnProperty.call(require.cache, file)) |
| return require.cache[file]; |
| var resolved = require.resolve(file); |
| if (!resolved) |
| throw new Error('Failed to resolve module ' + file); |
| var module$ = { |
| id: file, |
| require: require, |
| filename: file, |
| exports: {}, |
| loaded: false, |
| parent: parentModule, |
| children: [] |
| }; |
| if (parentModule) |
| parentModule.children.push(module$); |
| var dirname = file.slice(0, file.lastIndexOf('/') + 1); |
| require.cache[file] = module$.exports; |
| resolved.call(module$.exports, module$, module$.exports, dirname, file); |
| module$.loaded = true; |
| return require.cache[file] = module$.exports; |
| } |
| require.modules = {}; |
| require.cache = {}; |
| require.resolve = function (file) { |
| return {}.hasOwnProperty.call(require.modules, file) ? require.modules[file] : void 0; |
| }; |
| require.define = function (file, fn) { |
| require.modules[file] = fn; |
| }; |
| var process = function () { |
| var cwd = '/'; |
| return { |
| title: 'browser', |
| version: 'v4.1.1', |
| browser: true, |
| env: {}, |
| argv: [], |
| nextTick: global.setImmediate || function (fn) { |
| setTimeout(fn, 0); |
| }, |
| cwd: function () { |
| return cwd; |
| }, |
| chdir: function (dir) { |
| cwd = dir; |
| } |
| }; |
| }(); |
| require.define('/tools/entry-point.js', function (module, exports, __dirname, __filename) { |
| (function () { |
| 'use strict'; |
| global.escodegen = require('/escodegen.js', module); |
| escodegen.browser = true; |
| }()); |
| }); |
| require.define('/escodegen.js', function (module, exports, __dirname, __filename) { |
| (function () { |
| 'use strict'; |
| var Syntax, Precedence, BinaryPrecedence, SourceNode, estraverse, esutils, isArray, base, indent, json, renumber, hexadecimal, quotes, escapeless, newline, space, parentheses, semicolons, safeConcatenation, directive, extra, parse, sourceMap, sourceCode, preserveBlankLines, FORMAT_MINIFY, FORMAT_DEFAULTS; |
| estraverse = require('/node_modules/estraverse/estraverse.js', module); |
| esutils = require('/node_modules/esutils/lib/utils.js', module); |
| Syntax = estraverse.Syntax; |
| function isExpression(node) { |
| return CodeGenerator.Expression.hasOwnProperty(node.type); |
| } |
| function isStatement(node) { |
| return CodeGenerator.Statement.hasOwnProperty(node.type); |
| } |
| Precedence = { |
| Sequence: 0, |
| Yield: 1, |
| Await: 1, |
| Assignment: 1, |
| Conditional: 2, |
| ArrowFunction: 2, |
| LogicalOR: 3, |
| LogicalAND: 4, |
| BitwiseOR: 5, |
| BitwiseXOR: 6, |
| BitwiseAND: 7, |
| Equality: 8, |
| Relational: 9, |
| BitwiseSHIFT: 10, |
| Additive: 11, |
| Multiplicative: 12, |
| Unary: 13, |
| Postfix: 14, |
| Call: 15, |
| New: 16, |
| TaggedTemplate: 17, |
| Member: 18, |
| Primary: 19 |
| }; |
| BinaryPrecedence = { |
| '||': Precedence.LogicalOR, |
| '&&': Precedence.LogicalAND, |
| '|': Precedence.BitwiseOR, |
| '^': Precedence.BitwiseXOR, |
| '&': Precedence.BitwiseAND, |
| '==': Precedence.Equality, |
| '!=': Precedence.Equality, |
| '===': Precedence.Equality, |
| '!==': Precedence.Equality, |
| 'is': Precedence.Equality, |
| 'isnt': Precedence.Equality, |
| '<': Precedence.Relational, |
| '>': Precedence.Relational, |
| '<=': Precedence.Relational, |
| '>=': Precedence.Relational, |
| 'in': Precedence.Relational, |
| 'instanceof': Precedence.Relational, |
| '<<': Precedence.BitwiseSHIFT, |
| '>>': Precedence.BitwiseSHIFT, |
| '>>>': Precedence.BitwiseSHIFT, |
| '+': Precedence.Additive, |
| '-': Precedence.Additive, |
| '*': Precedence.Multiplicative, |
| '%': Precedence.Multiplicative, |
| '/': Precedence.Multiplicative |
| }; |
| var F_ALLOW_IN = 1, F_ALLOW_CALL = 1 << 1, F_ALLOW_UNPARATH_NEW = 1 << 2, F_FUNC_BODY = 1 << 3, F_DIRECTIVE_CTX = 1 << 4, F_SEMICOLON_OPT = 1 << 5; |
| var E_FTT = F_ALLOW_CALL | F_ALLOW_UNPARATH_NEW, E_TTF = F_ALLOW_IN | F_ALLOW_CALL, E_TTT = F_ALLOW_IN | F_ALLOW_CALL | F_ALLOW_UNPARATH_NEW, E_TFF = F_ALLOW_IN, E_FFT = F_ALLOW_UNPARATH_NEW, E_TFT = F_ALLOW_IN | F_ALLOW_UNPARATH_NEW; |
| var S_TFFF = F_ALLOW_IN, S_TFFT = F_ALLOW_IN | F_SEMICOLON_OPT, S_FFFF = 0, S_TFTF = F_ALLOW_IN | F_DIRECTIVE_CTX, S_TTFF = F_ALLOW_IN | F_FUNC_BODY; |
| function getDefaultOptions() { |
| return { |
| indent: null, |
| base: null, |
| parse: null, |
| comment: false, |
| format: { |
| indent: { |
| style: ' ', |
| base: 0, |
| adjustMultilineComment: false |
| }, |
| newline: '\n', |
| space: ' ', |
| json: false, |
| renumber: false, |
| hexadecimal: false, |
| quotes: 'single', |
| escapeless: false, |
| compact: false, |
| parentheses: true, |
| semicolons: true, |
| safeConcatenation: false, |
| preserveBlankLines: false |
| }, |
| moz: { |
| comprehensionExpressionStartsWithAssignment: false, |
| starlessGenerator: false |
| }, |
| sourceMap: null, |
| sourceMapRoot: null, |
| sourceMapWithCode: false, |
| directive: false, |
| raw: true, |
| verbatim: null, |
| sourceCode: null |
| }; |
| } |
| function stringRepeat(str, num) { |
| var result = ''; |
| for (num |= 0; num > 0; num >>>= 1, str += str) { |
| if (num & 1) { |
| result += str; |
| } |
| } |
| return result; |
| } |
| isArray = Array.isArray; |
| if (!isArray) { |
| isArray = function isArray(array) { |
| return Object.prototype.toString.call(array) === '[object Array]'; |
| }; |
| } |
| function hasLineTerminator(str) { |
| return /[\r\n]/g.test(str); |
| } |
| function endsWithLineTerminator(str) { |
| var len = str.length; |
| return len && esutils.code.isLineTerminator(str.charCodeAt(len - 1)); |
| } |
| function merge(target, override) { |
| var key; |
| for (key in override) { |
| if (override.hasOwnProperty(key)) { |
| target[key] = override[key]; |
| } |
| } |
| return target; |
| } |
| function updateDeeply(target, override) { |
| var key, val; |
| function isHashObject(target) { |
| return typeof target === 'object' && target instanceof Object && !(target instanceof RegExp); |
| } |
| for (key in override) { |
| if (override.hasOwnProperty(key)) { |
| val = override[key]; |
| if (isHashObject(val)) { |
| if (isHashObject(target[key])) { |
| updateDeeply(target[key], val); |
| } else { |
| target[key] = updateDeeply({}, val); |
| } |
| } else { |
| target[key] = val; |
| } |
| } |
| } |
| return target; |
| } |
| function generateNumber(value) { |
| var result, point, temp, exponent, pos; |
| if (value !== value) { |
| throw new Error('Numeric literal whose value is NaN'); |
| } |
| if (value < 0 || value === 0 && 1 / value < 0) { |
| throw new Error('Numeric literal whose value is negative'); |
| } |
| if (value === 1 / 0) { |
| return json ? 'null' : renumber ? '1e400' : '1e+400'; |
| } |
| result = '' + value; |
| if (!renumber || result.length < 3) { |
| return result; |
| } |
| point = result.indexOf('.'); |
| if (!json && result.charCodeAt(0) === 48 && point === 1) { |
| point = 0; |
| result = result.slice(1); |
| } |
| temp = result; |
| result = result.replace('e+', 'e'); |
| exponent = 0; |
| if ((pos = temp.indexOf('e')) > 0) { |
| exponent = +temp.slice(pos + 1); |
| temp = temp.slice(0, pos); |
| } |
| if (point >= 0) { |
| exponent -= temp.length - point - 1; |
| temp = +(temp.slice(0, point) + temp.slice(point + 1)) + ''; |
| } |
| pos = 0; |
| while (temp.charCodeAt(temp.length + pos - 1) === 48) { |
| --pos; |
| } |
| if (pos !== 0) { |
| exponent -= pos; |
| temp = temp.slice(0, pos); |
| } |
| if (exponent !== 0) { |
| temp += 'e' + exponent; |
| } |
| if ((temp.length < result.length || hexadecimal && value > 1e12 && Math.floor(value) === value && (temp = '0x' + value.toString(16)).length < result.length) && +temp === value) { |
| result = temp; |
| } |
| return result; |
| } |
| function escapeRegExpCharacter(ch, previousIsBackslash) { |
| if ((ch & ~1) === 8232) { |
| return (previousIsBackslash ? 'u' : '\\u') + (ch === 8232 ? '2028' : '2029'); |
| } else if (ch === 10 || ch === 13) { |
| return (previousIsBackslash ? '' : '\\') + (ch === 10 ? 'n' : 'r'); |
| } |
| return String.fromCharCode(ch); |
| } |
| function generateRegExp(reg) { |
| var match, result, flags, i, iz, ch, characterInBrack, previousIsBackslash; |
| result = reg.toString(); |
| if (reg.source) { |
| match = result.match(/\/([^\/]*)$/); |
| if (!match) { |
| return result; |
| } |
| flags = match[1]; |
| result = ''; |
| characterInBrack = false; |
| previousIsBackslash = false; |
| for (i = 0, iz = reg.source.length; i < iz; ++i) { |
| ch = reg.source.charCodeAt(i); |
| if (!previousIsBackslash) { |
| if (characterInBrack) { |
| if (ch === 93) { |
| characterInBrack = false; |
| } |
| } else { |
| if (ch === 47) { |
| result += '\\'; |
| } else if (ch === 91) { |
| characterInBrack = true; |
| } |
| } |
| result += escapeRegExpCharacter(ch, previousIsBackslash); |
| previousIsBackslash = ch === 92; |
| } else { |
| result += escapeRegExpCharacter(ch, previousIsBackslash); |
| previousIsBackslash = false; |
| } |
| } |
| return '/' + result + '/' + flags; |
| } |
| return result; |
| } |
| function escapeAllowedCharacter(code, next) { |
| var hex; |
| if (code === 8) { |
| return '\\b'; |
| } |
| if (code === 12) { |
| return '\\f'; |
| } |
| if (code === 9) { |
| return '\\t'; |
| } |
| hex = code.toString(16).toUpperCase(); |
| if (json || code > 255) { |
| return '\\u' + '0000'.slice(hex.length) + hex; |
| } else if (code === 0 && !esutils.code.isDecimalDigit(next)) { |
| return '\\0'; |
| } else if (code === 11) { |
| return '\\x0B'; |
| } else { |
| return '\\x' + '00'.slice(hex.length) + hex; |
| } |
| } |
| function escapeDisallowedCharacter(code) { |
| if (code === 92) { |
| return '\\\\'; |
| } |
| if (code === 10) { |
| return '\\n'; |
| } |
| if (code === 13) { |
| return '\\r'; |
| } |
| if (code === 8232) { |
| return '\\u2028'; |
| } |
| if (code === 8233) { |
| return '\\u2029'; |
| } |
| throw new Error('Incorrectly classified character'); |
| } |
| function escapeDirective(str) { |
| var i, iz, code, quote; |
| quote = quotes === 'double' ? '"' : "'"; |
| for (i = 0, iz = str.length; i < iz; ++i) { |
| code = str.charCodeAt(i); |
| if (code === 39) { |
| quote = '"'; |
| break; |
| } else if (code === 34) { |
| quote = "'"; |
| break; |
| } else if (code === 92) { |
| ++i; |
| } |
| } |
| return quote + str + quote; |
| } |
| function escapeString(str) { |
| var result = '', i, len, code, singleQuotes = 0, doubleQuotes = 0, single, quote; |
| for (i = 0, len = str.length; i < len; ++i) { |
| code = str.charCodeAt(i); |
| if (code === 39) { |
| ++singleQuotes; |
| } else if (code === 34) { |
| ++doubleQuotes; |
| } else if (code === 47 && json) { |
| result += '\\'; |
| } else if (esutils.code.isLineTerminator(code) || code === 92) { |
| result += escapeDisallowedCharacter(code); |
| continue; |
| } else if (!esutils.code.isIdentifierPartES5(code) && (json && code < 32 || !json && !escapeless && (code < 32 || code > 126))) { |
| result += escapeAllowedCharacter(code, str.charCodeAt(i + 1)); |
| continue; |
| } |
| result += String.fromCharCode(code); |
| } |
| single = !(quotes === 'double' || quotes === 'auto' && doubleQuotes < singleQuotes); |
| quote = single ? "'" : '"'; |
| if (!(single ? singleQuotes : doubleQuotes)) { |
| return quote + result + quote; |
| } |
| str = result; |
| result = quote; |
| for (i = 0, len = str.length; i < len; ++i) { |
| code = str.charCodeAt(i); |
| if (code === 39 && single || code === 34 && !single) { |
| result += '\\'; |
| } |
| result += String.fromCharCode(code); |
| } |
| return result + quote; |
| } |
| function flattenToString(arr) { |
| var i, iz, elem, result = ''; |
| for (i = 0, iz = arr.length; i < iz; ++i) { |
| elem = arr[i]; |
| result += isArray(elem) ? flattenToString(elem) : elem; |
| } |
| return result; |
| } |
| function toSourceNodeWhenNeeded(generated, node) { |
| if (!sourceMap) { |
| if (isArray(generated)) { |
| return flattenToString(generated); |
| } else { |
| return generated; |
| } |
| } |
| if (node == null) { |
| if (generated instanceof SourceNode) { |
| return generated; |
| } else { |
| node = {}; |
| } |
| } |
| if (node.loc == null) { |
| return new SourceNode(null, null, sourceMap, generated, node.name || null); |
| } |
| return new SourceNode(node.loc.start.line, node.loc.start.column, sourceMap === true ? node.loc.source || null : sourceMap, generated, node.name || null); |
| } |
| function noEmptySpace() { |
| return space ? space : ' '; |
| } |
| function join(left, right) { |
| var leftSource, rightSource, leftCharCode, rightCharCode; |
| leftSource = toSourceNodeWhenNeeded(left).toString(); |
| if (leftSource.length === 0) { |
| return [right]; |
| } |
| rightSource = toSourceNodeWhenNeeded(right).toString(); |
| if (rightSource.length === 0) { |
| return [left]; |
| } |
| leftCharCode = leftSource.charCodeAt(leftSource.length - 1); |
| rightCharCode = rightSource.charCodeAt(0); |
| if ((leftCharCode === 43 || leftCharCode === 45) && leftCharCode === rightCharCode || esutils.code.isIdentifierPartES5(leftCharCode) && esutils.code.isIdentifierPartES5(rightCharCode) || leftCharCode === 47 && rightCharCode === 105) { |
| return [ |
| left, |
| noEmptySpace(), |
| right |
| ]; |
| } else if (esutils.code.isWhiteSpace(leftCharCode) || esutils.code.isLineTerminator(leftCharCode) || esutils.code.isWhiteSpace(rightCharCode) || esutils.code.isLineTerminator(rightCharCode)) { |
| return [ |
| left, |
| right |
| ]; |
| } |
| return [ |
| left, |
| space, |
| right |
| ]; |
| } |
| function addIndent(stmt) { |
| return [ |
| base, |
| stmt |
| ]; |
| } |
| function withIndent(fn) { |
| var previousBase; |
| previousBase = base; |
| base += indent; |
| fn(base); |
| base = previousBase; |
| } |
| function calculateSpaces(str) { |
| var i; |
| for (i = str.length - 1; i >= 0; --i) { |
| if (esutils.code.isLineTerminator(str.charCodeAt(i))) { |
| break; |
| } |
| } |
| return str.length - 1 - i; |
| } |
| function adjustMultilineComment(value, specialBase) { |
| var array, i, len, line, j, spaces, previousBase, sn; |
| array = value.split(/\r\n|[\r\n]/); |
| spaces = Number.MAX_VALUE; |
| for (i = 1, len = array.length; i < len; ++i) { |
| line = array[i]; |
| j = 0; |
| while (j < line.length && esutils.code.isWhiteSpace(line.charCodeAt(j))) { |
| ++j; |
| } |
| if (spaces > j) { |
| spaces = j; |
| } |
| } |
| if (typeof specialBase !== 'undefined') { |
| previousBase = base; |
| if (array[1][spaces] === '*') { |
| specialBase += ' '; |
| } |
| base = specialBase; |
| } else { |
| if (spaces & 1) { |
| --spaces; |
| } |
| previousBase = base; |
| } |
| for (i = 1, len = array.length; i < len; ++i) { |
| sn = toSourceNodeWhenNeeded(addIndent(array[i].slice(spaces))); |
| array[i] = sourceMap ? sn.join('') : sn; |
| } |
| base = previousBase; |
| return array.join('\n'); |
| } |
| function generateComment(comment, specialBase) { |
| if (comment.type === 'Line') { |
| if (endsWithLineTerminator(comment.value)) { |
| return '//' + comment.value; |
| } else { |
| var result = '//' + comment.value; |
| if (!preserveBlankLines) { |
| result += '\n'; |
| } |
| return result; |
| } |
| } |
| if (extra.format.indent.adjustMultilineComment && /[\n\r]/.test(comment.value)) { |
| return adjustMultilineComment('/*' + comment.value + '*/', specialBase); |
| } |
| return '/*' + comment.value + '*/'; |
| } |
| function addComments(stmt, result) { |
| var i, len, comment, save, tailingToStatement, specialBase, fragment, extRange, range, prevRange, prefix, infix, suffix, count; |
| if (stmt.leadingComments && stmt.leadingComments.length > 0) { |
| save = result; |
| if (preserveBlankLines) { |
| comment = stmt.leadingComments[0]; |
| result = []; |
| extRange = comment.extendedRange; |
| range = comment.range; |
| prefix = sourceCode.substring(extRange[0], range[0]); |
| count = (prefix.match(/\n/g) || []).length; |
| if (count > 0) { |
| result.push(stringRepeat('\n', count)); |
| result.push(addIndent(generateComment(comment))); |
| } else { |
| result.push(prefix); |
| result.push(generateComment(comment)); |
| } |
| prevRange = range; |
| for (i = 1, len = stmt.leadingComments.length; i < len; i++) { |
| comment = stmt.leadingComments[i]; |
| range = comment.range; |
| infix = sourceCode.substring(prevRange[1], range[0]); |
| count = (infix.match(/\n/g) || []).length; |
| result.push(stringRepeat('\n', count)); |
| result.push(addIndent(generateComment(comment))); |
| prevRange = range; |
| } |
| suffix = sourceCode.substring(range[1], extRange[1]); |
| count = (suffix.match(/\n/g) || []).length; |
| result.push(stringRepeat('\n', count)); |
| } else { |
| comment = stmt.leadingComments[0]; |
| result = []; |
| if (safeConcatenation && stmt.type === Syntax.Program && stmt.body.length === 0) { |
| result.push('\n'); |
| } |
| result.push(generateComment(comment)); |
| if (!endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) { |
| result.push('\n'); |
| } |
| for (i = 1, len = stmt.leadingComments.length; i < len; ++i) { |
| comment = stmt.leadingComments[i]; |
| fragment = [generateComment(comment)]; |
| if (!endsWithLineTerminator(toSourceNodeWhenNeeded(fragment).toString())) { |
| fragment.push('\n'); |
| } |
| result.push(addIndent(fragment)); |
| } |
| } |
| result.push(addIndent(save)); |
| } |
| if (stmt.trailingComments) { |
| if (preserveBlankLines) { |
| comment = stmt.trailingComments[0]; |
| extRange = comment.extendedRange; |
| range = comment.range; |
| prefix = sourceCode.substring(extRange[0], range[0]); |
| count = (prefix.match(/\n/g) || []).length; |
| if (count > 0) { |
| result.push(stringRepeat('\n', count)); |
| result.push(addIndent(generateComment(comment))); |
| } else { |
| result.push(prefix); |
| result.push(generateComment(comment)); |
| } |
| } else { |
| tailingToStatement = !endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString()); |
| specialBase = stringRepeat(' ', calculateSpaces(toSourceNodeWhenNeeded([ |
| base, |
| result, |
| indent |
| ]).toString())); |
| for (i = 0, len = stmt.trailingComments.length; i < len; ++i) { |
| comment = stmt.trailingComments[i]; |
| if (tailingToStatement) { |
| if (i === 0) { |
| result = [ |
| result, |
| indent |
| ]; |
| } else { |
| result = [ |
| result, |
| specialBase |
| ]; |
| } |
| result.push(generateComment(comment, specialBase)); |
| } else { |
| result = [ |
| result, |
| addIndent(generateComment(comment)) |
| ]; |
| } |
| if (i !== len - 1 && !endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) { |
| result = [ |
| result, |
| '\n' |
| ]; |
| } |
| } |
| } |
| } |
| return result; |
| } |
| function generateBlankLines(start, end, result) { |
| var j, newlineCount = 0; |
| for (j = start; j < end; j++) { |
| if (sourceCode[j] === '\n') { |
| newlineCount++; |
| } |
| } |
| for (j = 1; j < newlineCount; j++) { |
| result.push(newline); |
| } |
| } |
| function parenthesize(text, current, should) { |
| if (current < should) { |
| return [ |
| '(', |
| text, |
| ')' |
| ]; |
| } |
| return text; |
| } |
| function generateVerbatimString(string) { |
| var i, iz, result; |
| result = string.split(/\r\n|\n/); |
| for (i = 1, iz = result.length; i < iz; i++) { |
| result[i] = newline + base + result[i]; |
| } |
| return result; |
| } |
| function generateVerbatim(expr, precedence) { |
| var verbatim, result, prec; |
| verbatim = expr[extra.verbatim]; |
| if (typeof verbatim === 'string') { |
| result = parenthesize(generateVerbatimString(verbatim), Precedence.Sequence, precedence); |
| } else { |
| result = generateVerbatimString(verbatim.content); |
| prec = verbatim.precedence != null ? verbatim.precedence : Precedence.Sequence; |
| result = parenthesize(result, prec, precedence); |
| } |
| return toSourceNodeWhenNeeded(result, expr); |
| } |
| function CodeGenerator() { |
| } |
| CodeGenerator.prototype.maybeBlock = function (stmt, flags) { |
| var result, noLeadingComment, that = this; |
| noLeadingComment = !extra.comment || !stmt.leadingComments; |
| if (stmt.type === Syntax.BlockStatement && noLeadingComment) { |
| return [ |
| space, |
| this.generateStatement(stmt, flags) |
| ]; |
| } |
| if (stmt.type === Syntax.EmptyStatement && noLeadingComment) { |
| return ';'; |
| } |
| withIndent(function () { |
| result = [ |
| newline, |
| addIndent(that.generateStatement(stmt, flags)) |
| ]; |
| }); |
| return result; |
| }; |
| CodeGenerator.prototype.maybeBlockSuffix = function (stmt, result) { |
| var ends = endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString()); |
| if (stmt.type === Syntax.BlockStatement && (!extra.comment || !stmt.leadingComments) && !ends) { |
| return [ |
| result, |
| space |
| ]; |
| } |
| if (ends) { |
| return [ |
| result, |
| base |
| ]; |
| } |
| return [ |
| result, |
| newline, |
| base |
| ]; |
| }; |
| function generateIdentifier(node) { |
| return toSourceNodeWhenNeeded(node.name, node); |
| } |
| function generateAsyncPrefix(node, spaceRequired) { |
| return node.async ? 'async' + (spaceRequired ? noEmptySpace() : space) : ''; |
| } |
| function generateStarSuffix(node) { |
| var isGenerator = node.generator && !extra.moz.starlessGenerator; |
| return isGenerator ? '*' + space : ''; |
| } |
| function generateMethodPrefix(prop) { |
| var func = prop.value; |
| if (func.async) { |
| return generateAsyncPrefix(func, !prop.computed); |
| } else { |
| return generateStarSuffix(func) ? '*' : ''; |
| } |
| } |
| CodeGenerator.prototype.generatePattern = function (node, precedence, flags) { |
| if (node.type === Syntax.Identifier) { |
| return generateIdentifier(node); |
| } |
| return this.generateExpression(node, precedence, flags); |
| }; |
| CodeGenerator.prototype.generateFunctionParams = function (node) { |
| var i, iz, result, hasDefault; |
| hasDefault = false; |
| if (node.type === Syntax.ArrowFunctionExpression && !node.rest && (!node.defaults || node.defaults.length === 0) && node.params.length === 1 && node.params[0].type === Syntax.Identifier) { |
| result = [ |
| generateAsyncPrefix(node, true), |
| generateIdentifier(node.params[0]) |
| ]; |
| } else { |
| result = node.type === Syntax.ArrowFunctionExpression ? [generateAsyncPrefix(node, false)] : []; |
| result.push('('); |
| if (node.defaults) { |
| hasDefault = true; |
| } |
| for (i = 0, iz = node.params.length; i < iz; ++i) { |
| if (hasDefault && node.defaults[i]) { |
| result.push(this.generateAssignment(node.params[i], node.defaults[i], '=', Precedence.Assignment, E_TTT)); |
| } else { |
| result.push(this.generatePattern(node.params[i], Precedence.Assignment, E_TTT)); |
| } |
| if (i + 1 < iz) { |
| result.push(',' + space); |
| } |
| } |
| if (node.rest) { |
| if (node.params.length) { |
| result.push(',' + space); |
| } |
| result.push('...'); |
| result.push(generateIdentifier(node.rest)); |
| } |
| result.push(')'); |
| } |
| return result; |
| }; |
| CodeGenerator.prototype.generateFunctionBody = function (node) { |
| var result, expr; |
| result = this.generateFunctionParams(node); |
| if (node.type === Syntax.ArrowFunctionExpression) { |
| result.push(space); |
| result.push('=>'); |
| } |
| if (node.expression) { |
| result.push(space); |
| expr = this.generateExpression(node.body, Precedence.Assignment, E_TTT); |
| if (expr.toString().charAt(0) === '{') { |
| expr = [ |
| '(', |
| expr, |
| ')' |
| ]; |
| } |
| result.push(expr); |
| } else { |
| result.push(this.maybeBlock(node.body, S_TTFF)); |
| } |
| return result; |
| }; |
| CodeGenerator.prototype.generateIterationForStatement = function (operator, stmt, flags) { |
| var result = ['for' + space + '('], that = this; |
| withIndent(function () { |
| if (stmt.left.type === Syntax.VariableDeclaration) { |
| withIndent(function () { |
| result.push(stmt.left.kind + noEmptySpace()); |
| result.push(that.generateStatement(stmt.left.declarations[0], S_FFFF)); |
| }); |
| } else { |
| result.push(that.generateExpression(stmt.left, Precedence.Call, E_TTT)); |
| } |
| result = join(result, operator); |
| result = [ |
| join(result, that.generateExpression(stmt.right, Precedence.Sequence, E_TTT)), |
| ')' |
| ]; |
| }); |
| result.push(this.maybeBlock(stmt.body, flags)); |
| return result; |
| }; |
| CodeGenerator.prototype.generatePropertyKey = function (expr, computed) { |
| var result = []; |
| if (computed) { |
| result.push('['); |
| } |
| result.push(this.generateExpression(expr, Precedence.Sequence, E_TTT)); |
| if (computed) { |
| result.push(']'); |
| } |
| return result; |
| }; |
| CodeGenerator.prototype.generateAssignment = function (left, right, operator, precedence, flags) { |
| if (Precedence.Assignment < precedence) { |
| flags |= F_ALLOW_IN; |
| } |
| return parenthesize([ |
| this.generateExpression(left, Precedence.Call, flags), |
| space + operator + space, |
| this.generateExpression(right, Precedence.Assignment, flags) |
| ], Precedence.Assignment, precedence); |
| }; |
| CodeGenerator.prototype.semicolon = function (flags) { |
| if (!semicolons && flags & F_SEMICOLON_OPT) { |
| return ''; |
| } |
| return ';'; |
| }; |
| CodeGenerator.Statement = { |
| BlockStatement: function (stmt, flags) { |
| var range, content, result = [ |
| '{', |
| newline |
| ], that = this; |
| withIndent(function () { |
| if (stmt.body.length === 0 && preserveBlankLines) { |
| range = stmt.range; |
| if (range[1] - range[0] > 2) { |
| content = sourceCode.substring(range[0] + 1, range[1] - 1); |
| if (content[0] === '\n') { |
| result = ['{']; |
| } |
| result.push(content); |
| } |
| } |
| var i, iz, fragment, bodyFlags; |
| bodyFlags = S_TFFF; |
| if (flags & F_FUNC_BODY) { |
| bodyFlags |= F_DIRECTIVE_CTX; |
| } |
| for (i = 0, iz = stmt.body.length; i < iz; ++i) { |
| if (preserveBlankLines) { |
| if (i === 0) { |
| if (stmt.body[0].leadingComments) { |
| range = stmt.body[0].leadingComments[0].extendedRange; |
| content = sourceCode.substring(range[0], range[1]); |
| if (content[0] === '\n') { |
| result = ['{']; |
| } |
| } |
| if (!stmt.body[0].leadingComments) { |
| generateBlankLines(stmt.range[0], stmt.body[0].range[0], result); |
| } |
| } |
| if (i > 0) { |
| if (!stmt.body[i - 1].trailingComments && !stmt.body[i].leadingComments) { |
| generateBlankLines(stmt.body[i - 1].range[1], stmt.body[i].range[0], result); |
| } |
| } |
| } |
| if (i === iz - 1) { |
| bodyFlags |= F_SEMICOLON_OPT; |
| } |
| if (stmt.body[i].leadingComments && preserveBlankLines) { |
| fragment = that.generateStatement(stmt.body[i], bodyFlags); |
| } else { |
| fragment = addIndent(that.generateStatement(stmt.body[i], bodyFlags)); |
| } |
| result.push(fragment); |
| if (!endsWithLineTerminator(toSourceNodeWhenNeeded(fragment).toString())) { |
| if (preserveBlankLines && i < iz - 1) { |
| if (!stmt.body[i + 1].leadingComments) { |
| result.push(newline); |
| } |
| } else { |
| result.push(newline); |
| } |
| } |
| if (preserveBlankLines) { |
| if (i === iz - 1) { |
| if (!stmt.body[i].trailingComments) { |
| generateBlankLines(stmt.body[i].range[1], stmt.range[1], result); |
| } |
| } |
| } |
| } |
| }); |
| result.push(addIndent('}')); |
| return result; |
| }, |
| BreakStatement: function (stmt, flags) { |
| if (stmt.label) { |
| return 'break ' + stmt.label.name + this.semicolon(flags); |
| } |
| return 'break' + this.semicolon(flags); |
| }, |
| ContinueStatement: function (stmt, flags) { |
| if (stmt.label) { |
| return 'continue ' + stmt.label.name + this.semicolon(flags); |
| } |
| return 'continue' + this.semicolon(flags); |
| }, |
| ClassBody: function (stmt, flags) { |
| var result = [ |
| '{', |
| newline |
| ], that = this; |
| withIndent(function (indent) { |
| var i, iz; |
| for (i = 0, iz = stmt.body.length; i < iz; ++i) { |
| result.push(indent); |
| result.push(that.generateExpression(stmt.body[i], Precedence.Sequence, E_TTT)); |
| if (i + 1 < iz) { |
| result.push(newline); |
| } |
| } |
| }); |
| if (!endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) { |
| result.push(newline); |
| } |
| result.push(base); |
| result.push('}'); |
| return result; |
| }, |
| ClassDeclaration: function (stmt, flags) { |
| var result, fragment; |
| result = ['class ' + stmt.id.name]; |
| if (stmt.superClass) { |
| fragment = join('extends', this.generateExpression(stmt.superClass, Precedence.Assignment, E_TTT)); |
| result = join(result, fragment); |
| } |
| result.push(space); |
| result.push(this.generateStatement(stmt.body, S_TFFT)); |
| return result; |
| }, |
| DirectiveStatement: function (stmt, flags) { |
| if (extra.raw && stmt.raw) { |
| return stmt.raw + this.semicolon(flags); |
| } |
| return escapeDirective(stmt.directive) + this.semicolon(flags); |
| }, |
| DoWhileStatement: function (stmt, flags) { |
| var result = join('do', this.maybeBlock(stmt.body, S_TFFF)); |
| result = this.maybeBlockSuffix(stmt.body, result); |
| return join(result, [ |
| 'while' + space + '(', |
| this.generateExpression(stmt.test, Precedence.Sequence, E_TTT), |
| ')' + this.semicolon(flags) |
| ]); |
| }, |
| CatchClause: function (stmt, flags) { |
| var result, that = this; |
| withIndent(function () { |
| var guard; |
| result = [ |
| 'catch' + space + '(', |
| that.generateExpression(stmt.param, Precedence.Sequence, E_TTT), |
| ')' |
| ]; |
| if (stmt.guard) { |
| guard = that.generateExpression(stmt.guard, Precedence.Sequence, E_TTT); |
| result.splice(2, 0, ' if ', guard); |
| } |
| }); |
| result.push(this.maybeBlock(stmt.body, S_TFFF)); |
| return result; |
| }, |
| DebuggerStatement: function (stmt, flags) { |
| return 'debugger' + this.semicolon(flags); |
| }, |
| EmptyStatement: function (stmt, flags) { |
| return ';'; |
| }, |
| ExportDefaultDeclaration: function (stmt, flags) { |
| var result = ['export'], bodyFlags; |
| bodyFlags = flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF; |
| result = join(result, 'default'); |
| if (isStatement(stmt.declaration)) { |
| result = join(result, this.generateStatement(stmt.declaration, bodyFlags)); |
| } else { |
| result = join(result, this.generateExpression(stmt.declaration, Precedence.Assignment, E_TTT) + this.semicolon(flags)); |
| } |
| return result; |
| }, |
| ExportNamedDeclaration: function (stmt, flags) { |
| var result = ['export'], bodyFlags, that = this; |
| bodyFlags = flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF; |
| if (stmt.declaration) { |
| return join(result, this.generateStatement(stmt.declaration, bodyFlags)); |
| } |
| if (stmt.specifiers) { |
| if (stmt.specifiers.length === 0) { |
| result = join(result, '{' + space + '}'); |
| } else if (stmt.specifiers[0].type === Syntax.ExportBatchSpecifier) { |
| result = join(result, this.generateExpression(stmt.specifiers[0], Precedence.Sequence, E_TTT)); |
| } else { |
| result = join(result, '{'); |
| withIndent(function (indent) { |
| var i, iz; |
| result.push(newline); |
| for (i = 0, iz = stmt.specifiers.length; i < iz; ++i) { |
| result.push(indent); |
| result.push(that.generateExpression(stmt.specifiers[i], Precedence.Sequence, E_TTT)); |
| if (i + 1 < iz) { |
| result.push(',' + newline); |
| } |
| } |
| }); |
| if (!endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) { |
| result.push(newline); |
| } |
| result.push(base + '}'); |
| } |
| if (stmt.source) { |
| result = join(result, [ |
| 'from' + space, |
| this.generateExpression(stmt.source, Precedence.Sequence, E_TTT), |
| this.semicolon(flags) |
| ]); |
| } else { |
| result.push(this.semicolon(flags)); |
| } |
| } |
| return result; |
| }, |
| ExportAllDeclaration: function (stmt, flags) { |
| return [ |
| 'export' + space, |
| '*' + space, |
| 'from' + space, |
| this.generateExpression(stmt.source, Precedence.Sequence, E_TTT), |
| this.semicolon(flags) |
| ]; |
| }, |
| ExpressionStatement: function (stmt, flags) { |
| var result, fragment; |
| function isClassPrefixed(fragment) { |
| var code; |
| if (fragment.slice(0, 5) !== 'class') { |
| return false; |
| } |
| code = fragment.charCodeAt(5); |
| return code === 123 || esutils.code.isWhiteSpace(code) || esutils.code.isLineTerminator(code); |
| } |
| function isFunctionPrefixed(fragment) { |
| var code; |
| if (fragment.slice(0, 8) !== 'function') { |
| return false; |
| } |
| code = fragment.charCodeAt(8); |
| return code === 40 || esutils.code.isWhiteSpace(code) || code === 42 || esutils.code.isLineTerminator(code); |
| } |
| function isAsyncPrefixed(fragment) { |
| var code, i, iz; |
| if (fragment.slice(0, 5) !== 'async') { |
| return false; |
| } |
| if (!esutils.code.isWhiteSpace(fragment.charCodeAt(5))) { |
| return false; |
| } |
| for (i = 6, iz = fragment.length; i < iz; ++i) { |
| if (!esutils.code.isWhiteSpace(fragment.charCodeAt(i))) { |
| break; |
| } |
| } |
| if (i === iz) { |
| return false; |
| } |
| if (fragment.slice(i, i + 8) !== 'function') { |
| return false; |
| } |
| code = fragment.charCodeAt(i + 8); |
| return code === 40 || esutils.code.isWhiteSpace(code) || code === 42 || esutils.code.isLineTerminator(code); |
| } |
| result = [this.generateExpression(stmt.expression, Precedence.Sequence, E_TTT)]; |
| fragment = toSourceNodeWhenNeeded(result).toString(); |
| if (fragment.charCodeAt(0) === 123 || isClassPrefixed(fragment) || isFunctionPrefixed(fragment) || isAsyncPrefixed(fragment) || directive && flags & F_DIRECTIVE_CTX && stmt.expression.type === Syntax.Literal && typeof stmt.expression.value === 'string') { |
| result = [ |
| '(', |
| result, |
| ')' + this.semicolon(flags) |
| ]; |
| } else { |
| result.push(this.semicolon(flags)); |
| } |
| return result; |
| }, |
| ImportDeclaration: function (stmt, flags) { |
| var result, cursor, that = this; |
| if (stmt.specifiers.length === 0) { |
| return [ |
| 'import', |
| space, |
| this.generateExpression(stmt.source, Precedence.Sequence, E_TTT), |
| this.semicolon(flags) |
| ]; |
| } |
| result = ['import']; |
| cursor = 0; |
| if (stmt.specifiers[cursor].type === Syntax.ImportDefaultSpecifier) { |
| result = join(result, [this.generateExpression(stmt.specifiers[cursor], Precedence.Sequence, E_TTT)]); |
| ++cursor; |
| } |
| if (stmt.specifiers[cursor]) { |
| if (cursor !== 0) { |
| result.push(','); |
| } |
| if (stmt.specifiers[cursor].type === Syntax.ImportNamespaceSpecifier) { |
| result = join(result, [ |
| space, |
| this.generateExpression(stmt.specifiers[cursor], Precedence.Sequence, E_TTT) |
| ]); |
| } else { |
| result.push(space + '{'); |
| if (stmt.specifiers.length - cursor === 1) { |
| result.push(space); |
| result.push(this.generateExpression(stmt.specifiers[cursor], Precedence.Sequence, E_TTT)); |
| result.push(space + '}' + space); |
| } else { |
| withIndent(function (indent) { |
| var i, iz; |
| result.push(newline); |
| for (i = cursor, iz = stmt.specifiers.length; i < iz; ++i) { |
| result.push(indent); |
| result.push(that.generateExpression(stmt.specifiers[i], Precedence.Sequence, E_TTT)); |
| if (i + 1 < iz) { |
| result.push(',' + newline); |
| } |
| } |
| }); |
| if (!endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) { |
| result.push(newline); |
| } |
| result.push(base + '}' + space); |
| } |
| } |
| } |
| result = join(result, [ |
| 'from' + space, |
| this.generateExpression(stmt.source, Precedence.Sequence, E_TTT), |
| this.semicolon(flags) |
| ]); |
| return result; |
| }, |
| VariableDeclarator: function (stmt, flags) { |
| var itemFlags = flags & F_ALLOW_IN ? E_TTT : E_FTT; |
| if (stmt.init) { |
| return [ |
| this.generateExpression(stmt.id, Precedence.Assignment, itemFlags), |
| space, |
| '=', |
| space, |
| this.generateExpression(stmt.init, Precedence.Assignment, itemFlags) |
| ]; |
| } |
| return this.generatePattern(stmt.id, Precedence.Assignment, itemFlags); |
| }, |
| VariableDeclaration: function (stmt, flags) { |
| var result, i, iz, node, bodyFlags, that = this; |
| result = [stmt.kind]; |
| bodyFlags = flags & F_ALLOW_IN ? S_TFFF : S_FFFF; |
| function block() { |
| node = stmt.declarations[0]; |
| if (extra.comment && node.leadingComments) { |
| result.push('\n'); |
| result.push(addIndent(that.generateStatement(node, bodyFlags))); |
| } else { |
| result.push(noEmptySpace()); |
| result.push(that.generateStatement(node, bodyFlags)); |
| } |
| for (i = 1, iz = stmt.declarations.length; i < iz; ++i) { |
| node = stmt.declarations[i]; |
| if (extra.comment && node.leadingComments) { |
| result.push(',' + newline); |
| result.push(addIndent(that.generateStatement(node, bodyFlags))); |
| } else { |
| result.push(',' + space); |
| result.push(that.generateStatement(node, bodyFlags)); |
| } |
| } |
| } |
| if (stmt.declarations.length > 1) { |
| withIndent(block); |
| } else { |
| block(); |
| } |
| result.push(this.semicolon(flags)); |
| return result; |
| }, |
| ThrowStatement: function (stmt, flags) { |
| return [ |
| join('throw', this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)), |
| this.semicolon(flags) |
| ]; |
| }, |
| TryStatement: function (stmt, flags) { |
| var result, i, iz, guardedHandlers; |
| result = [ |
| 'try', |
| this.maybeBlock(stmt.block, S_TFFF) |
| ]; |
| result = this.maybeBlockSuffix(stmt.block, result); |
| if (stmt.handlers) { |
| for (i = 0, iz = stmt.handlers.length; i < iz; ++i) { |
| result = join(result, this.generateStatement(stmt.handlers[i], S_TFFF)); |
| if (stmt.finalizer || i + 1 !== iz) { |
| result = this.maybeBlockSuffix(stmt.handlers[i].body, result); |
| } |
| } |
| } else { |
| guardedHandlers = stmt.guardedHandlers || []; |
| for (i = 0, iz = guardedHandlers.length; i < iz; ++i) { |
| result = join(result, this.generateStatement(guardedHandlers[i], S_TFFF)); |
| if (stmt.finalizer || i + 1 !== iz) { |
| result = this.maybeBlockSuffix(guardedHandlers[i].body, result); |
| } |
| } |
| if (stmt.handler) { |
| if (isArray(stmt.handler)) { |
| for (i = 0, iz = stmt.handler.length; i < iz; ++i) { |
| result = join(result, this.generateStatement(stmt.handler[i], S_TFFF)); |
| if (stmt.finalizer || i + 1 !== iz) { |
| result = this.maybeBlockSuffix(stmt.handler[i].body, result); |
| } |
| } |
| } else { |
| result = join(result, this.generateStatement(stmt.handler, S_TFFF)); |
| if (stmt.finalizer) { |
| result = this.maybeBlockSuffix(stmt.handler.body, result); |
| } |
| } |
| } |
| } |
| if (stmt.finalizer) { |
| result = join(result, [ |
| 'finally', |
| this.maybeBlock(stmt.finalizer, S_TFFF) |
| ]); |
| } |
| return result; |
| }, |
| SwitchStatement: function (stmt, flags) { |
| var result, fragment, i, iz, bodyFlags, that = this; |
| withIndent(function () { |
| result = [ |
| 'switch' + space + '(', |
| that.generateExpression(stmt.discriminant, Precedence.Sequence, E_TTT), |
| ')' + space + '{' + newline |
| ]; |
| }); |
| if (stmt.cases) { |
| bodyFlags = S_TFFF; |
| for (i = 0, iz = stmt.cases.length; i < iz; ++i) { |
| if (i === iz - 1) { |
| bodyFlags |= F_SEMICOLON_OPT; |
| } |
| fragment = addIndent(this.generateStatement(stmt.cases[i], bodyFlags)); |
| result.push(fragment); |
| if (!endsWithLineTerminator(toSourceNodeWhenNeeded(fragment).toString())) { |
| result.push(newline); |
| } |
| } |
| } |
| result.push(addIndent('}')); |
| return result; |
| }, |
| SwitchCase: function (stmt, flags) { |
| var result, fragment, i, iz, bodyFlags, that = this; |
| withIndent(function () { |
| if (stmt.test) { |
| result = [ |
| join('case', that.generateExpression(stmt.test, Precedence.Sequence, E_TTT)), |
| ':' |
| ]; |
| } else { |
| result = ['default:']; |
| } |
| i = 0; |
| iz = stmt.consequent.length; |
| if (iz && stmt.consequent[0].type === Syntax.BlockStatement) { |
| fragment = that.maybeBlock(stmt.consequent[0], S_TFFF); |
| result.push(fragment); |
| i = 1; |
| } |
| if (i !== iz && !endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) { |
| result.push(newline); |
| } |
| bodyFlags = S_TFFF; |
| for (; i < iz; ++i) { |
| if (i === iz - 1 && flags & F_SEMICOLON_OPT) { |
| bodyFlags |= F_SEMICOLON_OPT; |
| } |
| fragment = addIndent(that.generateStatement(stmt.consequent[i], bodyFlags)); |
| result.push(fragment); |
| if (i + 1 !== iz && !endsWithLineTerminator(toSourceNodeWhenNeeded(fragment).toString())) { |
| result.push(newline); |
| } |
| } |
| }); |
| return result; |
| }, |
| IfStatement: function (stmt, flags) { |
| var result, bodyFlags, semicolonOptional, that = this; |
| withIndent(function () { |
| result = [ |
| 'if' + space + '(', |
| that.generateExpression(stmt.test, Precedence.Sequence, E_TTT), |
| ')' |
| ]; |
| }); |
| semicolonOptional = flags & F_SEMICOLON_OPT; |
| bodyFlags = S_TFFF; |
| if (semicolonOptional) { |
| bodyFlags |= F_SEMICOLON_OPT; |
| } |
| if (stmt.alternate) { |
| result.push(this.maybeBlock(stmt.consequent, S_TFFF)); |
| result = this.maybeBlockSuffix(stmt.consequent, result); |
| if (stmt.alternate.type === Syntax.IfStatement) { |
| result = join(result, [ |
| 'else ', |
| this.generateStatement(stmt.alternate, bodyFlags) |
| ]); |
| } else { |
| result = join(result, join('else', this.maybeBlock(stmt.alternate, bodyFlags))); |
| } |
| } else { |
| result.push(this.maybeBlock(stmt.consequent, bodyFlags)); |
| } |
| return result; |
| }, |
| ForStatement: function (stmt, flags) { |
| var result, that = this; |
| withIndent(function () { |
| result = ['for' + space + '(']; |
| if (stmt.init) { |
| if (stmt.init.type === Syntax.VariableDeclaration) { |
| result.push(that.generateStatement(stmt.init, S_FFFF)); |
| } else { |
| result.push(that.generateExpression(stmt.init, Precedence.Sequence, E_FTT)); |
| result.push(';'); |
| } |
| } else { |
| result.push(';'); |
| } |
| if (stmt.test) { |
| result.push(space); |
| result.push(that.generateExpression(stmt.test, Precedence.Sequence, E_TTT)); |
| result.push(';'); |
| } else { |
| result.push(';'); |
| } |
| if (stmt.update) { |
| result.push(space); |
| result.push(that.generateExpression(stmt.update, Precedence.Sequence, E_TTT)); |
| result.push(')'); |
| } else { |
| result.push(')'); |
| } |
| }); |
| result.push(this.maybeBlock(stmt.body, flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF)); |
| return result; |
| }, |
| ForInStatement: function (stmt, flags) { |
| return this.generateIterationForStatement('in', stmt, flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF); |
| }, |
| ForOfStatement: function (stmt, flags) { |
| return this.generateIterationForStatement('of', stmt, flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF); |
| }, |
| LabeledStatement: function (stmt, flags) { |
| return [ |
| stmt.label.name + ':', |
| this.maybeBlock(stmt.body, flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF) |
| ]; |
| }, |
| Program: function (stmt, flags) { |
| var result, fragment, i, iz, bodyFlags; |
| iz = stmt.body.length; |
| result = [safeConcatenation && iz > 0 ? '\n' : '']; |
| bodyFlags = S_TFTF; |
| for (i = 0; i < iz; ++i) { |
| if (!safeConcatenation && i === iz - 1) { |
| bodyFlags |= F_SEMICOLON_OPT; |
| } |
| if (preserveBlankLines) { |
| if (i === 0) { |
| if (!stmt.body[0].leadingComments) { |
| generateBlankLines(stmt.range[0], stmt.body[i].range[0], result); |
| } |
| } |
| if (i > 0) { |
| if (!stmt.body[i - 1].trailingComments && !stmt.body[i].leadingComments) { |
| generateBlankLines(stmt.body[i - 1].range[1], stmt.body[i].range[0], result); |
| } |
| } |
| } |
| fragment = addIndent(this.generateStatement(stmt.body[i], bodyFlags)); |
| result.push(fragment); |
| if (i + 1 < iz && !endsWithLineTerminator(toSourceNodeWhenNeeded(fragment).toString())) { |
| if (preserveBlankLines) { |
| if (!stmt.body[i + 1].leadingComments) { |
| result.push(newline); |
| } |
| } else { |
| result.push(newline); |
| } |
| } |
| if (preserveBlankLines) { |
| if (i === iz - 1) { |
| if (!stmt.body[i].trailingComments) { |
| generateBlankLines(stmt.body[i].range[1], stmt.range[1], result); |
| } |
| } |
| } |
| } |
| return result; |
| }, |
| FunctionDeclaration: function (stmt, flags) { |
| return [ |
| generateAsyncPrefix(stmt, true), |
| 'function', |
| generateStarSuffix(stmt) || noEmptySpace(), |
| stmt.id ? generateIdentifier(stmt.id) : '', |
| this.generateFunctionBody(stmt) |
| ]; |
| }, |
| ReturnStatement: function (stmt, flags) { |
| if (stmt.argument) { |
| return [ |
| join('return', this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)), |
| this.semicolon(flags) |
| ]; |
| } |
| return ['return' + this.semicolon(flags)]; |
| }, |
| WhileStatement: function (stmt, flags) { |
| var result, that = this; |
| withIndent(function () { |
| result = [ |
| 'while' + space + '(', |
| that.generateExpression(stmt.test, Precedence.Sequence, E_TTT), |
| ')' |
| ]; |
| }); |
| result.push(this.maybeBlock(stmt.body, flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF)); |
| return result; |
| }, |
| WithStatement: function (stmt, flags) { |
| var result, that = this; |
| withIndent(function () { |
| result = [ |
| 'with' + space + '(', |
| that.generateExpression(stmt.object, Precedence.Sequence, E_TTT), |
| ')' |
| ]; |
| }); |
| result.push(this.maybeBlock(stmt.body, flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF)); |
| return result; |
| } |
| }; |
| merge(CodeGenerator.prototype, CodeGenerator.Statement); |
| CodeGenerator.Expression = { |
| SequenceExpression: function (expr, precedence, flags) { |
| var result, i, iz; |
| if (Precedence.Sequence < precedence) { |
| flags |= F_ALLOW_IN; |
| } |
| result = []; |
| for (i = 0, iz = expr.expressions.length; i < iz; ++i) { |
| result.push(this.generateExpression(expr.expressions[i], Precedence.Assignment, flags)); |
| if (i + 1 < iz) { |
| result.push(',' + space); |
| } |
| } |
| return parenthesize(result, Precedence.Sequence, precedence); |
| }, |
| AssignmentExpression: function (expr, precedence, flags) { |
| return this.generateAssignment(expr.left, expr.right, expr.operator, precedence, flags); |
| }, |
| ArrowFunctionExpression: function (expr, precedence, flags) { |
| return parenthesize(this.generateFunctionBody(expr), Precedence.ArrowFunction, precedence); |
| }, |
| ConditionalExpression: function (expr, precedence, flags) { |
| if (Precedence.Conditional < precedence) { |
| flags |= F_ALLOW_IN; |
| } |
| return parenthesize([ |
| this.generateExpression(expr.test, Precedence.LogicalOR, flags), |
| space + '?' + space, |
| this.generateExpression(expr.consequent, Precedence.Assignment, flags), |
| space + ':' + space, |
| this.generateExpression(expr.alternate, Precedence.Assignment, flags) |
| ], Precedence.Conditional, precedence); |
| }, |
| LogicalExpression: function (expr, precedence, flags) { |
| return this.BinaryExpression(expr, precedence, flags); |
| }, |
| BinaryExpression: function (expr, precedence, flags) { |
| var result, currentPrecedence, fragment, leftSource; |
| currentPrecedence = BinaryPrecedence[expr.operator]; |
| if (currentPrecedence < precedence) { |
| flags |= F_ALLOW_IN; |
| } |
| fragment = this.generateExpression(expr.left, currentPrecedence, flags); |
| leftSource = fragment.toString(); |
| if (leftSource.charCodeAt(leftSource.length - 1) === 47 && esutils.code.isIdentifierPartES5(expr.operator.charCodeAt(0))) { |
| result = [ |
| fragment, |
| noEmptySpace(), |
| expr.operator |
| ]; |
| } else { |
| result = join(fragment, expr.operator); |
| } |
| fragment = this.generateExpression(expr.right, currentPrecedence + 1, flags); |
| if (expr.operator === '/' && fragment.toString().charAt(0) === '/' || expr.operator.slice(-1) === '<' && fragment.toString().slice(0, 3) === '!--') { |
| result.push(noEmptySpace()); |
| result.push(fragment); |
| } else { |
| result = join(result, fragment); |
| } |
| if (expr.operator === 'in' && !(flags & F_ALLOW_IN)) { |
| return [ |
| '(', |
| result, |
| ')' |
| ]; |
| } |
| return parenthesize(result, currentPrecedence, precedence); |
| }, |
| CallExpression: function (expr, precedence, flags) { |
| var result, i, iz; |
| result = [this.generateExpression(expr.callee, Precedence.Call, E_TTF)]; |
| result.push('('); |
| for (i = 0, iz = expr['arguments'].length; i < iz; ++i) { |
| result.push(this.generateExpression(expr['arguments'][i], Precedence.Assignment, E_TTT)); |
| if (i + 1 < iz) { |
| result.push(',' + space); |
| } |
| } |
| result.push(')'); |
| if (!(flags & F_ALLOW_CALL)) { |
| return [ |
| '(', |
| result, |
| ')' |
| ]; |
| } |
| return parenthesize(result, Precedence.Call, precedence); |
| }, |
| NewExpression: function (expr, precedence, flags) { |
| var result, length, i, iz, itemFlags; |
| length = expr['arguments'].length; |
| itemFlags = flags & F_ALLOW_UNPARATH_NEW && !parentheses && length === 0 ? E_TFT : E_TFF; |
| result = join('new', this.generateExpression(expr.callee, Precedence.New, itemFlags)); |
| if (!(flags & F_ALLOW_UNPARATH_NEW) || parentheses || length > 0) { |
| result.push('('); |
| for (i = 0, iz = length; i < iz; ++i) { |
| result.push(this.generateExpression(expr['arguments'][i], Precedence.Assignment, E_TTT)); |
| if (i + 1 < iz) { |
| result.push(',' + space); |
| } |
| } |
| result.push(')'); |
| } |
| return parenthesize(result, Precedence.New, precedence); |
| }, |
| MemberExpression: function (expr, precedence, flags) { |
| var result, fragment; |
| result = [this.generateExpression(expr.object, Precedence.Call, flags & F_ALLOW_CALL ? E_TTF : E_TFF)]; |
| if (expr.computed) { |
| result.push('['); |
| result.push(this.generateExpression(expr.property, Precedence.Sequence, flags & F_ALLOW_CALL ? E_TTT : E_TFT)); |
| result.push(']'); |
| } else { |
| if (expr.object.type === Syntax.Literal && typeof expr.object.value === 'number') { |
| fragment = toSourceNodeWhenNeeded(result).toString(); |
| if (fragment.indexOf('.') < 0 && !/[eExX]/.test(fragment) && esutils.code.isDecimalDigit(fragment.charCodeAt(fragment.length - 1)) && !(fragment.length >= 2 && fragment.charCodeAt(0) === 48)) { |
| result.push('.'); |
| } |
| } |
| result.push('.'); |
| result.push(generateIdentifier(expr.property)); |
| } |
| return parenthesize(result, Precedence.Member, precedence); |
| }, |
| MetaProperty: function (expr, precedence, flags) { |
| var result; |
| result = []; |
| result.push(expr.meta); |
| result.push('.'); |
| result.push(expr.property); |
| return parenthesize(result, Precedence.Member, precedence); |
| }, |
| UnaryExpression: function (expr, precedence, flags) { |
| var result, fragment, rightCharCode, leftSource, leftCharCode; |
| fragment = this.generateExpression(expr.argument, Precedence.Unary, E_TTT); |
| if (space === '') { |
| result = join(expr.operator, fragment); |
| } else { |
| result = [expr.operator]; |
| if (expr.operator.length > 2) { |
| result = join(result, fragment); |
| } else { |
| leftSource = toSourceNodeWhenNeeded(result).toString(); |
| leftCharCode = leftSource.charCodeAt(leftSource.length - 1); |
| rightCharCode = fragment.toString().charCodeAt(0); |
| if ((leftCharCode === 43 || leftCharCode === 45) && leftCharCode === rightCharCode || esutils.code.isIdentifierPartES5(leftCharCode) && esutils.code.isIdentifierPartES5(rightCharCode)) { |
| result.push(noEmptySpace()); |
| result.push(fragment); |
| } else { |
| result.push(fragment); |
| } |
| } |
| } |
| return parenthesize(result, Precedence.Unary, precedence); |
| }, |
| YieldExpression: function (expr, precedence, flags) { |
| var result; |
| if (expr.delegate) { |
| result = 'yield*'; |
| } else { |
| result = 'yield'; |
| } |
| if (expr.argument) { |
| result = join(result, this.generateExpression(expr.argument, Precedence.Yield, E_TTT)); |
| } |
| return parenthesize(result, Precedence.Yield, precedence); |
| }, |
| AwaitExpression: function (expr, precedence, flags) { |
| var result = join(expr.all ? 'await*' : 'await', this.generateExpression(expr.argument, Precedence.Await, E_TTT)); |
| return parenthesize(result, Precedence.Await, precedence); |
| }, |
| UpdateExpression: function (expr, precedence, flags) { |
| if (expr.prefix) { |
| return parenthesize([ |
| expr.operator, |
| this.generateExpression(expr.argument, Precedence.Unary, E_TTT) |
| ], Precedence.Unary, precedence); |
| } |
| return parenthesize([ |
| this.generateExpression(expr.argument, Precedence.Postfix, E_TTT), |
| expr.operator |
| ], Precedence.Postfix, precedence); |
| }, |
| FunctionExpression: function (expr, precedence, flags) { |
| var result = [ |
| generateAsyncPrefix(expr, true), |
| 'function' |
| ]; |
| if (expr.id) { |
| result.push(generateStarSuffix(expr) || noEmptySpace()); |
| result.push(generateIdentifier(expr.id)); |
| } else { |
| result.push(generateStarSuffix(expr) || space); |
| } |
| result.push(this.generateFunctionBody(expr)); |
| return result; |
| }, |
| ArrayPattern: function (expr, precedence, flags) { |
| return this.ArrayExpression(expr, precedence, flags, true); |
| }, |
| ArrayExpression: function (expr, precedence, flags, isPattern) { |
| var result, multiline, that = this; |
| if (!expr.elements.length) { |
| return '[]'; |
| } |
| multiline = isPattern ? false : expr.elements.length > 1; |
| result = [ |
| '[', |
| multiline ? newline : '' |
| ]; |
| withIndent(function (indent) { |
| var i, iz; |
| for (i = 0, iz = expr.elements.length; i < iz; ++i) { |
| if (!expr.elements[i]) { |
| if (multiline) { |
| result.push(indent); |
| } |
| if (i + 1 === iz) { |
| result.push(','); |
| } |
| } else { |
| result.push(multiline ? indent : ''); |
| result.push(that.generateExpression(expr.elements[i], Precedence.Assignment, E_TTT)); |
| } |
| if (i + 1 < iz) { |
| result.push(',' + (multiline ? newline : space)); |
| } |
| } |
| }); |
| if (multiline && !endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) { |
| result.push(newline); |
| } |
| result.push(multiline ? base : ''); |
| result.push(']'); |
| return result; |
| }, |
| RestElement: function (expr, precedence, flags) { |
| return '...' + this.generatePattern(expr.argument); |
| }, |
| ClassExpression: function (expr, precedence, flags) { |
| var result, fragment; |
| result = ['class']; |
| if (expr.id) { |
| result = join(result, this.generateExpression(expr.id, Precedence.Sequence, E_TTT)); |
| } |
| if (expr.superClass) { |
| fragment = join('extends', this.generateExpression(expr.superClass, Precedence.Assignment, E_TTT)); |
| result = join(result, fragment); |
| } |
| result.push(space); |
| result.push(this.generateStatement(expr.body, S_TFFT)); |
| return result; |
| }, |
| MethodDefinition: function (expr, precedence, flags) { |
| var result, fragment; |
| if (expr['static']) { |
| result = ['static' + space]; |
| } else { |
| result = []; |
| } |
| if (expr.kind === 'get' || expr.kind === 'set') { |
| fragment = [ |
| join(expr.kind, this.generatePropertyKey(expr.key, expr.computed)), |
| this.generateFunctionBody(expr.value) |
| ]; |
| } else { |
| fragment = [ |
| generateMethodPrefix(expr), |
| this.generatePropertyKey(expr.key, expr.computed), |
| this.generateFunctionBody(expr.value) |
| ]; |
| } |
| return join(result, fragment); |
| }, |
| Property: function (expr, precedence, flags) { |
| if (expr.kind === 'get' || expr.kind === 'set') { |
| return [ |
| expr.kind, |
| noEmptySpace(), |
| this.generatePropertyKey(expr.key, expr.computed), |
| this.generateFunctionBody(expr.value) |
| ]; |
| } |
| if (expr.shorthand) { |
| return this.generatePropertyKey(expr.key, expr.computed); |
| } |
| if (expr.method) { |
| return [ |
| generateMethodPrefix(expr), |
| this.generatePropertyKey(expr.key, expr.computed), |
| this.generateFunctionBody(expr.value) |
| ]; |
| } |
| return [ |
| this.generatePropertyKey(expr.key, expr.computed), |
| ':' + space, |
| this.generateExpression(expr.value, Precedence.Assignment, E_TTT) |
| ]; |
| }, |
| ObjectExpression: function (expr, precedence, flags) { |
| var multiline, result, fragment, that = this; |
| if (!expr.properties.length) { |
| return '{}'; |
| } |
| multiline = expr.properties.length > 1; |
| withIndent(function () { |
| fragment = that.generateExpression(expr.properties[0], Precedence.Sequence, E_TTT); |
| }); |
| if (!multiline) { |
| if (!hasLineTerminator(toSourceNodeWhenNeeded(fragment).toString())) { |
| return [ |
| '{', |
| space, |
| fragment, |
| space, |
| '}' |
| ]; |
| } |
| } |
| withIndent(function (indent) { |
| var i, iz; |
| result = [ |
| '{', |
| newline, |
| indent, |
| fragment |
| ]; |
| if (multiline) { |
| result.push(',' + newline); |
| for (i = 1, iz = expr.properties.length; i < iz; ++i) { |
| result.push(indent); |
| result.push(that.generateExpression(expr.properties[i], Precedence.Sequence, E_TTT)); |
| if (i + 1 < iz) { |
| result.push(',' + newline); |
| } |
| } |
| } |
| }); |
| if (!endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) { |
| result.push(newline); |
| } |
| result.push(base); |
| result.push('}'); |
| return result; |
| }, |
| AssignmentPattern: function (expr, precedence, flags) { |
| return this.generateAssignment(expr.left, expr.right, expr.operator, precedence, flags); |
| }, |
| ObjectPattern: function (expr, precedence, flags) { |
| var result, i, iz, multiline, property, that = this; |
| if (!expr.properties.length) { |
| return '{}'; |
| } |
| multiline = false; |
| if (expr.properties.length === 1) { |
| property = expr.properties[0]; |
| if (property.value.type !== Syntax.Identifier) { |
| multiline = true; |
| } |
| } else { |
| for (i = 0, iz = expr.properties.length; i < iz; ++i) { |
| property = expr.properties[i]; |
| if (!property.shorthand) { |
| multiline = true; |
| break; |
| } |
| } |
| } |
| result = [ |
| '{', |
| multiline ? newline : '' |
| ]; |
| withIndent(function (indent) { |
| var i, iz; |
| for (i = 0, iz = expr.properties.length; i < iz; ++i) { |
| result.push(multiline ? indent : ''); |
| result.push(that.generateExpression(expr.properties[i], Precedence.Sequence, E_TTT)); |
| if (i + 1 < iz) { |
| result.push(',' + (multiline ? newline : space)); |
| } |
| } |
| }); |
| if (multiline && !endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) { |
| result.push(newline); |
| } |
| result.push(multiline ? base : ''); |
| result.push('}'); |
| return result; |
| }, |
| ThisExpression: function (expr, precedence, flags) { |
| return 'this'; |
| }, |
| Super: function (expr, precedence, flags) { |
| return 'super'; |
| }, |
| Identifier: function (expr, precedence, flags) { |
| return generateIdentifier(expr); |
| }, |
| ImportDefaultSpecifier: function (expr, precedence, flags) { |
| return generateIdentifier(expr.id || expr.local); |
| }, |
| ImportNamespaceSpecifier: function (expr, precedence, flags) { |
| var result = ['*']; |
| var id = expr.id || expr.local; |
| if (id) { |
| result.push(space + 'as' + noEmptySpace() + generateIdentifier(id)); |
| } |
| return result; |
| }, |
| ImportSpecifier: function (expr, precedence, flags) { |
| var imported = expr.imported; |
| var result = [imported.name]; |
| var local = expr.local; |
| if (local && local.name !== imported.name) { |
| result.push(noEmptySpace() + 'as' + noEmptySpace() + generateIdentifier(local)); |
| } |
| return result; |
| }, |
| ExportSpecifier: function (expr, precedence, flags) { |
| var local = expr.local; |
| var result = [local.name]; |
| var exported = expr.exported; |
| if (exported && exported.name !== local.name) { |
| result.push(noEmptySpace() + 'as' + noEmptySpace() + generateIdentifier(exported)); |
| } |
| return result; |
| }, |
| Literal: function (expr, precedence, flags) { |
| var raw; |
| if (expr.hasOwnProperty('raw') && parse && extra.raw) { |
| try { |
| raw = parse(expr.raw).body[0].expression; |
| if (raw.type === Syntax.Literal) { |
| if (raw.value === expr.value) { |
| return expr.raw; |
| } |
| } |
| } catch (e) { |
| } |
| } |
| if (expr.value === null) { |
| return 'null'; |
| } |
| if (typeof expr.value === 'string') { |
| return escapeString(expr.value); |
| } |
| if (typeof expr.value === 'number') { |
| return generateNumber(expr.value); |
| } |
| if (typeof expr.value === 'boolean') { |
| return expr.value ? 'true' : 'false'; |
| } |
| return generateRegExp(expr.value); |
| }, |
| GeneratorExpression: function (expr, precedence, flags) { |
| return this.ComprehensionExpression(expr, precedence, flags); |
| }, |
| ComprehensionExpression: function (expr, precedence, flags) { |
| var result, i, iz, fragment, that = this; |
| result = expr.type === Syntax.GeneratorExpression ? ['('] : ['[']; |
| if (extra.moz.comprehensionExpressionStartsWithAssignment) { |
| fragment = this.generateExpression(expr.body, Precedence.Assignment, E_TTT); |
| result.push(fragment); |
| } |
| if (expr.blocks) { |
| withIndent(function () { |
| for (i = 0, iz = expr.blocks.length; i < iz; ++i) { |
| fragment = that.generateExpression(expr.blocks[i], Precedence.Sequence, E_TTT); |
| if (i > 0 || extra.moz.comprehensionExpressionStartsWithAssignment) { |
| result = join(result, fragment); |
| } else { |
| result.push(fragment); |
| } |
| } |
| }); |
| } |
| if (expr.filter) { |
| result = join(result, 'if' + space); |
| fragment = this.generateExpression(expr.filter, Precedence.Sequence, E_TTT); |
| result = join(result, [ |
| '(', |
| fragment, |
| ')' |
| ]); |
| } |
| if (!extra.moz.comprehensionExpressionStartsWithAssignment) { |
| fragment = this.generateExpression(expr.body, Precedence.Assignment, E_TTT); |
| result = join(result, fragment); |
| } |
| result.push(expr.type === Syntax.GeneratorExpression ? ')' : ']'); |
| return result; |
| }, |
| ComprehensionBlock: function (expr, precedence, flags) { |
| var fragment; |
| if (expr.left.type === Syntax.VariableDeclaration) { |
| fragment = [ |
| expr.left.kind, |
| noEmptySpace(), |
| this.generateStatement(expr.left.declarations[0], S_FFFF) |
| ]; |
| } else { |
| fragment = this.generateExpression(expr.left, Precedence.Call, E_TTT); |
| } |
| fragment = join(fragment, expr.of ? 'of' : 'in'); |
| fragment = join(fragment, this.generateExpression(expr.right, Precedence.Sequence, E_TTT)); |
| return [ |
| 'for' + space + '(', |
| fragment, |
| ')' |
| ]; |
| }, |
| SpreadElement: function (expr, precedence, flags) { |
| return [ |
| '...', |
| this.generateExpression(expr.argument, Precedence.Assignment, E_TTT) |
| ]; |
| }, |
| TaggedTemplateExpression: function (expr, precedence, flags) { |
| var itemFlags = E_TTF; |
| if (!(flags & F_ALLOW_CALL)) { |
| itemFlags = E_TFF; |
| } |
| var result = [ |
| this.generateExpression(expr.tag, Precedence.Call, itemFlags), |
| this.generateExpression(expr.quasi, Precedence.Primary, E_FFT) |
| ]; |
| return parenthesize(result, Precedence.TaggedTemplate, precedence); |
| }, |
| TemplateElement: function (expr, precedence, flags) { |
| return expr.value.raw; |
| }, |
| TemplateLiteral: function (expr, precedence, flags) { |
| var result, i, iz; |
| result = ['`']; |
| for (i = 0, iz = expr.quasis.length; i < iz; ++i) { |
| result.push(this.generateExpression(expr.quasis[i], Precedence.Primary, E_TTT)); |
| if (i + 1 < iz) { |
| result.push('${' + space); |
| result.push(this.generateExpression(expr.expressions[i], Precedence.Sequence, E_TTT)); |
| result.push(space + '}'); |
| } |
| } |
| result.push('`'); |
| return result; |
| }, |
| ModuleSpecifier: function (expr, precedence, flags) { |
| return this.Literal(expr, precedence, flags); |
| } |
| }; |
| merge(CodeGenerator.prototype, CodeGenerator.Expression); |
| CodeGenerator.prototype.generateExpression = function (expr, precedence, flags) { |
| var result, type; |
| type = expr.type || Syntax.Property; |
| if (extra.verbatim && expr.hasOwnProperty(extra.verbatim)) { |
| return generateVerbatim(expr, precedence); |
| } |
| result = this[type](expr, precedence, flags); |
| if (extra.comment) { |
| result = addComments(expr, result); |
| } |
| return toSourceNodeWhenNeeded(result, expr); |
| }; |
| CodeGenerator.prototype.generateStatement = function (stmt, flags) { |
| var result, fragment; |
| result = this[stmt.type](stmt, flags); |
| if (extra.comment) { |
| result = addComments(stmt, result); |
| } |
| fragment = toSourceNodeWhenNeeded(result).toString(); |
| if (stmt.type === Syntax.Program && !safeConcatenation && newline === '' && fragment.charAt(fragment.length - 1) === '\n') { |
| result = sourceMap ? toSourceNodeWhenNeeded(result).replaceRight(/\s+$/, '') : fragment.replace(/\s+$/, ''); |
| } |
| return toSourceNodeWhenNeeded(result, stmt); |
| }; |
| function generateInternal(node) { |
| var codegen; |
| codegen = new CodeGenerator; |
| if (isStatement(node)) { |
| return codegen.generateStatement(node, S_TFFF); |
| } |
| if (isExpression(node)) { |
| return codegen.generateExpression(node, Precedence.Sequence, E_TTT); |
| } |
| throw new Error('Unknown node type: ' + node.type); |
| } |
| function generate(node, options) { |
| var defaultOptions = getDefaultOptions(), result, pair; |
| if (options != null) { |
| if (typeof options.indent === 'string') { |
| defaultOptions.format.indent.style = options.indent; |
| } |
| if (typeof options.base === 'number') { |
| defaultOptions.format.indent.base = options.base; |
| } |
| options = updateDeeply(defaultOptions, options); |
| indent = options.format.indent.style; |
| if (typeof options.base === 'string') { |
| base = options.base; |
| } else { |
| base = stringRepeat(indent, options.format.indent.base); |
| } |
| } else { |
| options = defaultOptions; |
| indent = options.format.indent.style; |
| base = stringRepeat(indent, options.format.indent.base); |
| } |
| json = options.format.json; |
| renumber = options.format.renumber; |
| hexadecimal = json ? false : options.format.hexadecimal; |
| quotes = json ? 'double' : options.format.quotes; |
| escapeless = options.format.escapeless; |
| newline = options.format.newline; |
| space = options.format.space; |
| if (options.format.compact) { |
| newline = space = indent = base = ''; |
| } |
| parentheses = options.format.parentheses; |
| semicolons = options.format.semicolons; |
| safeConcatenation = options.format.safeConcatenation; |
| directive = options.directive; |
| parse = json ? null : options.parse; |
| sourceMap = options.sourceMap; |
| sourceCode = options.sourceCode; |
| preserveBlankLines = options.format.preserveBlankLines && sourceCode !== null; |
| extra = options; |
| if (sourceMap) { |
| if (!exports.browser) { |
| SourceNode = require('/node_modules/source-map/lib/source-map.js', module).SourceNode; |
| } else { |
| SourceNode = global.sourceMap.SourceNode; |
| } |
| } |
| result = generateInternal(node); |
| if (!sourceMap) { |
| pair = { |
| code: result.toString(), |
| map: null |
| }; |
| return options.sourceMapWithCode ? pair : pair.code; |
| } |
| pair = result.toStringWithSourceMap({ |
| file: options.file, |
| sourceRoot: options.sourceMapRoot |
| }); |
| if (options.sourceContent) { |
| pair.map.setSourceContent(options.sourceMap, options.sourceContent); |
| } |
| if (options.sourceMapWithCode) { |
| return pair; |
| } |
| return pair.map.toString(); |
| } |
| FORMAT_MINIFY = { |
| indent: { |
| style: '', |
| base: 0 |
| }, |
| renumber: true, |
| hexadecimal: true, |
| quotes: 'auto', |
| escapeless: true, |
| compact: true, |
| parentheses: false, |
| semicolons: false |
| }; |
| FORMAT_DEFAULTS = getDefaultOptions().format; |
| exports.version = require('/package.json', module).version; |
| exports.generate = generate; |
| exports.attachComments = estraverse.attachComments; |
| exports.Precedence = updateDeeply({}, Precedence); |
| exports.browser = false; |
| exports.FORMAT_MINIFY = FORMAT_MINIFY; |
| exports.FORMAT_DEFAULTS = FORMAT_DEFAULTS; |
| }()); |
| }); |
| require.define('/package.json', function (module, exports, __dirname, __filename) { |
| module.exports = { |
| 'name': 'escodegen', |
| 'description': 'ECMAScript code generator', |
| 'homepage': 'http://github.com/estools/escodegen', |
| 'main': 'escodegen.js', |
| 'bin': { |
| 'esgenerate': './bin/esgenerate.js', |
| 'escodegen': './bin/escodegen.js' |
| }, |
| 'files': [ |
| 'LICENSE.BSD', |
| 'LICENSE.source-map', |
| 'README.md', |
| 'bin', |
| 'escodegen.js', |
| 'package.json' |
| ], |
| 'version': '1.8.0', |
| 'engines': { 'node': '>=0.12.0' }, |
| 'maintainers': [{ |
| 'name': 'Yusuke Suzuki', |
| 'email': 'utatane.tea@gmail.com', |
| 'web': 'http://github.com/Constellation' |
| }], |
| 'repository': { |
| 'type': 'git', |
| 'url': 'http://github.com/estools/escodegen.git' |
| }, |
| 'dependencies': { |
| 'estraverse': '^1.9.1', |
| 'esutils': '^2.0.2', |
| 'esprima': '^2.7.1', |
| 'optionator': '^0.8.1' |
| }, |
| 'optionalDependencies': { 'source-map': '~0.2.0' }, |
| 'devDependencies': { |
| 'acorn-6to5': '^0.11.1-25', |
| 'bluebird': '^2.3.11', |
| 'bower-registry-client': '^0.2.1', |
| 'chai': '^1.10.0', |
| 'commonjs-everywhere': '^0.9.7', |
| 'gulp': '^3.8.10', |
| 'gulp-eslint': '^0.2.0', |
| 'gulp-mocha': '^2.0.0', |
| 'semver': '^5.1.0' |
| }, |
| 'license': 'BSD-2-Clause', |
| 'scripts': { |
| 'test': 'gulp travis', |
| 'unit-test': 'gulp test', |
| 'lint': 'gulp lint', |
| 'release': 'node tools/release.js', |
| 'build-min': './node_modules/.bin/cjsify -ma path: tools/entry-point.js > escodegen.browser.min.js', |
| 'build': './node_modules/.bin/cjsify -a path: tools/entry-point.js > escodegen.browser.js' |
| } |
| }; |
| }); |
| require.define('/node_modules/source-map/lib/source-map.js', function (module, exports, __dirname, __filename) { |
| exports.SourceMapGenerator = require('/node_modules/source-map/lib/source-map/source-map-generator.js', module).SourceMapGenerator; |
| exports.SourceMapConsumer = require('/node_modules/source-map/lib/source-map/source-map-consumer.js', module).SourceMapConsumer; |
| exports.SourceNode = require('/node_modules/source-map/lib/source-map/source-node.js', module).SourceNode; |
| }); |
| require.define('/node_modules/source-map/lib/source-map/source-node.js', function (module, exports, __dirname, __filename) { |
| if (typeof define !== 'function') { |
| var define = require('/node_modules/source-map/node_modules/amdefine/amdefine.js', module)(module, require); |
| } |
| define(function (require, exports, module) { |
| var SourceMapGenerator = require('/node_modules/source-map/lib/source-map/source-map-generator.js', module).SourceMapGenerator; |
| var util = require('/node_modules/source-map/lib/source-map/util.js', module); |
| var REGEX_NEWLINE = /(\r?\n)/; |
| var NEWLINE_CODE = 10; |
| var isSourceNode = '$$$isSourceNode$$$'; |
| function SourceNode(aLine, aColumn, aSource, aChunks, aName) { |
| this.children = []; |
| this.sourceContents = {}; |
| this.line = aLine == null ? null : aLine; |
| this.column = aColumn == null ? null : aColumn; |
| this.source = aSource == null ? null : aSource; |
| this.name = aName == null ? null : aName; |
| this[isSourceNode] = true; |
| if (aChunks != null) |
| this.add(aChunks); |
| } |
| SourceNode.fromStringWithSourceMap = function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) { |
| var node = new SourceNode; |
| var remainingLines = aGeneratedCode.split(REGEX_NEWLINE); |
| var shiftNextLine = function () { |
| var lineContents = remainingLines.shift(); |
| var newLine = remainingLines.shift() || ''; |
| return lineContents + newLine; |
| }; |
| var lastGeneratedLine = 1, lastGeneratedColumn = 0; |
| var lastMapping = null; |
| aSourceMapConsumer.eachMapping(function (mapping) { |
| if (lastMapping !== null) { |
| if (lastGeneratedLine < mapping.generatedLine) { |
| var code = ''; |
| addMappingWithCode(lastMapping, shiftNextLine()); |
| lastGeneratedLine++; |
| lastGeneratedColumn = 0; |
| } else { |
| var nextLine = remainingLines[0]; |
| var code = nextLine.substr(0, mapping.generatedColumn - lastGeneratedColumn); |
| remainingLines[0] = nextLine.substr(mapping.generatedColumn - lastGeneratedColumn); |
| lastGeneratedColumn = mapping.generatedColumn; |
| addMappingWithCode(lastMapping, code); |
| lastMapping = mapping; |
| return; |
| } |
| } |
| while (lastGeneratedLine < mapping.generatedLine) { |
| node.add(shiftNextLine()); |
| lastGeneratedLine++; |
| } |
| if (lastGeneratedColumn < mapping.generatedColumn) { |
| var nextLine = remainingLines[0]; |
| node.add(nextLine.substr(0, mapping.generatedColumn)); |
| remainingLines[0] = nextLine.substr(mapping.generatedColumn); |
| lastGeneratedColumn = mapping.generatedColumn; |
| } |
| lastMapping = mapping; |
| }, this); |
| if (remainingLines.length > 0) { |
| if (lastMapping) { |
| addMappingWithCode(lastMapping, shiftNextLine()); |
| } |
| node.add(remainingLines.join('')); |
| } |
| aSourceMapConsumer.sources.forEach(function (sourceFile) { |
| var content = aSourceMapConsumer.sourceContentFor(sourceFile); |
| if (content != null) { |
| if (aRelativePath != null) { |
| sourceFile = util.join(aRelativePath, sourceFile); |
| } |
| node.setSourceContent(sourceFile, content); |
| } |
| }); |
| return node; |
| function addMappingWithCode(mapping, code) { |
| if (mapping === null || mapping.source === undefined) { |
| node.add(code); |
| } else { |
| var source = aRelativePath ? util.join(aRelativePath, mapping.source) : mapping.source; |
| node.add(new SourceNode(mapping.originalLine, mapping.originalColumn, source, code, mapping.name)); |
| } |
| } |
| }; |
| SourceNode.prototype.add = function SourceNode_add(aChunk) { |
| if (Array.isArray(aChunk)) { |
| aChunk.forEach(function (chunk) { |
| this.add(chunk); |
| }, this); |
| } else if (aChunk[isSourceNode] || typeof aChunk === 'string') { |
| if (aChunk) { |
| this.children.push(aChunk); |
| } |
| } else { |
| throw new TypeError('Expected a SourceNode, string, or an array of SourceNodes and strings. Got ' + aChunk); |
| } |
| return this; |
| }; |
| SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) { |
| if (Array.isArray(aChunk)) { |
| for (var i = aChunk.length - 1; i >= 0; i--) { |
| this.prepend(aChunk[i]); |
| } |
| } else if (aChunk[isSourceNode] || typeof aChunk === 'string') { |
| this.children.unshift(aChunk); |
| } else { |
| throw new TypeError('Expected a SourceNode, string, or an array of SourceNodes and strings. Got ' + aChunk); |
| } |
| return this; |
| }; |
| SourceNode.prototype.walk = function SourceNode_walk(aFn) { |
| var chunk; |
| for (var i = 0, len = this.children.length; i < len; i++) { |
| chunk = this.children[i]; |
| if (chunk[isSourceNode]) { |
| chunk.walk(aFn); |
| } else { |
| if (chunk !== '') { |
| aFn(chunk, { |
| source: this.source, |
| line: this.line, |
| column: this.column, |
| name: this.name |
| }); |
| } |
| } |
| } |
| }; |
| SourceNode.prototype.join = function SourceNode_join(aSep) { |
| var newChildren; |
| var i; |
| var len = this.children.length; |
| if (len > 0) { |
| newChildren = []; |
| for (i = 0; i < len - 1; i++) { |
| newChildren.push(this.children[i]); |
| newChildren.push(aSep); |
| } |
| newChildren.push(this.children[i]); |
| this.children = newChildren; |
| } |
| return this; |
| }; |
| SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) { |
| var lastChild = this.children[this.children.length - 1]; |
| if (lastChild[isSourceNode]) { |
| lastChild.replaceRight(aPattern, aReplacement); |
| } else if (typeof lastChild === 'string') { |
| this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement); |
| } else { |
| this.children.push(''.replace(aPattern, aReplacement)); |
| } |
| return this; |
| }; |
| SourceNode.prototype.setSourceContent = function SourceNode_setSourceContent(aSourceFile, aSourceContent) { |
| this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent; |
| }; |
| SourceNode.prototype.walkSourceContents = function SourceNode_walkSourceContents(aFn) { |
| for (var i = 0, len = this.children.length; i < len; i++) { |
| if (this.children[i][isSourceNode]) { |
| this.children[i].walkSourceContents(aFn); |
| } |
| } |
| var sources = Object.keys(this.sourceContents); |
| for (var i = 0, len = sources.length; i < len; i++) { |
| aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]); |
| } |
| }; |
| SourceNode.prototype.toString = function SourceNode_toString() { |
| var str = ''; |
| this.walk(function (chunk) { |
| str += chunk; |
| }); |
| return str; |
| }; |
| SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) { |
| var generated = { |
| code: '', |
| line: 1, |
| column: 0 |
| }; |
| var map = new SourceMapGenerator(aArgs); |
| var sourceMappingActive = false; |
| var lastOriginalSource = null; |
| var lastOriginalLine = null; |
| var lastOriginalColumn = null; |
| var lastOriginalName = null; |
| this.walk(function (chunk, original) { |
| generated.code += chunk; |
| if (original.source !== null && original.line !== null && original.column !== null) { |
| if (lastOriginalSource !== original.source || lastOriginalLine !== original.line || lastOriginalColumn !== original.column || lastOriginalName !== original.name) { |
| map.addMapping({ |
| source: original.source, |
| original: { |
| line: original.line, |
| column: original.column |
| }, |
| generated: { |
| line: generated.line, |
| column: generated.column |
| }, |
| name: original.name |
| }); |
| } |
| lastOriginalSource = original.source; |
| lastOriginalLine = original.line; |
| lastOriginalColumn = original.column; |
| lastOriginalName = original.name; |
| sourceMappingActive = true; |
| } else if (sourceMappingActive) { |
| map.addMapping({ |
| generated: { |
| line: generated.line, |
| column: generated.column |
| } |
| }); |
| lastOriginalSource = null; |
| sourceMappingActive = false; |
| } |
| for (var idx = 0, length = chunk.length; idx < length; idx++) { |
| if (chunk.charCodeAt(idx) === NEWLINE_CODE) { |
| generated.line++; |
| generated.column = 0; |
| if (idx + 1 === length) { |
| lastOriginalSource = null; |
| sourceMappingActive = false; |
| } else if (sourceMappingActive) { |
| map.addMapping({ |
| source: original.source, |
| original: { |
| line: original.line, |
| column: original.column |
| }, |
| generated: { |
| line: generated.line, |
| column: generated.column |
| }, |
| name: original.name |
| }); |
| } |
| } else { |
| generated.column++; |
| } |
| } |
| }); |
| this.walkSourceContents(function (sourceFile, sourceContent) { |
| map.setSourceContent(sourceFile, sourceContent); |
| }); |
| return { |
| code: generated.code, |
| map: map |
| }; |
| }; |
| exports.SourceNode = SourceNode; |
| }); |
| }); |
| require.define('/node_modules/source-map/lib/source-map/util.js', function (module, exports, __dirname, __filename) { |
| if (typeof define !== 'function') { |
| var define = require('/node_modules/source-map/node_modules/amdefine/amdefine.js', module)(module, require); |
| } |
| define(function (require, exports, module) { |
| function getArg(aArgs, aName, aDefaultValue) { |
| if (aName in aArgs) { |
| return aArgs[aName]; |
| } else if (arguments.length === 3) { |
| return aDefaultValue; |
| } else { |
| throw new Error('"' + aName + '" is a required argument.'); |
| } |
| } |
| exports.getArg = getArg; |
| var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.]*)(?::(\d+))?(\S*)$/; |
| var dataUrlRegexp = /^data:.+\,.+$/; |
| function urlParse(aUrl) { |
| var match = aUrl.match(urlRegexp); |
| if (!match) { |
| return null; |
| } |
| return { |
| scheme: match[1], |
| auth: match[2], |
| host: match[3], |
| port: match[4], |
| path: match[5] |
| }; |
| } |
| exports.urlParse = urlParse; |
| function urlGenerate(aParsedUrl) { |
| var url = ''; |
| if (aParsedUrl.scheme) { |
| url += aParsedUrl.scheme + ':'; |
| } |
| url += '//'; |
| if (aParsedUrl.auth) { |
| url += aParsedUrl.auth + '@'; |
| } |
| if (aParsedUrl.host) { |
| url += aParsedUrl.host; |
| } |
| if (aParsedUrl.port) { |
| url += ':' + aParsedUrl.port; |
| } |
| if (aParsedUrl.path) { |
| url += aParsedUrl.path; |
| } |
| return url; |
| } |
| exports.urlGenerate = urlGenerate; |
| function normalize(aPath) { |
| var path = aPath; |
| var url = urlParse(aPath); |
| if (url) { |
| if (!url.path) { |
| return aPath; |
| } |
| path = url.path; |
| } |
| var isAbsolute = path.charAt(0) === '/'; |
| var parts = path.split(/\/+/); |
| for (var part, up = 0, i = parts.length - 1; i >= 0; i--) { |
| part = parts[i]; |
| if (part === '.') { |
| parts.splice(i, 1); |
| } else if (part === '..') { |
| up++; |
| } else if (up > 0) { |
| if (part === '') { |
| parts.splice(i + 1, up); |
| up = 0; |
| } else { |
| parts.splice(i, 2); |
| up--; |
| } |
| } |
| } |
| path = parts.join('/'); |
| if (path === '') { |
| path = isAbsolute ? '/' : '.'; |
| } |
| if (url) { |
| url.path = path; |
| return urlGenerate(url); |
| } |
| return path; |
| } |
| exports.normalize = normalize; |
| function join(aRoot, aPath) { |
| if (aRoot === '') { |
| aRoot = '.'; |
| } |
| if (aPath === '') { |
| aPath = '.'; |
| } |
| var aPathUrl = urlParse(aPath); |
| var aRootUrl = urlParse(aRoot); |
| if (aRootUrl) { |
| aRoot = aRootUrl.path || '/'; |
| } |
| if (aPathUrl && !aPathUrl.scheme) { |
| if (aRootUrl) { |
| aPathUrl.scheme = aRootUrl.scheme; |
| } |
| return urlGenerate(aPathUrl); |
| } |
| if (aPathUrl || aPath.match(dataUrlRegexp)) { |
| return aPath; |
| } |
| if (aRootUrl && !aRootUrl.host && !aRootUrl.path) { |
| aRootUrl.host = aPath; |
| return urlGenerate(aRootUrl); |
| } |
| var joined = aPath.charAt(0) === '/' ? aPath : normalize(aRoot.replace(/\/+$/, '') + '/' + aPath); |
| if (aRootUrl) { |
| aRootUrl.path = joined; |
| return urlGenerate(aRootUrl); |
| } |
| return joined; |
| } |
| exports.join = join; |
| function relative(aRoot, aPath) { |
| if (aRoot === '') { |
| aRoot = '.'; |
| } |
| aRoot = aRoot.replace(/\/$/, ''); |
| var url = urlParse(aRoot); |
| if (aPath.charAt(0) == '/' && url && url.path == '/') { |
| return aPath.slice(1); |
| } |
| return aPath.indexOf(aRoot + '/') === 0 ? aPath.substr(aRoot.length + 1) : aPath; |
| } |
| exports.relative = relative; |
| function toSetString(aStr) { |
| return '$' + aStr; |
| } |
| exports.toSetString = toSetString; |
| function fromSetString(aStr) { |
| return aStr.substr(1); |
| } |
| exports.fromSetString = fromSetString; |
| function strcmp(aStr1, aStr2) { |
| var s1 = aStr1 || ''; |
| var s2 = aStr2 || ''; |
| return (s1 > s2) - (s1 < s2); |
| } |
| function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) { |
| var cmp; |
| cmp = strcmp(mappingA.source, mappingB.source); |
| if (cmp) { |
| return cmp; |
| } |
| cmp = mappingA.originalLine - mappingB.originalLine; |
| if (cmp) { |
| return cmp; |
| } |
| cmp = mappingA.originalColumn - mappingB.originalColumn; |
| if (cmp || onlyCompareOriginal) { |
| return cmp; |
| } |
| cmp = strcmp(mappingA.name, mappingB.name); |
| if (cmp) { |
| return cmp; |
| } |
| cmp = mappingA.generatedLine - mappingB.generatedLine; |
| if (cmp) { |
| return cmp; |
| } |
| return mappingA.generatedColumn - mappingB.generatedColumn; |
| } |
| ; |
| exports.compareByOriginalPositions = compareByOriginalPositions; |
| function compareByGeneratedPositions(mappingA, mappingB, onlyCompareGenerated) { |
| var cmp; |
| cmp = mappingA.generatedLine - mappingB.generatedLine; |
| if (cmp) { |
| return cmp; |
| } |
| cmp = mappingA.generatedColumn - mappingB.generatedColumn; |
| if (cmp || onlyCompareGenerated) { |
| return cmp; |
| } |
| cmp = strcmp(mappingA.source, mappingB.source); |
| if (cmp) { |
| return cmp; |
| } |
| cmp = mappingA.originalLine - mappingB.originalLine; |
| if (cmp) { |
| return cmp; |
| } |
| cmp = mappingA.originalColumn - mappingB.originalColumn; |
| if (cmp) { |
| return cmp; |
| } |
| return strcmp(mappingA.name, mappingB.name); |
| } |
| ; |
| exports.compareByGeneratedPositions = compareByGeneratedPositions; |
| }); |
| }); |
| require.define('/node_modules/source-map/node_modules/amdefine/amdefine.js', function (module, exports, __dirname, __filename) { |
| 'use strict'; |
| function amdefine(module, requireFn) { |
| 'use strict'; |
| var defineCache = {}, loaderCache = {}, alreadyCalled = false, path = require('path', module), makeRequire, stringRequire; |
| function trimDots(ary) { |
| var i, part; |
| for (i = 0; ary[i]; i += 1) { |
| part = ary[i]; |
| if (part === '.') { |
| ary.splice(i, 1); |
| i -= 1; |
| } else if (part === '..') { |
| if (i === 1 && (ary[2] === '..' || ary[0] === '..')) { |
| break; |
| } else if (i > 0) { |
| ary.splice(i - 1, 2); |
| i -= 2; |
| } |
| } |
| } |
| } |
| function normalize(name, baseName) { |
| var baseParts; |
| if (name && name.charAt(0) === '.') { |
| if (baseName) { |
| baseParts = baseName.split('/'); |
| baseParts = baseParts.slice(0, baseParts.length - 1); |
| baseParts = baseParts.concat(name.split('/')); |
| trimDots(baseParts); |
| name = baseParts.join('/'); |
| } |
| } |
| return name; |
| } |
| function makeNormalize(relName) { |
| return function (name) { |
| return normalize(name, relName); |
| }; |
| } |
| function makeLoad(id) { |
| function load(value) { |
| loaderCache[id] = value; |
| } |
| load.fromText = function (id, text) { |
| throw new Error('amdefine does not implement load.fromText'); |
| }; |
| return load; |
| } |
| makeRequire = function (systemRequire, exports, module, relId) { |
| function amdRequire(deps, callback) { |
| if (typeof deps === 'string') { |
| return stringRequire(systemRequire, exports, module, deps, relId); |
| } else { |
| deps = deps.map(function (depName) { |
| return stringRequire(systemRequire, exports, module, depName, relId); |
| }); |
| if (callback) { |
| process.nextTick(function () { |
| callback.apply(null, deps); |
| }); |
| } |
| } |
| } |
| amdRequire.toUrl = function (filePath) { |
| if (filePath.indexOf('.') === 0) { |
| return normalize(filePath, path.dirname(module.filename)); |
| } else { |
| return filePath; |
| } |
| }; |
| return amdRequire; |
| }; |
| requireFn = requireFn || function req() { |
| return module.require.apply(module, arguments); |
| }; |
| function runFactory(id, deps, factory) { |
| var r, e, m, result; |
| if (id) { |
| e = loaderCache[id] = {}; |
| m = { |
| id: id, |
| uri: __filename, |
| exports: e |
| }; |
| r = makeRequire(requireFn, e, m, id); |
| } else { |
| if (alreadyCalled) { |
| throw new Error('amdefine with no module ID cannot be called more than once per file.'); |
| } |
| alreadyCalled = true; |
| e = module.exports; |
| m = module; |
| r = makeRequire(requireFn, e, m, module.id); |
| } |
| if (deps) { |
| deps = deps.map(function (depName) { |
| return r(depName); |
| }); |
| } |
| if (typeof factory === 'function') { |
| result = factory.apply(m.exports, deps); |
| } else { |
| result = factory; |
| } |
| if (result !== undefined) { |
| m.exports = result; |
| if (id) { |
| loaderCache[id] = m.exports; |
| } |
| } |
| } |
| stringRequire = function (systemRequire, exports, module, id, relId) { |
| var index = id.indexOf('!'), originalId = id, prefix, plugin; |
| if (index === -1) { |
| id = normalize(id, relId); |
| if (id === 'require') { |
| return makeRequire(systemRequire, exports, module, relId); |
| } else if (id === 'exports') { |
| return exports; |
| } else if (id === 'module') { |
| return module; |
| } else if (loaderCache.hasOwnProperty(id)) { |
| return loaderCache[id]; |
| } else if (defineCache[id]) { |
| runFactory.apply(null, defineCache[id]); |
| return loaderCache[id]; |
| } else { |
| if (systemRequire) { |
| return systemRequire(originalId); |
| } else { |
| throw new Error('No module with ID: ' + id); |
| } |
| } |
| } else { |
| prefix = id.substring(0, index); |
| id = id.substring(index + 1, id.length); |
| plugin = stringRequire(systemRequire, exports, module, prefix, relId); |
| if (plugin.normalize) { |
| id = plugin.normalize(id, makeNormalize(relId)); |
| } else { |
| id = normalize(id, relId); |
| } |
| if (loaderCache[id]) { |
| return loaderCache[id]; |
| } else { |
| plugin.load(id, makeRequire(systemRequire, exports, module, relId), makeLoad(id), {}); |
| return loaderCache[id]; |
| } |
| } |
| }; |
| function define(id, deps, factory) { |
| if (Array.isArray(id)) { |
| factory = deps; |
| deps = id; |
| id = undefined; |
| } else if (typeof id !== 'string') { |
| factory = id; |
| id = deps = undefined; |
| } |
| if (deps && !Array.isArray(deps)) { |
| factory = deps; |
| deps = undefined; |
| } |
| if (!deps) { |
| deps = [ |
| 'require', |
| 'exports', |
| 'module' |
| ]; |
| } |
| if (id) { |
| defineCache[id] = [ |
| id, |
| deps, |
| factory |
| ]; |
| } else { |
| runFactory(id, deps, factory); |
| } |
| } |
| define.require = function (id) { |
| if (loaderCache[id]) { |
| return loaderCache[id]; |
| } |
| if (defineCache[id]) { |
| runFactory.apply(null, defineCache[id]); |
| return loaderCache[id]; |
| } |
| }; |
| define.amd = {}; |
| return define; |
| } |
| module.exports = amdefine; |
| }); |
| require.define('/node_modules/source-map/lib/source-map/source-map-generator.js', function (module, exports, __dirname, __filename) { |
| if (typeof define !== 'function') { |
| var define = require('/node_modules/source-map/node_modules/amdefine/amdefine.js', module)(module, require); |
| } |
| define(function (require, exports, module) { |
| var base64VLQ = require('/node_modules/source-map/lib/source-map/base64-vlq.js', module); |
| var util = require('/node_modules/source-map/lib/source-map/util.js', module); |
| var ArraySet = require('/node_modules/source-map/lib/source-map/array-set.js', module).ArraySet; |
| var MappingList = require('/node_modules/source-map/lib/source-map/mapping-list.js', module).MappingList; |
| function SourceMapGenerator(aArgs) { |
| if (!aArgs) { |
| aArgs = {}; |
| } |
| this._file = util.getArg(aArgs, 'file', null); |
| this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null); |
| this._skipValidation = util.getArg(aArgs, 'skipValidation', false); |
| this._sources = new ArraySet; |
| this._names = new ArraySet; |
| this._mappings = new MappingList; |
| this._sourcesContents = null; |
| } |
| SourceMapGenerator.prototype._version = 3; |
| SourceMapGenerator.fromSourceMap = function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) { |
| var sourceRoot = aSourceMapConsumer.sourceRoot; |
| var generator = new SourceMapGenerator({ |
| file: aSourceMapConsumer.file, |
| sourceRoot: sourceRoot |
| }); |
| aSourceMapConsumer.eachMapping(function (mapping) { |
| var newMapping = { |
| generated: { |
| line: mapping.generatedLine, |
| column: mapping.generatedColumn |
| } |
| }; |
| if (mapping.source != null) { |
| newMapping.source = mapping.source; |
| if (sourceRoot != null) { |
| newMapping.source = util.relative(sourceRoot, newMapping.source); |
| } |
| newMapping.original = { |
| line: mapping.originalLine, |
| column: mapping.originalColumn |
| }; |
| if (mapping.name != null) { |
| newMapping.name = mapping.name; |
| } |
| } |
| generator.addMapping(newMapping); |
| }); |
| aSourceMapConsumer.sources.forEach(function (sourceFile) { |
| var content = aSourceMapConsumer.sourceContentFor(sourceFile); |
| if (content != null) { |
| generator.setSourceContent(sourceFile, content); |
| } |
| }); |
| return generator; |
| }; |
| SourceMapGenerator.prototype.addMapping = function SourceMapGenerator_addMapping(aArgs) { |
| var generated = util.getArg(aArgs, 'generated'); |
| var original = util.getArg(aArgs, 'original', null); |
| var source = util.getArg(aArgs, 'source', null); |
| var name = util.getArg(aArgs, 'name', null); |
| if (!this._skipValidation) { |
| this._validateMapping(generated, original, source, name); |
| } |
| if (source != null && !this._sources.has(source)) { |
| this._sources.add(source); |
| } |
| if (name != null && !this._names.has(name)) { |
| this._names.add(name); |
| } |
| this._mappings.add({ |
| generatedLine: generated.line, |
| generatedColumn: generated.column, |
| originalLine: original != null && original.line, |
| originalColumn: original != null && original.column, |
| source: source, |
| name: name |
| }); |
| }; |
| SourceMapGenerator.prototype.setSourceContent = function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) { |
| var source = aSourceFile; |
| if (this._sourceRoot != null) { |
| source = util.relative(this._sourceRoot, source); |
| } |
| if (aSourceContent != null) { |
| if (!this._sourcesContents) { |
| this._sourcesContents = {}; |
| } |
| this._sourcesContents[util.toSetString(source)] = aSourceContent; |
| } else if (this._sourcesContents) { |
| delete this._sourcesContents[util.toSetString(source)]; |
| if (Object.keys(this._sourcesContents).length === 0) { |
| this._sourcesContents = null; |
| } |
| } |
| }; |
| SourceMapGenerator.prototype.applySourceMap = function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) { |
| var sourceFile = aSourceFile; |
| if (aSourceFile == null) { |
| if (aSourceMapConsumer.file == null) { |
| throw new Error('SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' + 'or the source map\'s "file" property. Both were omitted.'); |
| } |
| sourceFile = aSourceMapConsumer.file; |
| } |
| var sourceRoot = this._sourceRoot; |
| if (sourceRoot != null) { |
| sourceFile = util.relative(sourceRoot, sourceFile); |
| } |
| var newSources = new ArraySet; |
| var newNames = new ArraySet; |
| this._mappings.unsortedForEach(function (mapping) { |
| if (mapping.source === sourceFile && mapping.originalLine != null) { |
| var original = aSourceMapConsumer.originalPositionFor({ |
| line: mapping.originalLine, |
| column: mapping.originalColumn |
| }); |
| if (original.source != null) { |
| mapping.source = original.source; |
| if (aSourceMapPath != null) { |
| mapping.source = util.join(aSourceMapPath, mapping.source); |
| } |
| if (sourceRoot != null) { |
| mapping.source = util.relative(sourceRoot, mapping.source); |
| } |
| mapping.originalLine = original.line; |
| mapping.originalColumn = original.column; |
| if (original.name != null) { |
| mapping.name = original.name; |
| } |
| } |
| } |
| var source = mapping.source; |
| if (source != null && !newSources.has(source)) { |
| newSources.add(source); |
| } |
| var name = mapping.name; |
| if (name != null && !newNames.has(name)) { |
| newNames.add(name); |
| } |
| }, this); |
| this._sources = newSources; |
| this._names = newNames; |
| aSourceMapConsumer.sources.forEach(function (sourceFile) { |
| var content = aSourceMapConsumer.sourceContentFor(sourceFile); |
| if (content != null) { |
| if (aSourceMapPath != null) { |
| sourceFile = util.join(aSourceMapPath, sourceFile); |
| } |
| if (sourceRoot != null) { |
| sourceFile = util.relative(sourceRoot, sourceFile); |
| } |
| this.setSourceContent(sourceFile, content); |
| } |
| }, this); |
| }; |
| SourceMapGenerator.prototype._validateMapping = function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource, aName) { |
| if (aGenerated && 'line' in aGenerated && 'column' in aGenerated && aGenerated.line > 0 && aGenerated.column >= 0 && !aOriginal && !aSource && !aName) { |
| return; |
| } else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated && aOriginal && 'line' in aOriginal && 'column' in aOriginal && aGenerated.line > 0 && aGenerated.column >= 0 && aOriginal.line > 0 && aOriginal.column >= 0 && aSource) { |
| return; |
| } else { |
| throw new Error('Invalid mapping: ' + JSON.stringify({ |
| generated: aGenerated, |
| source: aSource, |
| original: aOriginal, |
| name: aName |
| })); |
| } |
| }; |
| SourceMapGenerator.prototype._serializeMappings = function SourceMapGenerator_serializeMappings() { |
| var previousGeneratedColumn = 0; |
| var previousGeneratedLine = 1; |
| var previousOriginalColumn = 0; |
| var previousOriginalLine = 0; |
| var previousName = 0; |
| var previousSource = 0; |
| var result = ''; |
| var mapping; |
| var mappings = this._mappings.toArray(); |
| for (var i = 0, len = mappings.length; i < len; i++) { |
| mapping = mappings[i]; |
| if (mapping.generatedLine !== previousGeneratedLine) { |
| previousGeneratedColumn = 0; |
| while (mapping.generatedLine !== previousGeneratedLine) { |
| result += ';'; |
| previousGeneratedLine++; |
| } |
| } else { |
| if (i > 0) { |
| if (!util.compareByGeneratedPositions(mapping, mappings[i - 1])) { |
| continue; |
| } |
| result += ','; |
| } |
| } |
| result += base64VLQ.encode(mapping.generatedColumn - previousGeneratedColumn); |
| previousGeneratedColumn = mapping.generatedColumn; |
| if (mapping.source != null) { |
| result += base64VLQ.encode(this._sources.indexOf(mapping.source) - previousSource); |
| previousSource = this._sources.indexOf(mapping.source); |
| result += base64VLQ.encode(mapping.originalLine - 1 - previousOriginalLine); |
| previousOriginalLine = mapping.originalLine - 1; |
| result += base64VLQ.encode(mapping.originalColumn - previousOriginalColumn); |
| previousOriginalColumn = mapping.originalColumn; |
| if (mapping.name != null) { |
| result += base64VLQ.encode(this._names.indexOf(mapping.name) - previousName); |
| previousName = this._names.indexOf(mapping.name); |
| } |
| } |
| } |
| return result; |
| }; |
| SourceMapGenerator.prototype._generateSourcesContent = function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) { |
| return aSources.map(function (source) { |
| if (!this._sourcesContents) { |
| return null; |
| } |
| if (aSourceRoot != null) { |
| source = util.relative(aSourceRoot, source); |
| } |
| var key = util.toSetString(source); |
| return Object.prototype.hasOwnProperty.call(this._sourcesContents, key) ? this._sourcesContents[key] : null; |
| }, this); |
| }; |
| SourceMapGenerator.prototype.toJSON = function SourceMapGenerator_toJSON() { |
| var map = { |
| version: this._version, |
| sources: this._sources.toArray(), |
| names: this._names.toArray(), |
| mappings: this._serializeMappings() |
| }; |
| if (this._file != null) { |
| map.file = this._file; |
| } |
| if (this._sourceRoot != null) { |
| map.sourceRoot = this._sourceRoot; |
| } |
| if (this._sourcesContents) { |
| map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot); |
| } |
| return map; |
| }; |
| SourceMapGenerator.prototype.toString = function SourceMapGenerator_toString() { |
| return JSON.stringify(this); |
| }; |
| exports.SourceMapGenerator = SourceMapGenerator; |
| }); |
| }); |
| require.define('/node_modules/source-map/lib/source-map/mapping-list.js', function (module, exports, __dirname, __filename) { |
| if (typeof define !== 'function') { |
| var define = require('/node_modules/source-map/node_modules/amdefine/amdefine.js', module)(module, require); |
| } |
| define(function (require, exports, module) { |
| var util = require('/node_modules/source-map/lib/source-map/util.js', module); |
| function generatedPositionAfter(mappingA, mappingB) { |
| var lineA = mappingA.generatedLine; |
| var lineB = mappingB.generatedLine; |
| var columnA = mappingA.generatedColumn; |
| var columnB = mappingB.generatedColumn; |
| return lineB > lineA || lineB == lineA && columnB >= columnA || util.compareByGeneratedPositions(mappingA, mappingB) <= 0; |
| } |
| function MappingList() { |
| this._array = []; |
| this._sorted = true; |
| this._last = { |
| generatedLine: -1, |
| generatedColumn: 0 |
| }; |
| } |
| MappingList.prototype.unsortedForEach = function MappingList_forEach(aCallback, aThisArg) { |
| this._array.forEach(aCallback, aThisArg); |
| }; |
| MappingList.prototype.add = function MappingList_add(aMapping) { |
| var mapping; |
| if (generatedPositionAfter(this._last, aMapping)) { |
| this._last = aMapping; |
| this._array.push(aMapping); |
| } else { |
| this._sorted = false; |
| this._array.push(aMapping); |
| } |
| }; |
| MappingList.prototype.toArray = function MappingList_toArray() { |
| if (!this._sorted) { |
| this._array.sort(util.compareByGeneratedPositions); |
| this._sorted = true; |
| } |
| return this._array; |
| }; |
| exports.MappingList = MappingList; |
| }); |
| }); |
| require.define('/node_modules/source-map/lib/source-map/array-set.js', function (module, exports, __dirname, __filename) { |
| if (typeof define !== 'function') { |
| var define = require('/node_modules/source-map/node_modules/amdefine/amdefine.js', module)(module, require); |
| } |
| define(function (require, exports, module) { |
| var util = require('/node_modules/source-map/lib/source-map/util.js', module); |
| function ArraySet() { |
| this._array = []; |
| this._set = {}; |
| } |
| 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; |
| }; |
| 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; |
| } |
| }; |
| ArraySet.prototype.has = function ArraySet_has(aStr) { |
| return Object.prototype.hasOwnProperty.call(this._set, util.toSetString(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.'); |
| }; |
| 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); |
| }; |
| ArraySet.prototype.toArray = function ArraySet_toArray() { |
| return this._array.slice(); |
| }; |
| exports.ArraySet = ArraySet; |
| }); |
| }); |
| require.define('/node_modules/source-map/lib/source-map/base64-vlq.js', function (module, exports, __dirname, __filename) { |
| if (typeof define !== 'function') { |
| var define = require('/node_modules/source-map/node_modules/amdefine/amdefine.js', module)(module, require); |
| } |
| define(function (require, exports, module) { |
| var base64 = require('/node_modules/source-map/lib/source-map/base64.js', module); |
| var VLQ_BASE_SHIFT = 5; |
| var VLQ_BASE = 1 << VLQ_BASE_SHIFT; |
| var VLQ_BASE_MASK = VLQ_BASE - 1; |
| var VLQ_CONTINUATION_BIT = VLQ_BASE; |
| function toVLQSigned(aValue) { |
| return aValue < 0 ? (-aValue << 1) + 1 : (aValue << 1) + 0; |
| } |
| function fromVLQSigned(aValue) { |
| var isNegative = (aValue & 1) === 1; |
| var shifted = aValue >> 1; |
| return isNegative ? -shifted : shifted; |
| } |
| 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) { |
| digit |= VLQ_CONTINUATION_BIT; |
| } |
| encoded += base64.encode(digit); |
| } while (vlq > 0); |
| return encoded; |
| }; |
| exports.decode = function base64VLQ_decode(aStr, aOutParam) { |
| 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); |
| aOutParam.value = fromVLQSigned(result); |
| aOutParam.rest = aStr.slice(i); |
| }; |
| }); |
| }); |
| require.define('/node_modules/source-map/lib/source-map/base64.js', function (module, exports, __dirname, __filename) { |
| if (typeof define !== 'function') { |
| var define = require('/node_modules/source-map/node_modules/amdefine/amdefine.js', module)(module, require); |
| } |
| define(function (require, exports, module) { |
| var charToIntMap = {}; |
| var intToCharMap = {}; |
| 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('').forEach(function (ch, index) { |
| charToIntMap[ch] = index; |
| intToCharMap[index] = ch; |
| }); |
| exports.encode = function base64_encode(aNumber) { |
| if (aNumber in intToCharMap) { |
| return intToCharMap[aNumber]; |
| } |
| throw new TypeError('Must be between 0 and 63: ' + aNumber); |
| }; |
| exports.decode = function base64_decode(aChar) { |
| if (aChar in charToIntMap) { |
| return charToIntMap[aChar]; |
| } |
| throw new TypeError('Not a valid base 64 digit: ' + aChar); |
| }; |
| }); |
| }); |
| require.define('/node_modules/source-map/lib/source-map/source-map-consumer.js', function (module, exports, __dirname, __filename) { |
| if (typeof define !== 'function') { |
| var define = require('/node_modules/source-map/node_modules/amdefine/amdefine.js', module)(module, require); |
| } |
| define(function (require, exports, module) { |
| var util = require('/node_modules/source-map/lib/source-map/util.js', module); |
| function SourceMapConsumer(aSourceMap) { |
| var sourceMap = aSourceMap; |
| if (typeof aSourceMap === 'string') { |
| sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, '')); |
| } |
| if (sourceMap.sections != null) { |
| var indexedSourceMapConsumer = require('/node_modules/source-map/lib/source-map/indexed-source-map-consumer.js', module); |
| return new indexedSourceMapConsumer.IndexedSourceMapConsumer(sourceMap); |
| } else { |
| var basicSourceMapConsumer = require('/node_modules/source-map/lib/source-map/basic-source-map-consumer.js', module); |
| return new basicSourceMapConsumer.BasicSourceMapConsumer(sourceMap); |
| } |
| } |
| SourceMapConsumer.fromSourceMap = function (aSourceMap) { |
| var basicSourceMapConsumer = require('/node_modules/source-map/lib/source-map/basic-source-map-consumer.js', module); |
| return basicSourceMapConsumer.BasicSourceMapConsumer.fromSourceMap(aSourceMap); |
| }; |
| SourceMapConsumer.prototype._version = 3; |
| SourceMapConsumer.prototype.__generatedMappings = null; |
| Object.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', { |
| get: function () { |
| if (!this.__generatedMappings) { |
| this.__generatedMappings = []; |
| this.__originalMappings = []; |
| this._parseMappings(this._mappings, this.sourceRoot); |
| } |
| return this.__generatedMappings; |
| } |
| }); |
| SourceMapConsumer.prototype.__originalMappings = null; |
| Object.defineProperty(SourceMapConsumer.prototype, '_originalMappings', { |
| get: function () { |
| if (!this.__originalMappings) { |
| this.__generatedMappings = []; |
| this.__originalMappings = []; |
| this._parseMappings(this._mappings, this.sourceRoot); |
| } |
| return this.__originalMappings; |
| } |
| }); |
| SourceMapConsumer.prototype._nextCharIsMappingSeparator = function SourceMapConsumer_nextCharIsMappingSeparator(aStr) { |
| var c = aStr.charAt(0); |
| return c === ';' || c === ','; |
| }; |
| SourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) { |
| throw new Error('Subclasses must implement _parseMappings'); |
| }; |
| SourceMapConsumer.GENERATED_ORDER = 1; |
| SourceMapConsumer.ORIGINAL_ORDER = 2; |
| SourceMapConsumer.prototype.eachMapping = function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) { |
| var context = aContext || null; |
| var order = aOrder || SourceMapConsumer.GENERATED_ORDER; |
| var mappings; |
| switch (order) { |
| case SourceMapConsumer.GENERATED_ORDER: |
| mappings = this._generatedMappings; |
| break; |
| case SourceMapConsumer.ORIGINAL_ORDER: |
| mappings = this._originalMappings; |
| break; |
| default: |
| throw new Error('Unknown order of iteration.'); |
| } |
| var sourceRoot = this.sourceRoot; |
| mappings.map(function (mapping) { |
| var source = mapping.source; |
| if (source != null && sourceRoot != null) { |
| source = util.join(sourceRoot, source); |
| } |
| return { |
| source: source, |
| generatedLine: mapping.generatedLine, |
| generatedColumn: mapping.generatedColumn, |
| originalLine: mapping.originalLine, |
| originalColumn: mapping.originalColumn, |
| name: mapping.name |
| }; |
| }).forEach(aCallback, context); |
| }; |
| SourceMapConsumer.prototype.allGeneratedPositionsFor = function SourceMapConsumer_allGeneratedPositionsFor(aArgs) { |
| var needle = { |
| source: util.getArg(aArgs, 'source'), |
| originalLine: util.getArg(aArgs, 'line'), |
| originalColumn: Infinity |
| }; |
| if (this.sourceRoot != null) { |
| needle.source = util.relative(this.sourceRoot, needle.source); |
| } |
| var mappings = []; |
| var index = this._findMapping(needle, this._originalMappings, 'originalLine', 'originalColumn', util.compareByOriginalPositions); |
| if (index >= 0) { |
| var mapping = this._originalMappings[index]; |
| while (mapping && mapping.originalLine === needle.originalLine) { |
| mappings.push({ |
| line: util.getArg(mapping, 'generatedLine', null), |
| column: util.getArg(mapping, 'generatedColumn', null), |
| lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null) |
| }); |
| mapping = this._originalMappings[--index]; |
| } |
| } |
| return mappings.reverse(); |
| }; |
| exports.SourceMapConsumer = SourceMapConsumer; |
| }); |
| }); |
| require.define('/node_modules/source-map/lib/source-map/basic-source-map-consumer.js', function (module, exports, __dirname, __filename) { |
| if (typeof define !== 'function') { |
| var define = require('/node_modules/source-map/node_modules/amdefine/amdefine.js', module)(module, require); |
| } |
| define(function (require, exports, module) { |
| var util = require('/node_modules/source-map/lib/source-map/util.js', module); |
| var binarySearch = require('/node_modules/source-map/lib/source-map/binary-search.js', module); |
| var ArraySet = require('/node_modules/source-map/lib/source-map/array-set.js', module).ArraySet; |
| var base64VLQ = require('/node_modules/source-map/lib/source-map/base64-vlq.js', module); |
| var SourceMapConsumer = require('/node_modules/source-map/lib/source-map/source-map-consumer.js', module).SourceMapConsumer; |
| function BasicSourceMapConsumer(aSourceMap) { |
| var sourceMap = aSourceMap; |
| if (typeof aSourceMap === 'string') { |
| sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, '')); |
| } |
| var version = util.getArg(sourceMap, 'version'); |
| var sources = util.getArg(sourceMap, 'sources'); |
| var names = util.getArg(sourceMap, 'names', []); |
| var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null); |
| var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null); |
| var mappings = util.getArg(sourceMap, 'mappings'); |
| var file = util.getArg(sourceMap, 'file', null); |
| if (version != this._version) { |
| throw new Error('Unsupported version: ' + version); |
| } |
| sources = sources.map(util.normalize); |
| this._names = ArraySet.fromArray(names, true); |
| this._sources = ArraySet.fromArray(sources, true); |
| this.sourceRoot = sourceRoot; |
| this.sourcesContent = sourcesContent; |
| this._mappings = mappings; |
| this.file = file; |
| } |
| BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype); |
| BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer; |
| BasicSourceMapConsumer.fromSourceMap = function SourceMapConsumer_fromSourceMap(aSourceMap) { |
| var smc = Object.create(BasicSourceMapConsumer.prototype); |
| smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true); |
| smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true); |
| smc.sourceRoot = aSourceMap._sourceRoot; |
| smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(), smc.sourceRoot); |
| smc.file = aSourceMap._file; |
| smc.__generatedMappings = aSourceMap._mappings.toArray().slice(); |
| smc.__originalMappings = aSourceMap._mappings.toArray().slice().sort(util.compareByOriginalPositions); |
| return smc; |
| }; |
| BasicSourceMapConsumer.prototype._version = 3; |
| Object.defineProperty(BasicSourceMapConsumer.prototype, 'sources', { |
| get: function () { |
| return this._sources.toArray().map(function (s) { |
| return this.sourceRoot != null ? util.join(this.sourceRoot, s) : s; |
| }, this); |
| } |
| }); |
| BasicSourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) { |
| var generatedLine = 1; |
| var previousGeneratedColumn = 0; |
| var previousOriginalLine = 0; |
| var previousOriginalColumn = 0; |
| var previousSource = 0; |
| var previousName = 0; |
| var str = aStr; |
| var temp = {}; |
| var mapping; |
| while (str.length > 0) { |
| if (str.charAt(0) === ';') { |
| generatedLine++; |
| str = str.slice(1); |
| previousGeneratedColumn = 0; |
| } else if (str.charAt(0) === ',') { |
| str = str.slice(1); |
| } else { |
| mapping = {}; |
| mapping.generatedLine = generatedLine; |
| base64VLQ.decode(str, temp); |
| mapping.generatedColumn = previousGeneratedColumn + temp.value; |
| previousGeneratedColumn = mapping.generatedColumn; |
| str = temp.rest; |
| if (str.length > 0 && !this._nextCharIsMappingSeparator(str)) { |
| base64VLQ.decode(str, temp); |
| mapping.source = this._sources.at(previousSource + temp.value); |
| previousSource += temp.value; |
| str = temp.rest; |
| if (str.length === 0 || this._nextCharIsMappingSeparator(str)) { |
| throw new Error('Found a source, but no line and column'); |
| } |
| base64VLQ.decode(str, temp); |
| mapping.originalLine = previousOriginalLine + temp.value; |
| previousOriginalLine = mapping.originalLine; |
| mapping.originalLine += 1; |
| str = temp.rest; |
| if (str.length === 0 || this._nextCharIsMappingSeparator(str)) { |
| throw new Error('Found a source and line, but no column'); |
| } |
| base64VLQ.decode(str, temp); |
| mapping.originalColumn = previousOriginalColumn + temp.value; |
| previousOriginalColumn = mapping.originalColumn; |
| str = temp.rest; |
| if (str.length > 0 && !this._nextCharIsMappingSeparator(str)) { |
| base64VLQ.decode(str, temp); |
| mapping.name = this._names.at(previousName + temp.value); |
| previousName += temp.value; |
| str = temp.rest; |
| } |
| } |
| this.__generatedMappings.push(mapping); |
| if (typeof mapping.originalLine === 'number') { |
| this.__originalMappings.push(mapping); |
| } |
| } |
| } |
| this.__generatedMappings.sort(util.compareByGeneratedPositions); |
| this.__originalMappings.sort(util.compareByOriginalPositions); |
| }; |
| BasicSourceMapConsumer.prototype._findMapping = function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName, aColumnName, aComparator) { |
| if (aNeedle[aLineName] <= 0) { |
| throw new TypeError('Line must be greater than or equal to 1, got ' + aNeedle[aLineName]); |
| } |
| if (aNeedle[aColumnName] < 0) { |
| throw new TypeError('Column must be greater than or equal to 0, got ' + aNeedle[aColumnName]); |
| } |
| return binarySearch.search(aNeedle, aMappings, aComparator); |
| }; |
| BasicSourceMapConsumer.prototype.computeColumnSpans = function SourceMapConsumer_computeColumnSpans() { |
| for (var index = 0; index < this._generatedMappings.length; ++index) { |
| var mapping = this._generatedMappings[index]; |
| if (index + 1 < this._generatedMappings.length) { |
| var nextMapping = this._generatedMappings[index + 1]; |
| if (mapping.generatedLine === nextMapping.generatedLine) { |
| mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1; |
| continue; |
| } |
| } |
| mapping.lastGeneratedColumn = Infinity; |
| } |
| }; |
| BasicSourceMapConsumer.prototype.originalPositionFor = function SourceMapConsumer_originalPositionFor(aArgs) { |
| var needle = { |
| generatedLine: util.getArg(aArgs, 'line'), |
| generatedColumn: util.getArg(aArgs, 'column') |
| }; |
| var index = this._findMapping(needle, this._generatedMappings, 'generatedLine', 'generatedColumn', util.compareByGeneratedPositions); |
| if (index >= 0) { |
| var mapping = this._generatedMappings[index]; |
| if (mapping.generatedLine === needle.generatedLine) { |
| var source = util.getArg(mapping, 'source', null); |
| if (source != null && this.sourceRoot != null) { |
| source = util.join(this.sourceRoot, source); |
| } |
| return { |
| source: source, |
| line: util.getArg(mapping, 'originalLine', null), |
| column: util.getArg(mapping, 'originalColumn', null), |
| name: util.getArg(mapping, 'name', null) |
| }; |
| } |
| } |
| return { |
| source: null, |
| line: null, |
| column: null, |
| name: null |
| }; |
| }; |
| BasicSourceMapConsumer.prototype.sourceContentFor = function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) { |
| if (!this.sourcesContent) { |
| return null; |
| } |
| if (this.sourceRoot != null) { |
| aSource = util.relative(this.sourceRoot, aSource); |
| } |
| if (this._sources.has(aSource)) { |
| return this.sourcesContent[this._sources.indexOf(aSource)]; |
| } |
| var url; |
| if (this.sourceRoot != null && (url = util.urlParse(this.sourceRoot))) { |
| var fileUriAbsPath = aSource.replace(/^file:\/\//, ''); |
| if (url.scheme == 'file' && this._sources.has(fileUriAbsPath)) { |
| return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]; |
| } |
| if ((!url.path || url.path == '/') && this._sources.has('/' + aSource)) { |
| return this.sourcesContent[this._sources.indexOf('/' + aSource)]; |
| } |
| } |
| if (nullOnMissing) { |
| return null; |
| } else { |
| throw new Error('"' + aSource + '" is not in the SourceMap.'); |
| } |
| }; |
| BasicSourceMapConsumer.prototype.generatedPositionFor = function SourceMapConsumer_generatedPositionFor(aArgs) { |
| var needle = { |
| source: util.getArg(aArgs, 'source'), |
| originalLine: util.getArg(aArgs, 'line'), |
| originalColumn: util.getArg(aArgs, 'column') |
| }; |
| if (this.sourceRoot != null) { |
| needle.source = util.relative(this.sourceRoot, needle.source); |
| } |
| var index = this._findMapping(needle, this._originalMappings, 'originalLine', 'originalColumn', util.compareByOriginalPositions); |
| if (index >= 0) { |
| var mapping = this._originalMappings[index]; |
| return { |
| line: util.getArg(mapping, 'generatedLine', null), |
| column: util.getArg(mapping, 'generatedColumn', null), |
| lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null) |
| }; |
| } |
| return { |
| line: null, |
| column: null, |
| lastColumn: null |
| }; |
| }; |
| exports.BasicSourceMapConsumer = BasicSourceMapConsumer; |
| }); |
| }); |
| require.define('/node_modules/source-map/lib/source-map/binary-search.js', function (module, exports, __dirname, __filename) { |
| if (typeof define !== 'function') { |
| var define = require('/node_modules/source-map/node_modules/amdefine/amdefine.js', module)(module, require); |
| } |
| define(function (require, exports, module) { |
| function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare) { |
| var mid = Math.floor((aHigh - aLow) / 2) + aLow; |
| var cmp = aCompare(aNeedle, aHaystack[mid], true); |
| if (cmp === 0) { |
| return mid; |
| } else if (cmp > 0) { |
| if (aHigh - mid > 1) { |
| return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare); |
| } |
| return mid; |
| } else { |
| if (mid - aLow > 1) { |
| return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare); |
| } |
| return aLow < 0 ? -1 : aLow; |
| } |
| } |
| exports.search = function search(aNeedle, aHaystack, aCompare) { |
| if (aHaystack.length === 0) { |
| return -1; |
| } |
| return recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack, aCompare); |
| }; |
| }); |
| }); |
| require.define('/node_modules/source-map/lib/source-map/indexed-source-map-consumer.js', function (module, exports, __dirname, __filename) { |
| if (typeof define !== 'function') { |
| var define = require('/node_modules/source-map/node_modules/amdefine/amdefine.js', module)(module, require); |
| } |
| define(function (require, exports, module) { |
| var util = require('/node_modules/source-map/lib/source-map/util.js', module); |
| var binarySearch = require('/node_modules/source-map/lib/source-map/binary-search.js', module); |
| var SourceMapConsumer = require('/node_modules/source-map/lib/source-map/source-map-consumer.js', module).SourceMapConsumer; |
| var BasicSourceMapConsumer = require('/node_modules/source-map/lib/source-map/basic-source-map-consumer.js', module).BasicSourceMapConsumer; |
| function IndexedSourceMapConsumer(aSourceMap) { |
| var sourceMap = aSourceMap; |
| if (typeof aSourceMap === 'string') { |
| sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, '')); |
| } |
| var version = util.getArg(sourceMap, 'version'); |
| var sections = util.getArg(sourceMap, 'sections'); |
| if (version != this._version) { |
| throw new Error('Unsupported version: ' + version); |
| } |
| var lastOffset = { |
| line: -1, |
| column: 0 |
| }; |
| this._sections = sections.map(function (s) { |
| if (s.url) { |
| throw new Error('Support for url field in sections not implemented.'); |
| } |
| var offset = util.getArg(s, 'offset'); |
| var offsetLine = util.getArg(offset, 'line'); |
| var offsetColumn = util.getArg(offset, 'column'); |
| if (offsetLine < lastOffset.line || offsetLine === lastOffset.line && offsetColumn < lastOffset.column) { |
| throw new Error('Section offsets must be ordered and non-overlapping.'); |
| } |
| lastOffset = offset; |
| return { |
| generatedOffset: { |
| generatedLine: offsetLine + 1, |
| generatedColumn: offsetColumn + 1 |
| }, |
| consumer: new SourceMapConsumer(util.getArg(s, 'map')) |
| }; |
| }); |
| } |
| IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype); |
| IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer; |
| IndexedSourceMapConsumer.prototype._version = 3; |
| Object.defineProperty(IndexedSourceMapConsumer.prototype, 'sources', { |
| get: function () { |
| var sources = []; |
| for (var i = 0; i < this._sections.length; i++) { |
| for (var j = 0; j < this._sections[i].consumer.sources.length; j++) { |
| sources.push(this._sections[i].consumer.sources[j]); |
| } |
| } |
| ; |
| return sources; |
| } |
| }); |
| IndexedSourceMapConsumer.prototype.originalPositionFor = function IndexedSourceMapConsumer_originalPositionFor(aArgs) { |
| var needle = { |
| generatedLine: util.getArg(aArgs, 'line'), |
| generatedColumn: util.getArg(aArgs, 'column') |
| }; |
| var sectionIndex = binarySearch.search(needle, this._sections, function (needle, section) { |
| var cmp = needle.generatedLine - section.generatedOffset.generatedLine; |
| if (cmp) { |
| return cmp; |
| } |
| return needle.generatedColumn - section.generatedOffset.generatedColumn; |
| }); |
| var section = this._sections[sectionIndex]; |
| if (!section) { |
| return { |
| source: null, |
| line: null, |
| column: null, |
| name: null |
| }; |
| } |
| return section.consumer.originalPositionFor({ |
| line: needle.generatedLine - (section.generatedOffset.generatedLine - 1), |
| column: needle.generatedColumn - (section.generatedOffset.generatedLine === needle.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0) |
| }); |
| }; |
| IndexedSourceMapConsumer.prototype.sourceContentFor = function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) { |
| for (var i = 0; i < this._sections.length; i++) { |
| var section = this._sections[i]; |
| var content = section.consumer.sourceContentFor(aSource, true); |
| if (content) { |
| return content; |
| } |
| } |
| if (nullOnMissing) { |
| return null; |
| } else { |
| throw new Error('"' + aSource + '" is not in the SourceMap.'); |
| } |
| }; |
| IndexedSourceMapConsumer.prototype.generatedPositionFor = function IndexedSourceMapConsumer_generatedPositionFor(aArgs) { |
| for (var i = 0; i < this._sections.length; i++) { |
| var section = this._sections[i]; |
| if (section.consumer.sources.indexOf(util.getArg(aArgs, 'source')) === -1) { |
| continue; |
| } |
| var generatedPosition = section.consumer.generatedPositionFor(aArgs); |
| if (generatedPosition) { |
| var ret = { |
| line: generatedPosition.line + (section.generatedOffset.generatedLine - 1), |
| column: generatedPosition.column + (section.generatedOffset.generatedLine === generatedPosition.line ? section.generatedOffset.generatedColumn - 1 : 0) |
| }; |
| return ret; |
| } |
| } |
| return { |
| line: null, |
| column: null |
| }; |
| }; |
| IndexedSourceMapConsumer.prototype._parseMappings = function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) { |
| this.__generatedMappings = []; |
| this.__originalMappings = []; |
| for (var i = 0; i < this._sections.length; i++) { |
| var section = this._sections[i]; |
| var sectionMappings = section.consumer._generatedMappings; |
| for (var j = 0; j < sectionMappings.length; j++) { |
| var mapping = sectionMappings[i]; |
| var source = mapping.source; |
| var sourceRoot = section.consumer.sourceRoot; |
| if (source != null && sourceRoot != null) { |
| source = util.join(sourceRoot, source); |
| } |
| var adjustedMapping = { |
| source: source, |
| generatedLine: mapping.generatedLine + (section.generatedOffset.generatedLine - 1), |
| generatedColumn: mapping.column + (section.generatedOffset.generatedLine === mapping.generatedLine) ? section.generatedOffset.generatedColumn - 1 : 0, |
| originalLine: mapping.originalLine, |
| originalColumn: mapping.originalColumn, |
| name: mapping.name |
| }; |
| this.__generatedMappings.push(adjustedMapping); |
| if (typeof adjustedMapping.originalLine === 'number') { |
| this.__originalMappings.push(adjustedMapping); |
| } |
| } |
| ; |
| } |
| ; |
| this.__generatedMappings.sort(util.compareByGeneratedPositions); |
| this.__originalMappings.sort(util.compareByOriginalPositions); |
| }; |
| exports.IndexedSourceMapConsumer = IndexedSourceMapConsumer; |
| }); |
| }); |
| require.define('/node_modules/esutils/lib/utils.js', function (module, exports, __dirname, __filename) { |
| (function () { |
| 'use strict'; |
| exports.ast = require('/node_modules/esutils/lib/ast.js', module); |
| exports.code = require('/node_modules/esutils/lib/code.js', module); |
| exports.keyword = require('/node_modules/esutils/lib/keyword.js', module); |
| }()); |
| }); |
| require.define('/node_modules/esutils/lib/keyword.js', function (module, exports, __dirname, __filename) { |
| (function () { |
| 'use strict'; |
| var code = require('/node_modules/esutils/lib/code.js', module); |
| function isStrictModeReservedWordES6(id) { |
| switch (id) { |
| case 'implements': |
| case 'interface': |
| case 'package': |
| case 'private': |
| case 'protected': |
| case 'public': |
| case 'static': |
| case 'let': |
| return true; |
| default: |
| return false; |
| } |
| } |
| function isKeywordES5(id, strict) { |
| if (!strict && id === 'yield') { |
| return false; |
| } |
| return isKeywordES6(id, strict); |
| } |
| function isKeywordES6(id, strict) { |
| if (strict && isStrictModeReservedWordES6(id)) { |
| return true; |
| } |
| switch (id.length) { |
| case 2: |
| return id === 'if' || id === 'in' || id === 'do'; |
| case 3: |
| return id === 'var' || id === 'for' || id === 'new' || id === 'try'; |
| case 4: |
| return id === 'this' || id === 'else' || id === 'case' || id === 'void' || id === 'with' || id === 'enum'; |
| case 5: |
| return id === 'while' || id === 'break' || id === 'catch' || id === 'throw' || id === 'const' || id === 'yield' || id === 'class' || id === 'super'; |
| case 6: |
| return id === 'return' || id === 'typeof' || id === 'delete' || id === 'switch' || id === 'export' || id === 'import'; |
| case 7: |
| return id === 'default' || id === 'finally' || id === 'extends'; |
| case 8: |
| return id === 'function' || id === 'continue' || id === 'debugger'; |
| case 10: |
| return id === 'instanceof'; |
| default: |
| return false; |
| } |
| } |
| function isReservedWordES5(id, strict) { |
| return id === 'null' || id === 'true' || id === 'false' || isKeywordES5(id, strict); |
| } |
| function isReservedWordES6(id, strict) { |
| return id === 'null' || id === 'true' || id === 'false' || isKeywordES6(id, strict); |
| } |
| function isRestrictedWord(id) { |
| return id === 'eval' || id === 'arguments'; |
| } |
| function isIdentifierNameES5(id) { |
| var i, iz, ch; |
| if (id.length === 0) { |
| return false; |
| } |
| ch = id.charCodeAt(0); |
| if (!code.isIdentifierStartES5(ch)) { |
| return false; |
| } |
| for (i = 1, iz = id.length; i < iz; ++i) { |
| ch = id.charCodeAt(i); |
| if (!code.isIdentifierPartES5(ch)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| function decodeUtf16(lead, trail) { |
| return (lead - 55296) * 1024 + (trail - 56320) + 65536; |
| } |
| function isIdentifierNameES6(id) { |
| var i, iz, ch, lowCh, check; |
| if (id.length === 0) { |
| return false; |
| } |
| check = code.isIdentifierStartES6; |
| for (i = 0, iz = id.length; i < iz; ++i) { |
| ch = id.charCodeAt(i); |
| if (55296 <= ch && ch <= 56319) { |
| ++i; |
| if (i >= iz) { |
| return false; |
| } |
| lowCh = id.charCodeAt(i); |
| if (!(56320 <= lowCh && lowCh <= 57343)) { |
| return false; |
| } |
| ch = decodeUtf16(ch, lowCh); |
| } |
| if (!check(ch)) { |
| return false; |
| } |
| check = code.isIdentifierPartES6; |
| } |
| return true; |
| } |
| function isIdentifierES5(id, strict) { |
| return isIdentifierNameES5(id) && !isReservedWordES5(id, strict); |
| } |
| function isIdentifierES6(id, strict) { |
| return isIdentifierNameES6(id) && !isReservedWordES6(id, strict); |
| } |
| module.exports = { |
| isKeywordES5: isKeywordES5, |
| isKeywordES6: isKeywordES6, |
| isReservedWordES5: isReservedWordES5, |
| isReservedWordES6: isReservedWordES6, |
| isRestrictedWord: isRestrictedWord, |
| isIdentifierNameES5: isIdentifierNameES5, |
| isIdentifierNameES6: isIdentifierNameES6, |
| isIdentifierES5: isIdentifierES5, |
| isIdentifierES6: isIdentifierES6 |
| }; |
| }()); |
| }); |
| require.define('/node_modules/esutils/lib/code.js', function (module, exports, __dirname, __filename) { |
| (function () { |
| 'use strict'; |
| var ES6Regex, ES5Regex, NON_ASCII_WHITESPACES, IDENTIFIER_START, IDENTIFIER_PART, ch; |
| ES5Regex = { |
| NonAsciiIdentifierStart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\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-\u08B2\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\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-\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-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\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-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA7AD\uA7B0\uA7B1\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB5F\uAB64\uAB65\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]/, |
| NonAsciiIdentifierPart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B2\u08E4-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58\u0C59\u0C60-\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D60-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFC-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA69D\uA69F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA7AD\uA7B0\uA7B1\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB5F\uAB64\uAB65\uABC0-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2D\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]/ |
| }; |
| ES6Regex = { |
| NonAsciiIdentifierStart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\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-\u08B2\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\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-\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-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\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\u2118-\u211D\u2124\u2126\u2128\u212A-\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\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\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-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA7AD\uA7B0\uA7B1\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB5F\uAB64\uAB65\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]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDE00-\uDE11\uDE13-\uDE2B\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF5D-\uDF61]|\uD805[\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDE00-\uDE2F\uDE44\uDE80-\uDEAA]|\uD806[\uDCA0-\uDCDF\uDCFF\uDEC0-\uDEF8]|\uD808[\uDC00-\uDF98]|\uD809[\uDC00-\uDC6E]|[\uD80C\uD840-\uD868\uD86A-\uD86C][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDC00-\uDCC4]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D]|\uD87E[\uDC00-\uDE1D]/, |
| NonAsciiIdentifierPart: /[\xAA\xB5\xB7\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B2\u08E4-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58\u0C59\u0C60-\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D60-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1369-\u1371\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFC-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA69D\uA69F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA7AD\uA7B0\uA7B1\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB5F\uAB64\uAB65\uABC0-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2D\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDD0-\uDDDA\uDE00-\uDE11\uDE13-\uDE37\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF01-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9]|\uD806[\uDCA0-\uDCE9\uDCFF\uDEC0-\uDEF8]|\uD808[\uDC00-\uDF98]|\uD809[\uDC00-\uDC6E]|[\uD80C\uD840-\uD868\uD86A-\uD86C][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF]/ |
| }; |
| function isDecimalDigit(ch) { |
| return 48 <= ch && ch <= 57; |
| } |
| function isHexDigit(ch) { |
| return 48 <= ch && ch <= 57 || 97 <= ch && ch <= 102 || 65 <= ch && ch <= 70; |
| } |
| function isOctalDigit(ch) { |
| return ch >= 48 && ch <= 55; |
| } |
| NON_ASCII_WHITESPACES = [ |
| 5760, |
| 6158, |
| 8192, |
| 8193, |
| 8194, |
| 8195, |
| 8196, |
| 8197, |
| 8198, |
| 8199, |
| 8200, |
| 8201, |
| 8202, |
| 8239, |
| 8287, |
| 12288, |
| 65279 |
| ]; |
| function isWhiteSpace(ch) { |
| return ch === 32 || ch === 9 || ch === 11 || ch === 12 || ch === 160 || ch >= 5760 && NON_ASCII_WHITESPACES.indexOf(ch) >= 0; |
| } |
| function isLineTerminator(ch) { |
| return ch === 10 || ch === 13 || ch === 8232 || ch === 8233; |
| } |
| function fromCodePoint(cp) { |
| if (cp <= 65535) { |
| return String.fromCharCode(cp); |
| } |
| var cu1 = String.fromCharCode(Math.floor((cp - 65536) / 1024) + 55296); |
| var cu2 = String.fromCharCode((cp - 65536) % 1024 + 56320); |
| return cu1 + cu2; |
| } |
| IDENTIFIER_START = new Array(128); |
| for (ch = 0; ch < 128; ++ch) { |
| IDENTIFIER_START[ch] = ch >= 97 && ch <= 122 || ch >= 65 && ch <= 90 || ch === 36 || ch === 95; |
| } |
| IDENTIFIER_PART = new Array(128); |
| for (ch = 0; ch < 128; ++ch) { |
| IDENTIFIER_PART[ch] = ch >= 97 && ch <= 122 || ch >= 65 && ch <= 90 || ch >= 48 && ch <= 57 || ch === 36 || ch === 95; |
| } |
| function isIdentifierStartES5(ch) { |
| return ch < 128 ? IDENTIFIER_START[ch] : ES5Regex.NonAsciiIdentifierStart.test(fromCodePoint(ch)); |
| } |
| function isIdentifierPartES5(ch) { |
| return ch < 128 ? IDENTIFIER_PART[ch] : ES5Regex.NonAsciiIdentifierPart.test(fromCodePoint(ch)); |
| } |
| function isIdentifierStartES6(ch) { |
| return ch < 128 ? IDENTIFIER_START[ch] : ES6Regex.NonAsciiIdentifierStart.test(fromCodePoint(ch)); |
| } |
| function isIdentifierPartES6(ch) { |
| return ch < 128 ? IDENTIFIER_PART[ch] : ES6Regex.NonAsciiIdentifierPart.test(fromCodePoint(ch)); |
| } |
| module.exports = { |
| isDecimalDigit: isDecimalDigit, |
| isHexDigit: isHexDigit, |
| isOctalDigit: isOctalDigit, |
| isWhiteSpace: isWhiteSpace, |
| isLineTerminator: isLineTerminator, |
| isIdentifierStartES5: isIdentifierStartES5, |
| isIdentifierPartES5: isIdentifierPartES5, |
| isIdentifierStartES6: isIdentifierStartES6, |
| isIdentifierPartES6: isIdentifierPartES6 |
| }; |
| }()); |
| }); |
| require.define('/node_modules/esutils/lib/ast.js', function (module, exports, __dirname, __filename) { |
| (function () { |
| 'use strict'; |
| function isExpression(node) { |
| if (node == null) { |
| return false; |
| } |
| switch (node.type) { |
| case 'ArrayExpression': |
| case 'AssignmentExpression': |
| case 'BinaryExpression': |
| case 'CallExpression': |
| case 'ConditionalExpression': |
| case 'FunctionExpression': |
| case 'Identifier': |
| case 'Literal': |
| case 'LogicalExpression': |
| case 'MemberExpression': |
| case 'NewExpression': |
| case 'ObjectExpression': |
| case 'SequenceExpression': |
| case 'ThisExpression': |
| case 'UnaryExpression': |
| case 'UpdateExpression': |
| return true; |
| } |
| return false; |
| } |
| function isIterationStatement(node) { |
| if (node == null) { |
| return false; |
| } |
| switch (node.type) { |
| case 'DoWhileStatement': |
| case 'ForInStatement': |
| case 'ForStatement': |
| case 'WhileStatement': |
| return true; |
| } |
| return false; |
| } |
| function isStatement(node) { |
| if (node == null) { |
| return false; |
| } |
| switch (node.type) { |
| case 'BlockStatement': |
| case 'BreakStatement': |
| case 'ContinueStatement': |
| case 'DebuggerStatement': |
| case 'DoWhileStatement': |
| case 'EmptyStatement': |
| case 'ExpressionStatement': |
| case 'ForInStatement': |
| case 'ForStatement': |
| case 'IfStatement': |
| case 'LabeledStatement': |
| case 'ReturnStatement': |
| case 'SwitchStatement': |
| case 'ThrowStatement': |
| case 'TryStatement': |
| case 'VariableDeclaration': |
| case 'WhileStatement': |
| case 'WithStatement': |
| return true; |
| } |
| return false; |
| } |
| function isSourceElement(node) { |
| return isStatement(node) || node != null && node.type === 'FunctionDeclaration'; |
| } |
| function trailingStatement(node) { |
| switch (node.type) { |
| case 'IfStatement': |
| if (node.alternate != null) { |
| return node.alternate; |
| } |
| return node.consequent; |
| case 'LabeledStatement': |
| case 'ForStatement': |
| case 'ForInStatement': |
| case 'WhileStatement': |
| case 'WithStatement': |
| return node.body; |
| } |
| return null; |
| } |
| function isProblematicIfStatement(node) { |
| var current; |
| if (node.type !== 'IfStatement') { |
| return false; |
| } |
| if (node.alternate == null) { |
| return false; |
| } |
| current = node.consequent; |
| do { |
| if (current.type === 'IfStatement') { |
| if (current.alternate == null) { |
| return true; |
| } |
| } |
| current = trailingStatement(current); |
| } while (current); |
| return false; |
| } |
| module.exports = { |
| isExpression: isExpression, |
| isStatement: isStatement, |
| isIterationStatement: isIterationStatement, |
| isSourceElement: isSourceElement, |
| isProblematicIfStatement: isProblematicIfStatement, |
| trailingStatement: trailingStatement |
| }; |
| }()); |
| }); |
| require.define('/node_modules/estraverse/estraverse.js', function (module, exports, __dirname, __filename) { |
| (function (root, factory) { |
| 'use strict'; |
| if (typeof define === 'function' && define.amd) { |
| define(['exports'], factory); |
| } else if (typeof exports !== 'undefined') { |
| factory(exports); |
| } else { |
| factory(root.estraverse = {}); |
| } |
| }(this, function clone(exports) { |
| 'use strict'; |
| var Syntax, isArray, VisitorOption, VisitorKeys, objectCreate, objectKeys, BREAK, SKIP, REMOVE; |
| function ignoreJSHintError() { |
| } |
| isArray = Array.isArray; |
| if (!isArray) { |
| isArray = function isArray(array) { |
| return Object.prototype.toString.call(array) === '[object Array]'; |
| }; |
| } |
| function deepCopy(obj) { |
| var ret = {}, key, val; |
| for (key in obj) { |
| if (obj.hasOwnProperty(key)) { |
| val = obj[key]; |
| if (typeof val === 'object' && val !== null) { |
| ret[key] = deepCopy(val); |
| } else { |
| ret[key] = val; |
| } |
| } |
| } |
| return ret; |
| } |
| function shallowCopy(obj) { |
| var ret = {}, key; |
| for (key in obj) { |
| if (obj.hasOwnProperty(key)) { |
| ret[key] = obj[key]; |
| } |
| } |
| return ret; |
| } |
| ignoreJSHintError(shallowCopy); |
| function upperBound(array, func) { |
| var diff, len, i, current; |
| len = array.length; |
| i = 0; |
| while (len) { |
| diff = len >>> 1; |
| current = i + diff; |
| if (func(array[current])) { |
| len = diff; |
| } else { |
| i = current + 1; |
| len -= diff + 1; |
| } |
| } |
| return i; |
| } |
| function lowerBound(array, func) { |
| var diff, len, i, current; |
| len = array.length; |
| i = 0; |
| while (len) { |
| diff = len >>> 1; |
| current = i + diff; |
| if (func(array[current])) { |
| i = current + 1; |
| len -= diff + 1; |
| } else { |
| len = diff; |
| } |
| } |
| return i; |
| } |
| ignoreJSHintError(lowerBound); |
| objectCreate = Object.create || function () { |
| function F() { |
| } |
| return function (o) { |
| F.prototype = o; |
| return new F; |
| }; |
| }(); |
| objectKeys = Object.keys || function (o) { |
| var keys = [], key; |
| for (key in o) { |
| keys.push(key); |
| } |
| return keys; |
| }; |
| function extend(to, from) { |
| var keys = objectKeys(from), key, i, len; |
| for (i = 0, len = keys.length; i < len; i += 1) { |
| key = keys[i]; |
| to[key] = from[key]; |
| } |
| return to; |
| } |
| Syntax = { |
| AssignmentExpression: 'AssignmentExpression', |
| ArrayExpression: 'ArrayExpression', |
| ArrayPattern: 'ArrayPattern', |
| ArrowFunctionExpression: 'ArrowFunctionExpression', |
| AwaitExpression: 'AwaitExpression', |
| BlockStatement: 'BlockStatement', |
| BinaryExpression: 'BinaryExpression', |
| BreakStatement: 'BreakStatement', |
| CallExpression: 'CallExpression', |
| CatchClause: 'CatchClause', |
| ClassBody: 'ClassBody', |
| ClassDeclaration: 'ClassDeclaration', |
| ClassExpression: 'ClassExpression', |
| ComprehensionBlock: 'ComprehensionBlock', |
| ComprehensionExpression: 'ComprehensionExpression', |
| ConditionalExpression: 'ConditionalExpression', |
| ContinueStatement: 'ContinueStatement', |
| DebuggerStatement: 'DebuggerStatement', |
| DirectiveStatement: 'DirectiveStatement', |
| DoWhileStatement: 'DoWhileStatement', |
| EmptyStatement: 'EmptyStatement', |
| ExportBatchSpecifier: 'ExportBatchSpecifier', |
| ExportDeclaration: 'ExportDeclaration', |
| ExportSpecifier: 'ExportSpecifier', |
| ExpressionStatement: 'ExpressionStatement', |
| ForStatement: 'ForStatement', |
| ForInStatement: 'ForInStatement', |
| ForOfStatement: 'ForOfStatement', |
| FunctionDeclaration: 'FunctionDeclaration', |
| FunctionExpression: 'FunctionExpression', |
| GeneratorExpression: 'GeneratorExpression', |
| Identifier: 'Identifier', |
| IfStatement: 'IfStatement', |
| ImportDeclaration: 'ImportDeclaration', |
| ImportDefaultSpecifier: 'ImportDefaultSpecifier', |
| ImportNamespaceSpecifier: 'ImportNamespaceSpecifier', |
| ImportSpecifier: 'ImportSpecifier', |
| Literal: 'Literal', |
| LabeledStatement: 'LabeledStatement', |
| LogicalExpression: 'LogicalExpression', |
| MemberExpression: 'MemberExpression', |
| MethodDefinition: 'MethodDefinition', |
| ModuleSpecifier: 'ModuleSpecifier', |
| NewExpression: 'NewExpression', |
| ObjectExpression: 'ObjectExpression', |
| ObjectPattern: 'ObjectPattern', |
| Program: 'Program', |
| Property: 'Property', |
| ReturnStatement: 'ReturnStatement', |
| SequenceExpression: 'SequenceExpression', |
| SpreadElement: 'SpreadElement', |
| SwitchStatement: 'SwitchStatement', |
| SwitchCase: 'SwitchCase', |
| TaggedTemplateExpression: 'TaggedTemplateExpression', |
| TemplateElement: 'TemplateElement', |
| TemplateLiteral: 'TemplateLiteral', |
| ThisExpression: 'ThisExpression', |
| ThrowStatement: 'ThrowStatement', |
| TryStatement: 'TryStatement', |
| UnaryExpression: 'UnaryExpression', |
| UpdateExpression: 'UpdateExpression', |
| VariableDeclaration: 'VariableDeclaration', |
| VariableDeclarator: 'VariableDeclarator', |
| WhileStatement: 'WhileStatement', |
| WithStatement: 'WithStatement', |
| YieldExpression: 'YieldExpression' |
| }; |
| VisitorKeys = { |
| AssignmentExpression: [ |
| 'left', |
| 'right' |
| ], |
| ArrayExpression: ['elements'], |
| ArrayPattern: ['elements'], |
| ArrowFunctionExpression: [ |
| 'params', |
| 'defaults', |
| 'rest', |
| 'body' |
| ], |
| AwaitExpression: ['argument'], |
| BlockStatement: ['body'], |
| BinaryExpression: [ |
| 'left', |
| 'right' |
| ], |
| BreakStatement: ['label'], |
| CallExpression: [ |
| 'callee', |
| 'arguments' |
| ], |
| CatchClause: [ |
| 'param', |
| 'body' |
| ], |
| ClassBody: ['body'], |
| ClassDeclaration: [ |
| 'id', |
| 'body', |
| 'superClass' |
| ], |
| ClassExpression: [ |
| 'id', |
| 'body', |
| 'superClass' |
| ], |
| ComprehensionBlock: [ |
| 'left', |
| 'right' |
| ], |
| ComprehensionExpression: [ |
| 'blocks', |
| 'filter', |
| 'body' |
| ], |
| ConditionalExpression: [ |
| 'test', |
| 'consequent', |
| 'alternate' |
| ], |
| ContinueStatement: ['label'], |
| DebuggerStatement: [], |
| DirectiveStatement: [], |
| DoWhileStatement: [ |
| 'body', |
| 'test' |
| ], |
| EmptyStatement: [], |
| ExportBatchSpecifier: [], |
| ExportDeclaration: [ |
| 'declaration', |
| 'specifiers', |
| 'source' |
| ], |
| ExportSpecifier: [ |
| 'id', |
| 'name' |
| ], |
| ExpressionStatement: ['expression'], |
| ForStatement: [ |
| 'init', |
| 'test', |
| 'update', |
| 'body' |
| ], |
| ForInStatement: [ |
| 'left', |
| 'right', |
| 'body' |
| ], |
| ForOfStatement: [ |
| 'left', |
| 'right', |
| 'body' |
| ], |
| FunctionDeclaration: [ |
| 'id', |
| 'params', |
| 'defaults', |
| 'rest', |
| 'body' |
| ], |
| FunctionExpression: [ |
| 'id', |
| 'params', |
| 'defaults', |
| 'rest', |
| 'body' |
| ], |
| GeneratorExpression: [ |
| 'blocks', |
| 'filter', |
| 'body' |
| ], |
| Identifier: [], |
| IfStatement: [ |
| 'test', |
| 'consequent', |
| 'alternate' |
| ], |
| ImportDeclaration: [ |
| 'specifiers', |
| 'source' |
| ], |
| ImportDefaultSpecifier: ['id'], |
| ImportNamespaceSpecifier: ['id'], |
| ImportSpecifier: [ |
| 'id', |
| 'name' |
| ], |
| Literal: [], |
| LabeledStatement: [ |
| 'label', |
| 'body' |
| ], |
| LogicalExpression: [ |
| 'left', |
| 'right' |
| ], |
| MemberExpression: [ |
| 'object', |
| 'property' |
| ], |
| MethodDefinition: [ |
| 'key', |
| 'value' |
| ], |
| ModuleSpecifier: [], |
| NewExpression: [ |
| 'callee', |
| 'arguments' |
| ], |
| ObjectExpression: ['properties'], |
| ObjectPattern: ['properties'], |
| Program: ['body'], |
| Property: [ |
| 'key', |
| 'value' |
| ], |
| ReturnStatement: ['argument'], |
| SequenceExpression: ['expressions'], |
| SpreadElement: ['argument'], |
| SwitchStatement: [ |
| 'discriminant', |
| 'cases' |
| ], |
| SwitchCase: [ |
| 'test', |
| 'consequent' |
| ], |
| TaggedTemplateExpression: [ |
| 'tag', |
| 'quasi' |
| ], |
| TemplateElement: [], |
| TemplateLiteral: [ |
| 'quasis', |
| 'expressions' |
| ], |
| ThisExpression: [], |
| ThrowStatement: ['argument'], |
| TryStatement: [ |
| 'block', |
| 'handlers', |
| 'handler', |
| 'guardedHandlers', |
| 'finalizer' |
| ], |
| UnaryExpression: ['argument'], |
| UpdateExpression: ['argument'], |
| VariableDeclaration: ['declarations'], |
| VariableDeclarator: [ |
| 'id', |
| 'init' |
| ], |
| WhileStatement: [ |
| 'test', |
| 'body' |
| ], |
| WithStatement: [ |
| 'object', |
| 'body' |
| ], |
| YieldExpression: ['argument'] |
| }; |
| BREAK = {}; |
| SKIP = {}; |
| REMOVE = {}; |
| VisitorOption = { |
| Break: BREAK, |
| Skip: SKIP, |
| Remove: REMOVE |
| }; |
| function Reference(parent, key) { |
| this.parent = parent; |
| this.key = key; |
| } |
| Reference.prototype.replace = function replace(node) { |
| this.parent[this.key] = node; |
| }; |
| Reference.prototype.remove = function remove() { |
| if (isArray(this.parent)) { |
| this.parent.splice(this.key, 1); |
| return true; |
| } else { |
| this.replace(null); |
| return false; |
| } |
| }; |
| function Element(node, path, wrap, ref) { |
| this.node = node; |
| this.path = path; |
| this.wrap = wrap; |
| this.ref = ref; |
| } |
| function Controller() { |
| } |
| Controller.prototype.path = function path() { |
| var i, iz, j, jz, result, element; |
| function addToPath(result, path) { |
| if (isArray(path)) { |
| for (j = 0, jz = path.length; j < jz; ++j) { |
| result.push(path[j]); |
| } |
| } else { |
| result.push(path); |
| } |
| } |
| if (!this.__current.path) { |
| return null; |
| } |
| result = []; |
| for (i = 2, iz = this.__leavelist.length; i < iz; ++i) { |
| element = this.__leavelist[i]; |
| addToPath(result, element.path); |
| } |
| addToPath(result, this.__current.path); |
| return result; |
| }; |
| Controller.prototype.type = function () { |
| var node = this.current(); |
| return node.type || this.__current.wrap; |
| }; |
| Controller.prototype.parents = function parents() { |
| var i, iz, result; |
| result = []; |
| for (i = 1, iz = this.__leavelist.length; i < iz; ++i) { |
| result.push(this.__leavelist[i].node); |
| } |
| return result; |
| }; |
| Controller.prototype.current = function current() { |
| return this.__current.node; |
| }; |
| Controller.prototype.__execute = function __execute(callback, element) { |
| var previous, result; |
| result = undefined; |
| previous = this.__current; |
| this.__current = element; |
| this.__state = null; |
| if (callback) { |
| result = callback.call(this, element.node, this.__leavelist[this.__leavelist.length - 1].node); |
| } |
| this.__current = previous; |
| return result; |
| }; |
| Controller.prototype.notify = function notify(flag) { |
| this.__state = flag; |
| }; |
| Controller.prototype.skip = function () { |
| this.notify(SKIP); |
| }; |
| Controller.prototype['break'] = function () { |
| this.notify(BREAK); |
| }; |
| Controller.prototype.remove = function () { |
| this.notify(REMOVE); |
| }; |
| Controller.prototype.__initialize = function (root, visitor) { |
| this.visitor = visitor; |
| this.root = root; |
| this.__worklist = []; |
| this.__leavelist = []; |
| this.__current = null; |
| this.__state = null; |
| this.__fallback = visitor.fallback === 'iteration'; |
| this.__keys = VisitorKeys; |
| if (visitor.keys) { |
| this.__keys = extend(objectCreate(this.__keys), visitor.keys); |
| } |
| }; |
| function isNode(node) { |
| if (node == null) { |
| return false; |
| } |
| return typeof node === 'object' && typeof node.type === 'string'; |
| } |
| function isProperty(nodeType, key) { |
| return (nodeType === Syntax.ObjectExpression || nodeType === Syntax.ObjectPattern) && 'properties' === key; |
| } |
| Controller.prototype.traverse = function traverse(root, visitor) { |
| var worklist, leavelist, element, node, nodeType, ret, key, current, current2, candidates, candidate, sentinel; |
| this.__initialize(root, visitor); |
| sentinel = {}; |
| worklist = this.__worklist; |
| leavelist = this.__leavelist; |
| worklist.push(new Element(root, null, null, null)); |
| leavelist.push(new Element(null, null, null, null)); |
| while (worklist.length) { |
| element = worklist.pop(); |
| if (element === sentinel) { |
| element = leavelist.pop(); |
| ret = this.__execute(visitor.leave, element); |
| if (this.__state === BREAK || ret === BREAK) { |
| return; |
| } |
| continue; |
| } |
| if (element.node) { |
| ret = this.__execute(visitor.enter, element); |
| if (this.__state === BREAK || ret === BREAK) { |
| return; |
| } |
| worklist.push(sentinel); |
| leavelist.push(element); |
| if (this.__state === SKIP || ret === SKIP) { |
| continue; |
| } |
| node = element.node; |
| nodeType = element.wrap || node.type; |
| candidates = this.__keys[nodeType]; |
| if (!candidates) { |
| if (this.__fallback) { |
| candidates = objectKeys(node); |
| } else { |
| throw new Error('Unknown node type ' + nodeType + '.'); |
| } |
| } |
| current = candidates.length; |
| while ((current -= 1) >= 0) { |
| key = candidates[current]; |
| candidate = node[key]; |
| if (!candidate) { |
| continue; |
| } |
| if (isArray(candidate)) { |
| current2 = candidate.length; |
| while ((current2 -= 1) >= 0) { |
| if (!candidate[current2]) { |
| continue; |
| } |
| if (isProperty(nodeType, candidates[current])) { |
| element = new Element(candidate[current2], [ |
| key, |
| current2 |
| ], 'Property', null); |
| } else if (isNode(candidate[current2])) { |
| element = new Element(candidate[current2], [ |
| key, |
| current2 |
| ], null, null); |
| } else { |
| continue; |
| } |
| worklist.push(element); |
| } |
| } else if (isNode(candidate)) { |
| worklist.push(new Element(candidate, key, null, null)); |
| } |
| } |
| } |
| } |
| }; |
| Controller.prototype.replace = function replace(root, visitor) { |
| function removeElem(element) { |
| var i, key, nextElem, parent; |
| if (element.ref.remove()) { |
| key = element.ref.key; |
| parent = element.ref.parent; |
| i = worklist.length; |
| while (i--) { |
| nextElem = worklist[i]; |
| if (nextElem.ref && nextElem.ref.parent === parent) { |
| if (nextElem.ref.key < key) { |
| break; |
| } |
| --nextElem.ref.key; |
| } |
| } |
| } |
| } |
| var worklist, leavelist, node, nodeType, target, element, current, current2, candidates, candidate, sentinel, outer, key; |
| this.__initialize(root, visitor); |
| sentinel = {}; |
| worklist = this.__worklist; |
| leavelist = this.__leavelist; |
| outer = { root: root }; |
| element = new Element(root, null, null, new Reference(outer, 'root')); |
| worklist.push(element); |
| leavelist.push(element); |
| while (worklist.length) { |
| element = worklist.pop(); |
| if (element === sentinel) { |
| element = leavelist.pop(); |
| target = this.__execute(visitor.leave, element); |
| if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) { |
| element.ref.replace(target); |
| } |
| if (this.__state === REMOVE || target === REMOVE) { |
| removeElem(element); |
| } |
| if (this.__state === BREAK || target === BREAK) { |
| return outer.root; |
| } |
| continue; |
| } |
| target = this.__execute(visitor.enter, element); |
| if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) { |
| element.ref.replace(target); |
| element.node = target; |
| } |
| if (this.__state === REMOVE || target === REMOVE) { |
| removeElem(element); |
| element.node = null; |
| } |
| if (this.__state === BREAK || target === BREAK) { |
| return outer.root; |
| } |
| node = element.node; |
| if (!node) { |
| continue; |
| } |
| worklist.push(sentinel); |
| leavelist.push(element); |
| if (this.__state === SKIP || target === SKIP) { |
| continue; |
| } |
| nodeType = element.wrap || node.type; |
| candidates = this.__keys[nodeType]; |
| if (!candidates) { |
| if (this.__fallback) { |
| candidates = objectKeys(node); |
| } else { |
| throw new Error('Unknown node type ' + nodeType + '.'); |
| } |
| } |
| current = candidates.length; |
| while ((current -= 1) >= 0) { |
| key = candidates[current]; |
| candidate = node[key]; |
| if (!candidate) { |
| continue; |
| } |
| if (isArray(candidate)) { |
| current2 = candidate.length; |
| while ((current2 -= 1) >= 0) { |
| if (!candidate[current2]) { |
| continue; |
| } |
| if (isProperty(nodeType, candidates[current])) { |
| element = new Element(candidate[current2], [ |
| key, |
| current2 |
| ], 'Property', new Reference(candidate, current2)); |
| } else if (isNode(candidate[current2])) { |
| element = new Element(candidate[current2], [ |
| key, |
| current2 |
| ], null, new Reference(candidate, current2)); |
| } else { |
| continue; |
| } |
| worklist.push(element); |
| } |
| } else if (isNode(candidate)) { |
| worklist.push(new Element(candidate, key, null, new Reference(node, key))); |
| } |
| } |
| } |
| return outer.root; |
| }; |
| function traverse(root, visitor) { |
| var controller = new Controller; |
| return controller.traverse(root, visitor); |
| } |
| function replace(root, visitor) { |
| var controller = new Controller; |
| return controller.replace(root, visitor); |
| } |
| function extendCommentRange(comment, tokens) { |
| var target; |
| target = upperBound(tokens, function search(token) { |
| return token.range[0] > comment.range[0]; |
| }); |
| comment.extendedRange = [ |
| comment.range[0], |
| comment.range[1] |
| ]; |
| if (target !== tokens.length) { |
| comment.extendedRange[1] = tokens[target].range[0]; |
| } |
| target -= 1; |
| if (target >= 0) { |
| comment.extendedRange[0] = tokens[target].range[1]; |
| } |
| return comment; |
| } |
| function attachComments(tree, providedComments, tokens) { |
| var comments = [], comment, len, i, cursor; |
| if (!tree.range) { |
| throw new Error('attachComments needs range information'); |
| } |
| if (!tokens.length) { |
| if (providedComments.length) { |
| for (i = 0, len = providedComments.length; i < len; i += 1) { |
| comment = deepCopy(providedComments[i]); |
| comment.extendedRange = [ |
| 0, |
| tree.range[0] |
| ]; |
| comments.push(comment); |
| } |
| tree.leadingComments = comments; |
| } |
| return tree; |
| } |
| for (i = 0, len = providedComments.length; i < len; i += 1) { |
| comments.push(extendCommentRange(deepCopy(providedComments[i]), tokens)); |
| } |
| cursor = 0; |
| traverse(tree, { |
| enter: function (node) { |
| var comment; |
| while (cursor < comments.length) { |
| comment = comments[cursor]; |
| if (comment.extendedRange[1] > node.range[0]) { |
| break; |
| } |
| if (comment.extendedRange[1] === node.range[0]) { |
| if (!node.leadingComments) { |
| node.leadingComments = []; |
| } |
| node.leadingComments.push(comment); |
| comments.splice(cursor, 1); |
| } else { |
| cursor += 1; |
| } |
| } |
| if (cursor === comments.length) { |
| return VisitorOption.Break; |
| } |
| if (comments[cursor].extendedRange[0] > node.range[1]) { |
| return VisitorOption.Skip; |
| } |
| } |
| }); |
| cursor = 0; |
| traverse(tree, { |
| leave: function (node) { |
| var comment; |
| while (cursor < comments.length) { |
| comment = comments[cursor]; |
| if (node.range[1] < comment.extendedRange[0]) { |
| break; |
| } |
| if (node.range[1] === comment.extendedRange[0]) { |
| if (!node.trailingComments) { |
| node.trailingComments = []; |
| } |
| node.trailingComments.push(comment); |
| comments.splice(cursor, 1); |
| } else { |
| cursor += 1; |
| } |
| } |
| if (cursor === comments.length) { |
| return VisitorOption.Break; |
| } |
| if (comments[cursor].extendedRange[0] > node.range[1]) { |
| return VisitorOption.Skip; |
| } |
| } |
| }); |
| return tree; |
| } |
| exports.version = '1.8.1-dev'; |
| exports.Syntax = Syntax; |
| exports.traverse = traverse; |
| exports.replace = replace; |
| exports.attachComments = attachComments; |
| exports.VisitorKeys = VisitorKeys; |
| exports.VisitorOption = VisitorOption; |
| exports.Controller = Controller; |
| exports.cloneEnvironment = function () { |
| return clone({}); |
| }; |
| return exports; |
| })); |
| }); |
| require('/tools/entry-point.js'); |
| }.call(this, this)); |