pax_global_header00006660000000000000000000000064130257675530014527gustar00rootroot0000000000000052 comment=e7001cad79b4b0d7c4a6cf569ea33bfc808183cd acorn-4.0.4/000077500000000000000000000000001302576755300126365ustar00rootroot00000000000000acorn-4.0.4/.editorconfig000066400000000000000000000001431302576755300153110ustar00rootroot00000000000000root = true [*] indent_style = space indent_size = 2 end_of_line = lf insert_final_newline = true acorn-4.0.4/.gitattributes000066400000000000000000000000161302576755300155260ustar00rootroot00000000000000* text eol=lf acorn-4.0.4/.gitignore000066400000000000000000000000621302576755300146240ustar00rootroot00000000000000/node_modules /.tern-port /local /bin/acorn /dist acorn-4.0.4/.npmignore000066400000000000000000000002211302576755300146300ustar00rootroot00000000000000/.tern-port /test /local /rollup /bin/generate-identifier-regex.js /bin/update_authors.sh .editorconfig .gitattributes .tern-project .travis.yml acorn-4.0.4/.tern-project000066400000000000000000000000771302576755300152570ustar00rootroot00000000000000{ "plugins": { "node": true, "es_modules": true } }acorn-4.0.4/.travis.yml000066400000000000000000000001121302576755300147410ustar00rootroot00000000000000language: node_js sudo: false node_js: - '0.12' - '4' - '5' - '6' acorn-4.0.4/AUTHORS000066400000000000000000000015351302576755300137120ustar00rootroot00000000000000List of Acorn contributors. Updated before every release. Adrian Rakovsky Alistair Braidwood Amila Welihinda Andres Suarez Angelo Aparajita Fishman Arian Stolwijk Artem Govorov Brandon Mills Charles Hughes Conrad Irwin Daniel Tschinder David Bonnet Domenico Matteo Forbes Lindesay Gilad Peleg impinball Ingvar Stepanyan Jackson Ray Hamilton Jesse McCarthy Jiaxing Wang Joel Kemp Johannes Herr Jordan Klassen Jürg Lehni Kai Cataldo keeyipchan Keheliya Gallaba Kevin Irish Kevin Kwok krator Marijn Haverbeke Martin Carlberg Mat Garcia Mathias Bynens Mathieu 'p01' Henri Matthew Bastien Max Schaefer Max Zerzouri Mihai Bazon Mike Rennie Nicholas C. Zakas Nick Fitzgerald Olivier Thomann Oskar Schöldström Paul Harper Peter Rust PlNG Prayag Verma ReadmeCritic r-e-d Richard Gibson Rich Harris Sebastian McKenzie Simen Bekkhus Timothy Gu Toru Nagashima zsjforcn acorn-4.0.4/CHANGELOG.md000066400000000000000000000113261302576755300144520ustar00rootroot00000000000000## 4.0.4 (2016-12-19) ### Bug fixes Fix issue with loading acorn_loose.js with an AMD loader. Fix crash when `export` was followed by a keyword that can't be exported. ## 4.0.3 (2016-08-16) ### Bug fixes Allow regular function declarations inside single-statement `if` branches in loose mode. Forbid them entirely in strict mode. Properly parse properties named `async` in ES2017 mode. Fix bug where reserved words were broken in ES2017 mode. ## 4.0.2 (2016-08-11) ### Bug fixes Don't ignore period or 'e' characters after octal numbers. Fix broken parsing for call expressions in default parameter values of arrow functions. ## 4.0.1 (2016-08-08) ### Bug fixes Fix false positives in duplicated export name errors. ## 4.0.0 (2016-08-07) ### Breaking changes The default `ecmaVersion` option value is now 7. A number of internal method signatures changed, so plugins might need to be updated. ### Bug fixes The parser now raises errors on duplicated export names. `arguments` and `eval` can now be used in shorthand properties. Duplicate parameter names in non-simple argument lists now always produce an error. ### New features The `ecmaVersion` option now also accepts year-style version numbers (2015, etc). Support for `async`/`await` syntax when `ecmaVersion` is >= 8. Support for trailing commas in call expressions when `ecmaVersion` is >= 8. ## 3.3.0 (2016-07-25) ### Bug fixes Fix bug in tokenizing of regexp operator after a function declaration. Fix parser crash when parsing an array pattern with a hole. ### New features Implement check against complex argument lists in functions that enable strict mode in ES7. ## 3.2.0 (2016-06-07) ### Bug fixes Improve handling of lack of unicode regexp support in host environment. Properly reject shorthand properties whose name is a keyword. Don't crash when the loose parser is called without options object. ### New features Visitors created with `visit.make` now have their base as _prototype_, rather than copying properties into a fresh object. Make it possible to use `visit.ancestor` with a walk state. ## 3.1.0 (2016-04-18) ### Bug fixes Fix issue where the loose parser created invalid TemplateElement nodes for unclosed template literals. Properly tokenize the division operator directly after a function expression. Allow trailing comma in destructuring arrays. ### New features The walker now allows defining handlers for `CatchClause` nodes. ## 3.0.4 (2016-02-25) ### Fixes Allow update expressions as left-hand-side of the ES7 exponential operator. ## 3.0.2 (2016-02-10) ### Fixes Fix bug that accidentally made `undefined` a reserved word when parsing ES7. ## 3.0.0 (2016-02-10) ### Breaking changes The default value of the `ecmaVersion` option is now 6 (used to be 5). Support for comprehension syntax (which was dropped from the draft spec) has been removed. ### Fixes `let` and `yield` are now “contextual keywords”, meaning you can mostly use them as identifiers in ES5 non-strict code. A parenthesized class or function expression after `export default` is now parsed correctly. ### New features When `ecmaVersion` is set to 7, Acorn will parse the exponentiation operator (`**`). The identifier character ranges are now based on Unicode 8.0.0. Plugins can now override the `raiseRecoverable` method to override the way non-critical errors are handled. ## 2.7.0 (2016-01-04) ### Fixes Stop allowing rest parameters in setters. Make sure the loose parser always attaches a `local` property to `ImportNamespaceSpecifier` nodes. Disallow `y` rexexp flag in ES5. Disallow `\00` and `\000` escapes in strict mode. Raise an error when an import name is a reserved word. ## 2.6.4 (2015-11-12) ### Fixes Fix crash in loose parser when parsing invalid object pattern. ### New features Support plugins in the loose parser. ## 2.6.2 (2015-11-10) ### Fixes Don't crash when no options object is passed. ## 2.6.0 (2015-11-09) ### Fixes Add `await` as a reserved word in module sources. Disallow `yield` in a parameter default value for a generator. Forbid using a comma after a rest pattern in an array destructuring. ### New features Support parsing stdin in command-line tool. ## 2.5.2 (2015-10-27) ### Fixes Fix bug where the walker walked an exported `let` statement as an expression. ## 2.5.0 (2015-10-27) ### Fixes Fix tokenizer support in the command-line tool. In the loose parser, don't allow non-string-literals as import sources. Stop allowing `new.target` outside of functions. Remove legacy `guard` and `guardedHandler` properties from try nodes. Stop allowing multiple `__proto__` properties on an object literal in strict mode. Don't allow rest parameters to be non-identifier patterns. Check for duplicate paramter names in arrow functions. acorn-4.0.4/LICENSE000066400000000000000000000020761302576755300136500ustar00rootroot00000000000000Copyright (C) 2012-2016 by various contributors (see AUTHORS) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. acorn-4.0.4/README.md000066400000000000000000000405221302576755300141200ustar00rootroot00000000000000# Acorn [![Build Status](https://travis-ci.org/ternjs/acorn.svg?branch=master)](https://travis-ci.org/ternjs/acorn) [![NPM version](https://img.shields.io/npm/v/acorn.svg)](https://www.npmjs.com/package/acorn) [Author funding status: ![maintainer happiness](https://marijnhaverbeke.nl/fund/status_s.png?force)](https://marijnhaverbeke.nl/fund/) A tiny, fast JavaScript parser, written completely in JavaScript. ## Community Acorn is open source software released under an [MIT license](https://github.com/ternjs/acorn/blob/master/LICENSE). You are welcome to [report bugs](https://github.com/ternjs/acorn/issues) or create pull requests on [github](https://github.com/ternjs/acorn). For questions and discussion, please use the [Tern discussion forum](https://discuss.ternjs.net). ## Installation The easiest way to install acorn is with [`npm`][npm]. [npm]: https://www.npmjs.com/ ```sh npm install acorn ``` Alternately, download the source. ```sh git clone https://github.com/ternjs/acorn.git ``` ## Components When run in a CommonJS (node.js) or AMD environment, exported values appear in the interfaces exposed by the individual files, as usual. When loaded in the browser (Acorn works in any JS-enabled browser more recent than IE5) without any kind of module management, a single global object `acorn` will be defined, and all the exported properties will be added to that. ### Main parser This is implemented in `dist/acorn.js`, and is what you get when you `require("acorn")` in node.js. **parse**`(input, options)` is used to parse a JavaScript program. The `input` parameter is a string, `options` can be undefined or an object setting some of the options listed below. The return value will be an abstract syntax tree object as specified by the [ESTree spec][estree]. When encountering a syntax error, the parser will raise a `SyntaxError` object with a meaningful message. The error object will have a `pos` property that indicates the character offset at which the error occurred, and a `loc` object that contains a `{line, column}` object referring to that same position. [estree]: https://github.com/estree/estree - **ecmaVersion**: Indicates the ECMAScript version to parse. Must be either 3, 5, 6 (2015), 7 (2016), or 8 (2017). This influences support for strict mode, the set of reserved words, and support for new syntax features. Default is 7. **NOTE**: Only 'stage 4' (finalized) ECMAScript features are being implemented by Acorn. - **sourceType**: Indicate the mode the code should be parsed in. Can be either `"script"` or `"module"`. This influences global strict mode and parsing of `import` and `export` declarations. - **onInsertedSemicolon**: If given a callback, that callback will be called whenever a missing semicolon is inserted by the parser. The callback will be given the character offset of the point where the semicolon is inserted as argument, and if `locations` is on, also a `{line, column}` object representing this position. - **onTrailingComma**: Like `onInsertedSemicolon`, but for trailing commas. - **allowReserved**: If `false`, using a reserved word will generate an error. Defaults to `true` for `ecmaVersion` 3, `false` for higher versions. When given the value `"never"`, reserved words and keywords can also not be used as property names (as in Internet Explorer's old parser). - **allowReturnOutsideFunction**: By default, a return statement at the top level raises an error. Set this to `true` to accept such code. - **allowImportExportEverywhere**: By default, `import` and `export` declarations can only appear at a program's top level. Setting this option to `true` allows them anywhere where a statement is allowed. - **allowHashBang**: When this is enabled (off by default), if the code starts with the characters `#!` (as in a shellscript), the first line will be treated as a comment. - **locations**: When `true`, each node has a `loc` object attached with `start` and `end` subobjects, each of which contains the one-based line and zero-based column numbers in `{line, column}` form. Default is `false`. - **onToken**: If a function is passed for this option, each found token will be passed in same format as tokens returned from `tokenizer().getToken()`. If array is passed, each found token is pushed to it. Note that you are not allowed to call the parser from the callback—that will corrupt its internal state. - **onComment**: If a function is passed for this option, whenever a comment is encountered the function will be called with the following parameters: - `block`: `true` if the comment is a block comment, false if it is a line comment. - `text`: The content of the comment. - `start`: Character offset of the start of the comment. - `end`: Character offset of the end of the comment. When the `locations` options is on, the `{line, column}` locations of the comment’s start and end are passed as two additional parameters. If array is passed for this option, each found comment is pushed to it as object in Esprima format: ```javascript { "type": "Line" | "Block", "value": "comment text", "start": Number, "end": Number, // If `locations` option is on: "loc": { "start": {line: Number, column: Number} "end": {line: Number, column: Number} }, // If `ranges` option is on: "range": [Number, Number] } ``` Note that you are not allowed to call the parser from the callback—that will corrupt its internal state. - **ranges**: Nodes have their start and end characters offsets recorded in `start` and `end` properties (directly on the node, rather than the `loc` object, which holds line/column data. To also add a [semi-standardized][range] `range` property holding a `[start, end]` array with the same numbers, set the `ranges` option to `true`. - **program**: It is possible to parse multiple files into a single AST by passing the tree produced by parsing the first file as the `program` option in subsequent parses. This will add the toplevel forms of the parsed file to the "Program" (top) node of an existing parse tree. - **sourceFile**: When the `locations` option is `true`, you can pass this option to add a `source` attribute in every node’s `loc` object. Note that the contents of this option are not examined or processed in any way; you are free to use whatever format you choose. - **directSourceFile**: Like `sourceFile`, but a `sourceFile` property will be added (regardless of the `location` option) directly to the nodes, rather than the `loc` object. - **preserveParens**: If this option is `true`, parenthesized expressions are represented by (non-standard) `ParenthesizedExpression` nodes that have a single `expression` property containing the expression inside parentheses. [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678 **parseExpressionAt**`(input, offset, options)` will parse a single expression in a string, and return its AST. It will not complain if there is more of the string left after the expression. **getLineInfo**`(input, offset)` can be used to get a `{line, column}` object for a given program string and character offset. **tokenizer**`(input, options)` returns an object with a `getToken` method that can be called repeatedly to get the next token, a `{start, end, type, value}` object (with added `loc` property when the `locations` option is enabled and `range` property when the `ranges` option is enabled). When the token's type is `tokTypes.eof`, you should stop calling the method, since it will keep returning that same token forever. In ES6 environment, returned result can be used as any other protocol-compliant iterable: ```javascript for (let token of acorn.tokenizer(str)) { // iterate over the tokens } // transform code to array of tokens: var tokens = [...acorn.tokenizer(str)]; ``` **tokTypes** holds an object mapping names to the token type objects that end up in the `type` properties of tokens. #### Note on using with [Escodegen][escodegen] Escodegen supports generating comments from AST, attached in Esprima-specific format. In order to simulate same format in Acorn, consider following example: ```javascript var comments = [], tokens = []; var ast = acorn.parse('var x = 42; // answer', { // collect ranges for each node ranges: true, // collect comments in Esprima's format onComment: comments, // collect token ranges onToken: tokens }); // attach comments using collected information escodegen.attachComments(ast, comments, tokens); // generate code console.log(escodegen.generate(ast, {comment: true})); // > 'var x = 42; // answer' ``` [escodegen]: https://github.com/estools/escodegen ### dist/acorn_loose.js ### This file implements an error-tolerant parser. It exposes a single function. The loose parser is accessible in node.js via `require("acorn/dist/acorn_loose")`. **parse_dammit**`(input, options)` takes the same arguments and returns the same syntax tree as the `parse` function in `acorn.js`, but never raises an error, and will do its best to parse syntactically invalid code in as meaningful a way as it can. It'll insert identifier nodes with name `"✖"` as placeholders in places where it can't make sense of the input. Depends on `acorn.js`, because it uses the same tokenizer. ### dist/walk.js ### Implements an abstract syntax tree walker. Will store its interface in `acorn.walk` when loaded without a module system. **simple**`(node, visitors, base, state)` does a 'simple' walk over a tree. `node` should be the AST node to walk, and `visitors` an object with properties whose names correspond to node types in the [ESTree spec][estree]. The properties should contain functions that will be called with the node object and, if applicable the state at that point. The last two arguments are optional. `base` is a walker algorithm, and `state` is a start state. The default walker will simply visit all statements and expressions and not produce a meaningful state. (An example of a use of state is to track scope at each point in the tree.) **ancestor**`(node, visitors, base, state)` does a 'simple' walk over a tree, building up an array of ancestor nodes (including the current node) and passing the array to the callbacks as a third parameter. **recursive**`(node, state, functions, base)` does a 'recursive' walk, where the walker functions are responsible for continuing the walk on the child nodes of their target node. `state` is the start state, and `functions` should contain an object that maps node types to walker functions. Such functions are called with `(node, state, c)` arguments, and can cause the walk to continue on a sub-node by calling the `c` argument on it with `(node, state)` arguments. The optional `base` argument provides the fallback walker functions for node types that aren't handled in the `functions` object. If not given, the default walkers will be used. **make**`(functions, base)` builds a new walker object by using the walker functions in `functions` and filling in the missing ones by taking defaults from `base`. **findNodeAt**`(node, start, end, test, base, state)` tries to locate a node in a tree at the given start and/or end offsets, which satisfies the predicate `test`. `start` and `end` can be either `null` (as wildcard) or a number. `test` may be a string (indicating a node type) or a function that takes `(nodeType, node)` arguments and returns a boolean indicating whether this node is interesting. `base` and `state` are optional, and can be used to specify a custom walker. Nodes are tested from inner to outer, so if two nodes match the boundaries, the inner one will be preferred. **findNodeAround**`(node, pos, test, base, state)` is a lot like `findNodeAt`, but will match any node that exists 'around' (spanning) the given position. **findNodeAfter**`(node, pos, test, base, state)` is similar to `findNodeAround`, but will match all nodes *after* the given position (testing outer nodes before inner nodes). ## Command line interface The `bin/acorn` utility can be used to parse a file from the command line. It accepts as arguments its input file and the following options: - `--ecma3|--ecma5|--ecma6|--ecma7`: Sets the ECMAScript version to parse. Default is version 5. - `--module`: Sets the parsing mode to `"module"`. Is set to `"script"` otherwise. - `--locations`: Attaches a "loc" object to each node with "start" and "end" subobjects, each of which contains the one-based line and zero-based column numbers in `{line, column}` form. - `--allow-hash-bang`: If the code starts with the characters #! (as in a shellscript), the first line will be treated as a comment. - `--compact`: No whitespace is used in the AST output. - `--silent`: Do not output the AST, just return the exit status. - `--help`: Print the usage information and quit. The utility spits out the syntax tree as JSON data. ## Build system Acorn is written in ECMAScript 6, as a set of small modules, in the project's `src` directory, and compiled down to bigger ECMAScript 3 files in `dist` using [Browserify](http://browserify.org) and [Babel](http://babeljs.io/). If you are already using Babel, you can consider including the modules directly. The command-line test runner (`npm test`) uses the ES6 modules. The browser-based test page (`test/index.html`) uses the compiled modules. The `bin/build-acorn.js` script builds the latter from the former. If you are working on Acorn, you'll probably want to try the code out directly, without an intermediate build step. In your scripts, you can register the Babel require shim like this: require("babel-core/register") That will allow you to directly `require` the ES6 modules. ## Plugins Acorn is designed support allow plugins which, within reasonable bounds, redefine the way the parser works. Plugins can add new token types and new tokenizer contexts (if necessary), and extend methods in the parser object. This is not a clean, elegant API—using it requires an understanding of Acorn's internals, and plugins are likely to break whenever those internals are significantly changed. But still, it is _possible_, in this way, to create parsers for JavaScript dialects without forking all of Acorn. And in principle it is even possible to combine such plugins, so that if you have, for example, a plugin for parsing types and a plugin for parsing JSX-style XML literals, you could load them both and parse code with both JSX tags and types. A plugin should register itself by adding a property to `acorn.plugins`, which holds a function. Calling `acorn.parse`, a `plugins` option can be passed, holding an object mapping plugin names to configuration values (or just `true` for plugins that don't take options). After the parser object has been created, the initialization functions for the chosen plugins are called with `(parser, configValue)` arguments. They are expected to use the `parser.extend` method to extend parser methods. For example, the `readToken` method could be extended like this: ```javascript parser.extend("readToken", function(nextMethod) { return function(code) { console.log("Reading a token!") return nextMethod.call(this, code) } }) ``` The `nextMethod` argument passed to `extend`'s second argument is the previous value of this method, and should usually be called through to whenever the extended method does not handle the call itself. Similarly, the loose parser allows plugins to register themselves via `acorn.pluginsLoose`. The extension mechanism is the same as for the normal parser: ```javascript looseParser.extend("readToken", function(nextMethod) { return function() { console.log("Reading a token in the loose parser!") return nextMethod.call(this) } }) ``` ### Existing plugins - [`acorn-jsx`](https://github.com/RReverser/acorn-jsx): Parse [Facebook JSX syntax extensions](https://github.com/facebook/jsx) - [`acorn-es7-plugin`](https://github.com/MatAtBread/acorn-es7-plugin/): Parse [async/await syntax proposal](https://github.com/tc39/ecmascript-asyncawait) - [`acorn-object-spread`](https://github.com/UXtemple/acorn-object-spread): Parse [object spread syntax proposal](https://github.com/sebmarkbage/ecmascript-rest-spread) - [`acorn-es7`](https://www.npmjs.com/package/acorn-es7): Parse [decorator syntax proposal](https://github.com/wycats/javascript-decorators) - [`acorn-objj`](https://www.npmjs.com/package/acorn-objj): [Objective-J](http://www.cappuccino-project.org/learn/objective-j.html) language parser built as Acorn plugin acorn-4.0.4/bin/000077500000000000000000000000001302576755300134065ustar00rootroot00000000000000acorn-4.0.4/bin/generate-identifier-regex.js000066400000000000000000000033111302576755300207640ustar00rootroot00000000000000'use strict'; // Which Unicode version should be used? var version = '9.0.0'; var start = require('unicode-' + version + '/Binary_Property/ID_Start/code-points.js') .filter(function(ch) { return ch > 0x7f; }); var last = -1; var cont = [0x200c, 0x200d].concat(require('unicode-' + version + '/Binary_Property/ID_Continue/code-points.js') .filter(function(ch) { return ch > 0x7f && search(start, ch, last + 1) == -1; })); function search(arr, ch, starting) { for (var i = starting; arr[i] <= ch && i < arr.length; last = i++) if (arr[i] === ch) return i; return -1; } function pad(str, width) { while (str.length < width) str = "0" + str; return str; } function esc(code) { var hex = code.toString(16); if (hex.length <= 2) return "\\x" + pad(hex, 2); else return "\\u" + pad(hex, 4); } function generate(chars) { var astral = [], re = ""; for (var i = 0, at = 0x10000; i < chars.length; i++) { var from = chars[i], to = from; while (i < chars.length - 1 && chars[i + 1] == to + 1) { i++; to++; } if (to <= 0xffff) { if (from == to) re += esc(from); else if (from + 1 == to) re += esc(from) + esc(to); else re += esc(from) + "-" + esc(to); } else { astral.push(from - at, to - from); at = to; } } return {nonASCII: re, astral: astral}; } var startData = generate(start), contData = generate(cont); console.log("let nonASCIIidentifierStartChars = \"" + startData.nonASCII + "\""); console.log("let nonASCIIidentifierChars = \"" + contData.nonASCII + "\""); console.log("const astralIdentifierStartCodes = " + JSON.stringify(startData.astral)); console.log("const astralIdentifierCodes = " + JSON.stringify(contData.astral)); acorn-4.0.4/bin/update_authors.sh000077500000000000000000000005421302576755300167750ustar00rootroot00000000000000# Combine existing list of authors with everyone known in git, sort, add header. tail --lines=+3 AUTHORS > AUTHORS.tmp git log --format='%aN' | grep -v abraidwood | grep -v Rich-Harris | grep -v ForbesLindesay >> AUTHORS.tmp echo -e "List of Acorn contributors. Updated before every release.\n" > AUTHORS sort -u AUTHORS.tmp >> AUTHORS rm -f AUTHORS.tmp acorn-4.0.4/dist/000077500000000000000000000000001302576755300136015ustar00rootroot00000000000000acorn-4.0.4/dist/.keep000066400000000000000000000000001302576755300145140ustar00rootroot00000000000000acorn-4.0.4/dist/acorn_csp.js000077700000000000000000000000001302576755300175412acorn.jsustar00rootroot00000000000000acorn-4.0.4/package.json000066400000000000000000000022641302576755300151300ustar00rootroot00000000000000{ "name": "acorn", "description": "ECMAScript parser", "homepage": "https://github.com/ternjs/acorn", "main": "dist/acorn.js", "jsnext:main": "dist/acorn.es.js", "version": "4.0.4", "engines": { "node": ">=0.4.0" }, "maintainers": [ { "name": "Marijn Haverbeke", "email": "marijnh@gmail.com", "web": "http://marijnhaverbeke.nl" }, { "name": "Ingvar Stepanyan", "email": "me@rreverser.com", "web": "http://rreverser.com/" } ], "repository": { "type": "git", "url": "https://github.com/ternjs/acorn.git" }, "license": "MIT", "scripts": { "prepublish": "npm test", "test": "node test/run.js", "pretest": "npm run build", "build": "npm run build:main && npm run build:walk && npm run build:loose && npm run build:bin", "build:main": "rollup -c rollup/config.main.js", "build:walk": "rollup -c rollup/config.walk.js", "build:loose": "rollup -c rollup/config.loose.js", "build:bin": "rollup -c rollup/config.bin.js" }, "bin": { "acorn": "./bin/acorn" }, "devDependencies": { "rollup": "^0.34.1", "rollup-plugin-buble": "^0.11.0", "unicode-9.0.0": "^0.7.0" } } acorn-4.0.4/rollup/000077500000000000000000000000001302576755300141535ustar00rootroot00000000000000acorn-4.0.4/rollup/config.bin.js000066400000000000000000000004221302576755300165230ustar00rootroot00000000000000import buble from 'rollup-plugin-buble' export default { entry: 'src/bin/acorn.js', dest: 'bin/acorn', format: 'cjs', banner: '#!/usr/bin/env node', external: [ 'fs', 'path', 'acorn' ], paths: { acorn: '../dist/acorn.js' }, plugins: [ buble() ] } acorn-4.0.4/rollup/config.loose.js000066400000000000000000000007341302576755300171020ustar00rootroot00000000000000import buble from 'rollup-plugin-buble' import {resolve} from 'path' var acorn = resolve('src/index.js') var paths = {}, globals = {} paths[acorn] = './acorn' globals[acorn] = 'acorn' export default { entry: 'src/loose/index.js', moduleName: 'acorn.loose', external: [ acorn ], paths: paths, globals: globals, targets: [ { dest: 'dist/acorn_loose.js', format: 'umd' }, { dest: 'dist/acorn_loose.es.js', format: 'es' } ], plugins: [ buble() ] } acorn-4.0.4/rollup/config.main.js000066400000000000000000000003531302576755300167020ustar00rootroot00000000000000import buble from 'rollup-plugin-buble'; export default { entry: 'src/index.js', moduleName: 'acorn', plugins: [ buble() ], targets: [ { dest: 'dist/acorn.js', format: 'umd' }, { dest: 'dist/acorn.es.js', format: 'es' } ] }; acorn-4.0.4/rollup/config.walk.js000066400000000000000000000003631302576755300167150ustar00rootroot00000000000000import buble from 'rollup-plugin-buble'; export default { entry: 'src/walk/index.js', moduleName: 'acorn.walk', plugins: [ buble() ], targets: [ { dest: 'dist/walk.js', format: 'umd' }, { dest: 'dist/walk.es.js', format: 'es' } ] }; acorn-4.0.4/src/000077500000000000000000000000001302576755300134255ustar00rootroot00000000000000acorn-4.0.4/src/bin/000077500000000000000000000000001302576755300141755ustar00rootroot00000000000000acorn-4.0.4/src/bin/acorn.js000066400000000000000000000037741302576755300156500ustar00rootroot00000000000000import {basename} from "path" import {readFileSync as readFile} from "fs" import * as acorn from "acorn" let infile, forceFile, silent = false, compact = false, tokenize = false const options = {} function help(status) { const print = (status == 0) ? console.log : console.error print("usage: " + basename(process.argv[1]) + " [--ecma3|--ecma5|--ecma6|--ecma7|...|--ecma2015|--ecma2016|...]") print(" [--tokenize] [--locations] [---allow-hash-bang] [--compact] [--silent] [--module] [--help] [--] [infile]") process.exit(status) } for (let i = 2; i < process.argv.length; ++i) { const arg = process.argv[i] if ((arg == "-" || arg[0] != "-") && !infile) infile = arg else if (arg == "--" && !infile && i + 2 == process.argv.length) forceFile = infile = process.argv[++i] else if (arg == "--locations") options.locations = true else if (arg == "--allow-hash-bang") options.allowHashBang = true else if (arg == "--silent") silent = true else if (arg == "--compact") compact = true else if (arg == "--help") help(0) else if (arg == "--tokenize") tokenize = true else if (arg == "--module") options.sourceType = 'module' else { let match = arg.match(/^--ecma(\d+)$/) if (match) options.ecmaVersion = +match[1] else help(1) } } function run(code) { let result if (!tokenize) { try { result = acorn.parse(code, options) } catch(e) { console.error(e.message); process.exit(1) } } else { result = [] let tokenizer = acorn.tokenizer(code, options), token while (true) { try { token = tokenizer.getToken() } catch(e) { console.error(e.message); process.exit(1) } result.push(token) if (token.type == acorn.tokTypes.eof) break } } if (!silent) console.log(JSON.stringify(result, null, compact ? null : 2)) } if (forceFile || infile && infile != "-") { run(readFile(infile, "utf8")) } else { let code = "" process.stdin.resume() process.stdin.on("data", chunk => code += chunk) process.stdin.on("end", () => run(code)) } acorn-4.0.4/src/expression.js000066400000000000000000000716111302576755300161700ustar00rootroot00000000000000// A recursive descent parser operates by defining functions for all // syntactic elements, and recursively calling those, each function // advancing the input stream and returning an AST node. Precedence // of constructs (for example, the fact that `!x[1]` means `!(x[1])` // instead of `(!x)[1]` is handled by the fact that the parser // function that parses unary prefix operators is called first, and // in turn calls the function that parses `[]` subscripts — that // way, it'll receive the node for `x[1]` already parsed, and wraps // *that* in the unary operator node. // // Acorn uses an [operator precedence parser][opp] to handle binary // operator precedence, because it is much more compact than using // the technique outlined above, which uses different, nesting // functions to specify precedence, for all of the ten binary // precedence levels that JavaScript defines. // // [opp]: http://en.wikipedia.org/wiki/Operator-precedence_parser import {types as tt} from "./tokentype" import {Parser} from "./state" import {DestructuringErrors} from "./parseutil" const pp = Parser.prototype // Check if property name clashes with already added. // Object/class getters and setters are not allowed to clash — // either with each other or with an init property — and in // strict mode, init properties are also not allowed to be repeated. pp.checkPropClash = function(prop, propHash) { if (this.options.ecmaVersion >= 6 && (prop.computed || prop.method || prop.shorthand)) return let {key} = prop, name switch (key.type) { case "Identifier": name = key.name; break case "Literal": name = String(key.value); break default: return } let {kind} = prop if (this.options.ecmaVersion >= 6) { if (name === "__proto__" && kind === "init") { if (propHash.proto) this.raiseRecoverable(key.start, "Redefinition of __proto__ property") propHash.proto = true } return } name = "$" + name let other = propHash[name] if (other) { let isGetSet = kind !== "init" if ((this.strict || isGetSet) && other[kind] || !(isGetSet ^ other.init)) this.raiseRecoverable(key.start, "Redefinition of property") } else { other = propHash[name] = { init: false, get: false, set: false } } other[kind] = true } // ### Expression parsing // These nest, from the most general expression type at the top to // 'atomic', nondivisible expression types at the bottom. Most of // the functions will simply let the function(s) below them parse, // and, *if* the syntactic construct they handle is present, wrap // the AST node that the inner parser gave them in another node. // Parse a full expression. The optional arguments are used to // forbid the `in` operator (in for loops initalization expressions) // and provide reference for storing '=' operator inside shorthand // property assignment in contexts where both object expression // and object pattern might appear (so it's possible to raise // delayed syntax error at correct position). pp.parseExpression = function(noIn, refDestructuringErrors) { let startPos = this.start, startLoc = this.startLoc let expr = this.parseMaybeAssign(noIn, refDestructuringErrors) if (this.type === tt.comma) { let node = this.startNodeAt(startPos, startLoc) node.expressions = [expr] while (this.eat(tt.comma)) node.expressions.push(this.parseMaybeAssign(noIn, refDestructuringErrors)) return this.finishNode(node, "SequenceExpression") } return expr } // Parse an assignment expression. This includes applications of // operators like `+=`. pp.parseMaybeAssign = function(noIn, refDestructuringErrors, afterLeftParse) { if (this.inGenerator && this.isContextual("yield")) return this.parseYield() let ownDestructuringErrors = false if (!refDestructuringErrors) { refDestructuringErrors = new DestructuringErrors ownDestructuringErrors = true } let startPos = this.start, startLoc = this.startLoc if (this.type == tt.parenL || this.type == tt.name) this.potentialArrowAt = this.start let left = this.parseMaybeConditional(noIn, refDestructuringErrors) if (afterLeftParse) left = afterLeftParse.call(this, left, startPos, startLoc) if (this.type.isAssign) { this.checkPatternErrors(refDestructuringErrors, true) if (!ownDestructuringErrors) DestructuringErrors.call(refDestructuringErrors) let node = this.startNodeAt(startPos, startLoc) node.operator = this.value node.left = this.type === tt.eq ? this.toAssignable(left) : left refDestructuringErrors.shorthandAssign = 0 // reset because shorthand default was used correctly this.checkLVal(left) this.next() node.right = this.parseMaybeAssign(noIn) return this.finishNode(node, "AssignmentExpression") } else { if (ownDestructuringErrors) this.checkExpressionErrors(refDestructuringErrors, true) } return left } // Parse a ternary conditional (`?:`) operator. pp.parseMaybeConditional = function(noIn, refDestructuringErrors) { let startPos = this.start, startLoc = this.startLoc let expr = this.parseExprOps(noIn, refDestructuringErrors) if (this.checkExpressionErrors(refDestructuringErrors)) return expr if (this.eat(tt.question)) { let node = this.startNodeAt(startPos, startLoc) node.test = expr node.consequent = this.parseMaybeAssign() this.expect(tt.colon) node.alternate = this.parseMaybeAssign(noIn) return this.finishNode(node, "ConditionalExpression") } return expr } // Start the precedence parser. pp.parseExprOps = function(noIn, refDestructuringErrors) { let startPos = this.start, startLoc = this.startLoc let expr = this.parseMaybeUnary(refDestructuringErrors, false) if (this.checkExpressionErrors(refDestructuringErrors)) return expr return this.parseExprOp(expr, startPos, startLoc, -1, noIn) } // Parse binary operators with the operator precedence parsing // algorithm. `left` is the left-hand side of the operator. // `minPrec` provides context that allows the function to stop and // defer further parser to one of its callers when it encounters an // operator that has a lower precedence than the set it is parsing. pp.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, noIn) { let prec = this.type.binop if (prec != null && (!noIn || this.type !== tt._in)) { if (prec > minPrec) { let logical = this.type === tt.logicalOR || this.type === tt.logicalAND let op = this.value this.next() let startPos = this.start, startLoc = this.startLoc let right = this.parseExprOp(this.parseMaybeUnary(null, false), startPos, startLoc, prec, noIn) let node = this.buildBinary(leftStartPos, leftStartLoc, left, right, op, logical) return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, noIn) } } return left } pp.buildBinary = function(startPos, startLoc, left, right, op, logical) { let node = this.startNodeAt(startPos, startLoc) node.left = left node.operator = op node.right = right return this.finishNode(node, logical ? "LogicalExpression" : "BinaryExpression") } // Parse unary operators, both prefix and postfix. pp.parseMaybeUnary = function(refDestructuringErrors, sawUnary) { let startPos = this.start, startLoc = this.startLoc, expr if (this.inAsync && this.isContextual("await")) { expr = this.parseAwait(refDestructuringErrors) sawUnary = true } else if (this.type.prefix) { let node = this.startNode(), update = this.type === tt.incDec node.operator = this.value node.prefix = true this.next() node.argument = this.parseMaybeUnary(null, true) this.checkExpressionErrors(refDestructuringErrors, true) if (update) this.checkLVal(node.argument) else if (this.strict && node.operator === "delete" && node.argument.type === "Identifier") this.raiseRecoverable(node.start, "Deleting local variable in strict mode") else sawUnary = true expr = this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression") } else { expr = this.parseExprSubscripts(refDestructuringErrors) if (this.checkExpressionErrors(refDestructuringErrors)) return expr while (this.type.postfix && !this.canInsertSemicolon()) { let node = this.startNodeAt(startPos, startLoc) node.operator = this.value node.prefix = false node.argument = expr this.checkLVal(expr) this.next() expr = this.finishNode(node, "UpdateExpression") } } if (!sawUnary && this.eat(tt.starstar)) return this.buildBinary(startPos, startLoc, expr, this.parseMaybeUnary(null, false), "**", false) else return expr } // Parse call, dot, and `[]`-subscript expressions. pp.parseExprSubscripts = function(refDestructuringErrors) { let startPos = this.start, startLoc = this.startLoc let expr = this.parseExprAtom(refDestructuringErrors) let skipArrowSubscripts = expr.type === "ArrowFunctionExpression" && this.input.slice(this.lastTokStart, this.lastTokEnd) !== ")" if (this.checkExpressionErrors(refDestructuringErrors) || skipArrowSubscripts) return expr return this.parseSubscripts(expr, startPos, startLoc) } pp.parseSubscripts = function(base, startPos, startLoc, noCalls) { for (;;) { let maybeAsyncArrow = this.options.ecmaVersion >= 8 && base.type === "Identifier" && base.name === "async" && !this.canInsertSemicolon() if (this.eat(tt.dot)) { let node = this.startNodeAt(startPos, startLoc) node.object = base node.property = this.parseIdent(true) node.computed = false base = this.finishNode(node, "MemberExpression") } else if (this.eat(tt.bracketL)) { let node = this.startNodeAt(startPos, startLoc) node.object = base node.property = this.parseExpression() node.computed = true this.expect(tt.bracketR) base = this.finishNode(node, "MemberExpression") } else if (!noCalls && this.eat(tt.parenL)) { let refDestructuringErrors = new DestructuringErrors, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos this.yieldPos = 0 this.awaitPos = 0 let exprList = this.parseExprList(tt.parenR, this.options.ecmaVersion >= 8, false, refDestructuringErrors) if (maybeAsyncArrow && !this.canInsertSemicolon() && this.eat(tt.arrow)) { this.checkPatternErrors(refDestructuringErrors, true) this.checkYieldAwaitInDefaultParams() this.yieldPos = oldYieldPos this.awaitPos = oldAwaitPos return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList, true) } this.checkExpressionErrors(refDestructuringErrors, true) this.yieldPos = oldYieldPos || this.yieldPos this.awaitPos = oldAwaitPos || this.awaitPos let node = this.startNodeAt(startPos, startLoc) node.callee = base node.arguments = exprList base = this.finishNode(node, "CallExpression") } else if (this.type === tt.backQuote) { let node = this.startNodeAt(startPos, startLoc) node.tag = base node.quasi = this.parseTemplate() base = this.finishNode(node, "TaggedTemplateExpression") } else { return base } } } // Parse an atomic expression — either a single token that is an // expression, an expression started by a keyword like `function` or // `new`, or an expression wrapped in punctuation like `()`, `[]`, // or `{}`. pp.parseExprAtom = function(refDestructuringErrors) { let node, canBeArrow = this.potentialArrowAt == this.start switch (this.type) { case tt._super: if (!this.inFunction) this.raise(this.start, "'super' outside of function or class") case tt._this: let type = this.type === tt._this ? "ThisExpression" : "Super" node = this.startNode() this.next() return this.finishNode(node, type) case tt.name: let startPos = this.start, startLoc = this.startLoc let id = this.parseIdent(this.type !== tt.name) if (this.options.ecmaVersion >= 8 && id.name === "async" && !this.canInsertSemicolon() && this.eat(tt._function)) return this.parseFunction(this.startNodeAt(startPos, startLoc), false, false, true) if (canBeArrow && !this.canInsertSemicolon()) { if (this.eat(tt.arrow)) return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], false) if (this.options.ecmaVersion >= 8 && id.name === "async" && this.type === tt.name) { id = this.parseIdent() if (this.canInsertSemicolon() || !this.eat(tt.arrow)) this.unexpected() return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], true) } } return id case tt.regexp: let value = this.value node = this.parseLiteral(value.value) node.regex = {pattern: value.pattern, flags: value.flags} return node case tt.num: case tt.string: return this.parseLiteral(this.value) case tt._null: case tt._true: case tt._false: node = this.startNode() node.value = this.type === tt._null ? null : this.type === tt._true node.raw = this.type.keyword this.next() return this.finishNode(node, "Literal") case tt.parenL: return this.parseParenAndDistinguishExpression(canBeArrow) case tt.bracketL: node = this.startNode() this.next() node.elements = this.parseExprList(tt.bracketR, true, true, refDestructuringErrors) return this.finishNode(node, "ArrayExpression") case tt.braceL: return this.parseObj(false, refDestructuringErrors) case tt._function: node = this.startNode() this.next() return this.parseFunction(node, false) case tt._class: return this.parseClass(this.startNode(), false) case tt._new: return this.parseNew() case tt.backQuote: return this.parseTemplate() default: this.unexpected() } } pp.parseLiteral = function(value) { let node = this.startNode() node.value = value node.raw = this.input.slice(this.start, this.end) this.next() return this.finishNode(node, "Literal") } pp.parseParenExpression = function() { this.expect(tt.parenL) let val = this.parseExpression() this.expect(tt.parenR) return val } pp.parseParenAndDistinguishExpression = function(canBeArrow) { let startPos = this.start, startLoc = this.startLoc, val, allowTrailingComma = this.options.ecmaVersion >= 8 if (this.options.ecmaVersion >= 6) { this.next() let innerStartPos = this.start, innerStartLoc = this.startLoc let exprList = [], first = true, lastIsComma = false let refDestructuringErrors = new DestructuringErrors, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, spreadStart, innerParenStart this.yieldPos = 0 this.awaitPos = 0 while (this.type !== tt.parenR) { first ? first = false : this.expect(tt.comma) if (allowTrailingComma && this.afterTrailingComma(tt.parenR, true)) { lastIsComma = true break } else if (this.type === tt.ellipsis) { spreadStart = this.start exprList.push(this.parseParenItem(this.parseRest())) if (this.type === tt.comma) this.raise(this.start, "Comma is not permitted after the rest element") break } else { if (this.type === tt.parenL && !innerParenStart) { innerParenStart = this.start } exprList.push(this.parseMaybeAssign(false, refDestructuringErrors, this.parseParenItem)) } } let innerEndPos = this.start, innerEndLoc = this.startLoc this.expect(tt.parenR) if (canBeArrow && !this.canInsertSemicolon() && this.eat(tt.arrow)) { this.checkPatternErrors(refDestructuringErrors, true) this.checkYieldAwaitInDefaultParams() if (innerParenStart) this.unexpected(innerParenStart) this.yieldPos = oldYieldPos this.awaitPos = oldAwaitPos return this.parseParenArrowList(startPos, startLoc, exprList) } if (!exprList.length || lastIsComma) this.unexpected(this.lastTokStart) if (spreadStart) this.unexpected(spreadStart) this.checkExpressionErrors(refDestructuringErrors, true) this.yieldPos = oldYieldPos || this.yieldPos this.awaitPos = oldAwaitPos || this.awaitPos if (exprList.length > 1) { val = this.startNodeAt(innerStartPos, innerStartLoc) val.expressions = exprList this.finishNodeAt(val, "SequenceExpression", innerEndPos, innerEndLoc) } else { val = exprList[0] } } else { val = this.parseParenExpression() } if (this.options.preserveParens) { let par = this.startNodeAt(startPos, startLoc) par.expression = val return this.finishNode(par, "ParenthesizedExpression") } else { return val } } pp.parseParenItem = function(item) { return item } pp.parseParenArrowList = function(startPos, startLoc, exprList) { return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList) } // New's precedence is slightly tricky. It must allow its argument to // be a `[]` or dot subscript expression, but not a call — at least, // not without wrapping it in parentheses. Thus, it uses the noCalls // argument to parseSubscripts to prevent it from consuming the // argument list. const empty = [] pp.parseNew = function() { let node = this.startNode() let meta = this.parseIdent(true) if (this.options.ecmaVersion >= 6 && this.eat(tt.dot)) { node.meta = meta node.property = this.parseIdent(true) if (node.property.name !== "target") this.raiseRecoverable(node.property.start, "The only valid meta property for new is new.target") if (!this.inFunction) this.raiseRecoverable(node.start, "new.target can only be used in functions") return this.finishNode(node, "MetaProperty") } let startPos = this.start, startLoc = this.startLoc node.callee = this.parseSubscripts(this.parseExprAtom(), startPos, startLoc, true) if (this.eat(tt.parenL)) node.arguments = this.parseExprList(tt.parenR, this.options.ecmaVersion >= 8, false) else node.arguments = empty return this.finishNode(node, "NewExpression") } // Parse template expression. pp.parseTemplateElement = function() { let elem = this.startNode() elem.value = { raw: this.input.slice(this.start, this.end).replace(/\r\n?/g, '\n'), cooked: this.value } this.next() elem.tail = this.type === tt.backQuote return this.finishNode(elem, "TemplateElement") } pp.parseTemplate = function() { let node = this.startNode() this.next() node.expressions = [] let curElt = this.parseTemplateElement() node.quasis = [curElt] while (!curElt.tail) { this.expect(tt.dollarBraceL) node.expressions.push(this.parseExpression()) this.expect(tt.braceR) node.quasis.push(curElt = this.parseTemplateElement()) } this.next() return this.finishNode(node, "TemplateLiteral") } // Parse an object literal or binding pattern. pp.parseObj = function(isPattern, refDestructuringErrors) { let node = this.startNode(), first = true, propHash = {} node.properties = [] this.next() while (!this.eat(tt.braceR)) { if (!first) { this.expect(tt.comma) if (this.afterTrailingComma(tt.braceR)) break } else first = false let prop = this.startNode(), isGenerator, isAsync, startPos, startLoc if (this.options.ecmaVersion >= 6) { prop.method = false prop.shorthand = false if (isPattern || refDestructuringErrors) { startPos = this.start startLoc = this.startLoc } if (!isPattern) isGenerator = this.eat(tt.star) } this.parsePropertyName(prop) if (!isPattern && this.options.ecmaVersion >= 8 && !isGenerator && !prop.computed && prop.key.type === "Identifier" && prop.key.name === "async" && this.type !== tt.parenL && this.type !== tt.colon && !this.canInsertSemicolon()) { isAsync = true this.parsePropertyName(prop, refDestructuringErrors) } else { isAsync = false } this.parsePropertyValue(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors) this.checkPropClash(prop, propHash) node.properties.push(this.finishNode(prop, "Property")) } return this.finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression") } pp.parsePropertyValue = function(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors) { if ((isGenerator || isAsync) && this.type === tt.colon) this.unexpected() if (this.eat(tt.colon)) { prop.value = isPattern ? this.parseMaybeDefault(this.start, this.startLoc) : this.parseMaybeAssign(false, refDestructuringErrors) prop.kind = "init" } else if (this.options.ecmaVersion >= 6 && this.type === tt.parenL) { if (isPattern) this.unexpected() prop.kind = "init" prop.method = true prop.value = this.parseMethod(isGenerator, isAsync) } else if (this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" && (prop.key.name === "get" || prop.key.name === "set") && (this.type != tt.comma && this.type != tt.braceR)) { if (isGenerator || isAsync || isPattern) this.unexpected() prop.kind = prop.key.name this.parsePropertyName(prop) prop.value = this.parseMethod(false) let paramCount = prop.kind === "get" ? 0 : 1 if (prop.value.params.length !== paramCount) { let start = prop.value.start if (prop.kind === "get") this.raiseRecoverable(start, "getter should have no params") else this.raiseRecoverable(start, "setter should have exactly one param") } else { if (prop.kind === "set" && prop.value.params[0].type === "RestElement") this.raiseRecoverable(prop.value.params[0].start, "Setter cannot use rest params") } } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") { if (this.keywords.test(prop.key.name) || (this.strict ? this.reservedWordsStrict : this.reservedWords).test(prop.key.name) || (this.inGenerator && prop.key.name == "yield") || (this.inAsync && prop.key.name == "await")) this.raiseRecoverable(prop.key.start, "'" + prop.key.name + "' can not be used as shorthand property") prop.kind = "init" if (isPattern) { prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key) } else if (this.type === tt.eq && refDestructuringErrors) { if (!refDestructuringErrors.shorthandAssign) refDestructuringErrors.shorthandAssign = this.start prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key) } else { prop.value = prop.key } prop.shorthand = true } else this.unexpected() } pp.parsePropertyName = function(prop) { if (this.options.ecmaVersion >= 6) { if (this.eat(tt.bracketL)) { prop.computed = true prop.key = this.parseMaybeAssign() this.expect(tt.bracketR) return prop.key } else { prop.computed = false } } return prop.key = this.type === tt.num || this.type === tt.string ? this.parseExprAtom() : this.parseIdent(true) } // Initialize empty function node. pp.initFunction = function(node) { node.id = null if (this.options.ecmaVersion >= 6) { node.generator = false node.expression = false } if (this.options.ecmaVersion >= 8) node.async = false } // Parse object or class method. pp.parseMethod = function(isGenerator, isAsync) { let node = this.startNode(), oldInGen = this.inGenerator, oldInAsync = this.inAsync, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos this.initFunction(node) if (this.options.ecmaVersion >= 6) node.generator = isGenerator if (this.options.ecmaVersion >= 8) node.async = !!isAsync this.inGenerator = node.generator this.inAsync = node.async this.yieldPos = 0 this.awaitPos = 0 this.expect(tt.parenL) node.params = this.parseBindingList(tt.parenR, false, this.options.ecmaVersion >= 8) this.checkYieldAwaitInDefaultParams() this.parseFunctionBody(node, false) this.inGenerator = oldInGen this.inAsync = oldInAsync this.yieldPos = oldYieldPos this.awaitPos = oldAwaitPos return this.finishNode(node, "FunctionExpression") } // Parse arrow function expression with given parameters. pp.parseArrowExpression = function(node, params, isAsync) { let oldInGen = this.inGenerator, oldInAsync = this.inAsync, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos this.initFunction(node) if (this.options.ecmaVersion >= 8) node.async = !!isAsync this.inGenerator = false this.inAsync = node.async this.yieldPos = 0 this.awaitPos = 0 node.params = this.toAssignableList(params, true) this.parseFunctionBody(node, true) this.inGenerator = oldInGen this.inAsync = oldInAsync this.yieldPos = oldYieldPos this.awaitPos = oldAwaitPos return this.finishNode(node, "ArrowFunctionExpression") } // Parse function body and check parameters. pp.parseFunctionBody = function(node, isArrowFunction) { let isExpression = isArrowFunction && this.type !== tt.braceL if (isExpression) { node.body = this.parseMaybeAssign() node.expression = true } else { // Start a new scope with regard to labels and the `inFunction` // flag (restore them to their old value afterwards). let oldInFunc = this.inFunction, oldLabels = this.labels this.inFunction = true; this.labels = [] node.body = this.parseBlock(true) node.expression = false this.inFunction = oldInFunc; this.labels = oldLabels } // If this is a strict mode function, verify that argument names // are not repeated, and it does not try to bind the words `eval` // or `arguments`. let useStrict = (!isExpression && node.body.body.length && this.isUseStrict(node.body.body[0])) ? node.body.body[0] : null if (useStrict && this.options.ecmaVersion >= 7 && !this.isSimpleParamList(node.params)) this.raiseRecoverable(useStrict.start, "Illegal 'use strict' directive in function with non-simple parameter list") if (this.strict || useStrict) { let oldStrict = this.strict this.strict = true if (node.id) this.checkLVal(node.id, true) this.checkParams(node) this.strict = oldStrict } else if (isArrowFunction || !this.isSimpleParamList(node.params)) { this.checkParams(node) } } pp.isSimpleParamList = function(params) { for (let i = 0; i < params.length; i++) if (params[i].type !== "Identifier") return false return true } // Checks function params for various disallowed patterns such as using "eval" // or "arguments" and duplicate parameters. pp.checkParams = function(node) { let nameHash = {} for (let i = 0; i < node.params.length; i++) this.checkLVal(node.params[i], true, nameHash) } // Parses a comma-separated list of expressions, and returns them as // an array. `close` is the token type that ends the list, and // `allowEmpty` can be turned on to allow subsequent commas with // nothing in between them to be parsed as `null` (which is needed // for array literals). pp.parseExprList = function(close, allowTrailingComma, allowEmpty, refDestructuringErrors) { let elts = [], first = true while (!this.eat(close)) { if (!first) { this.expect(tt.comma) if (allowTrailingComma && this.afterTrailingComma(close)) break } else first = false let elt if (allowEmpty && this.type === tt.comma) elt = null else if (this.type === tt.ellipsis) { elt = this.parseSpread(refDestructuringErrors) if (this.type === tt.comma && refDestructuringErrors && !refDestructuringErrors.trailingComma) { refDestructuringErrors.trailingComma = this.start } } else elt = this.parseMaybeAssign(false, refDestructuringErrors) elts.push(elt) } return elts } // Parse the next token as an identifier. If `liberal` is true (used // when parsing properties), it will also convert keywords into // identifiers. pp.parseIdent = function(liberal) { let node = this.startNode() if (liberal && this.options.allowReserved == "never") liberal = false if (this.type === tt.name) { if (!liberal && (this.strict ? this.reservedWordsStrict : this.reservedWords).test(this.value) && (this.options.ecmaVersion >= 6 || this.input.slice(this.start, this.end).indexOf("\\") == -1)) this.raiseRecoverable(this.start, "The keyword '" + this.value + "' is reserved") if (this.inGenerator && this.value === "yield") this.raiseRecoverable(this.start, "Can not use 'yield' as identifier inside a generator") if (this.inAsync && this.value === "await") this.raiseRecoverable(this.start, "Can not use 'await' as identifier inside an async function") node.name = this.value } else if (liberal && this.type.keyword) { node.name = this.type.keyword } else { this.unexpected() } this.next() return this.finishNode(node, "Identifier") } // Parses yield expression inside generator. pp.parseYield = function() { if (!this.yieldPos) this.yieldPos = this.start let node = this.startNode() this.next() if (this.type == tt.semi || this.canInsertSemicolon() || (this.type != tt.star && !this.type.startsExpr)) { node.delegate = false node.argument = null } else { node.delegate = this.eat(tt.star) node.argument = this.parseMaybeAssign() } return this.finishNode(node, "YieldExpression") } pp.parseAwait = function() { if (!this.awaitPos) this.awaitPos = this.start let node = this.startNode() this.next() node.argument = this.parseMaybeUnary(null, true) return this.finishNode(node, "AwaitExpression") } acorn-4.0.4/src/identifier.js000066400000000000000000000263611302576755300161150ustar00rootroot00000000000000// Reserved word lists for various dialects of the language export const reservedWords = { 3: "abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile", 5: "class enum extends super const export import", 6: "enum", strict: "implements interface let package private protected public static yield", strictBind: "eval arguments" } // And the keywords var ecma5AndLessKeywords = "break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this" export const keywords = { 5: ecma5AndLessKeywords, 6: ecma5AndLessKeywords + " const class extends export import super" } // ## Character categories // Big ugly regular expressions that match characters in the // whitespace, identifier, and identifier-start categories. These // are only applied when a character is found to actually have a // code point above 128. // Generated by `bin/generate-identifier-regex.js`. let nonASCIIidentifierStartChars = "\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-\u08b4\u08b6-\u08bd\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\u0af9\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-\u0c5a\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\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-\u13f5\u13f8-\u13fd\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\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\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-\u9fd5\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7ae\ua7b0-\ua7b7\ua7f7-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\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-\uab65\uab70-\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" let nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u08d4-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c03\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0d01-\u0d03\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0eb9\u0ebb\u0ebc\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf2-\u1cf4\u1cf8\u1cf9\u1dc0-\u1df5\u1dfb-\u1dff\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua900-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f" const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]") const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]") nonASCIIidentifierStartChars = nonASCIIidentifierChars = null // These are a run-length and offset encoded representation of the // >0xffff code points that are a valid part of identifiers. The // offset starts at 0x10000, and each pair of numbers represents an // offset to the next range, and then a size of the range. They were // generated by bin/generate-identifier-regex.js const astralIdentifierStartCodes = [0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,17,26,6,37,11,29,3,35,5,7,2,4,43,157,19,35,5,35,5,39,9,51,157,310,10,21,11,7,153,5,3,0,2,43,2,1,4,0,3,22,11,22,10,30,66,18,2,1,11,21,11,25,71,55,7,1,65,0,16,3,2,2,2,26,45,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,56,50,14,50,785,52,76,44,33,24,27,35,42,34,4,0,13,47,15,3,22,0,2,0,36,17,2,24,85,6,2,0,2,3,2,14,2,9,8,46,39,7,3,1,3,21,2,6,2,1,2,4,4,0,19,0,13,4,159,52,19,3,54,47,21,1,2,0,185,46,42,3,37,47,21,0,60,42,86,25,391,63,32,0,449,56,264,8,2,36,18,0,50,29,881,921,103,110,18,195,2749,1070,4050,582,8634,568,8,30,114,29,19,47,17,3,32,20,6,18,881,68,12,0,67,12,65,0,32,6124,20,754,9486,1,3071,106,6,12,4,8,8,9,5991,84,2,70,2,1,3,0,3,1,3,3,2,11,2,0,2,6,2,64,2,3,3,7,2,6,2,27,2,3,2,4,2,0,4,6,2,339,3,24,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,7,4149,196,60,67,1213,3,2,26,2,1,2,0,3,0,2,9,2,3,2,0,2,0,7,0,5,0,2,0,2,0,2,2,2,1,2,0,3,0,2,0,2,0,2,0,2,0,2,1,2,0,3,3,2,6,2,3,2,3,2,0,2,9,2,16,6,2,2,4,2,16,4421,42710,42,4148,12,221,3,5761,10591,541] const astralIdentifierCodes = [509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,1306,2,54,14,32,9,16,3,46,10,54,9,7,2,37,13,2,9,52,0,13,2,49,13,10,2,4,9,83,11,7,0,161,11,6,9,7,3,57,0,2,6,3,1,3,2,10,0,11,1,3,6,4,4,193,17,10,9,87,19,13,9,214,6,3,8,28,1,83,16,16,9,82,12,9,9,84,14,5,9,423,9,838,7,2,7,17,9,57,21,2,13,19882,9,135,4,60,6,26,9,1016,45,17,3,19723,1,5319,4,4,5,9,7,3,6,31,3,149,2,1418,49,513,54,5,49,9,0,15,0,23,4,2,14,1361,6,2,16,3,6,2,1,2,4,2214,6,110,6,6,9,792487,239] // This has a complexity linear to the value of the code. The // assumption is that looking up astral identifier characters is // rare. function isInAstralSet(code, set) { let pos = 0x10000 for (let i = 0; i < set.length; i += 2) { pos += set[i] if (pos > code) return false pos += set[i + 1] if (pos >= code) return true } } // Test whether a given character code starts an identifier. export function isIdentifierStart(code, astral) { if (code < 65) return code === 36 if (code < 91) return true if (code < 97) return code === 95 if (code < 123) return true if (code <= 0xffff) return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code)) if (astral === false) return false return isInAstralSet(code, astralIdentifierStartCodes) } // Test whether a given character is part of an identifier. export function isIdentifierChar(code, astral) { if (code < 48) return code === 36 if (code < 58) return true if (code < 65) return false if (code < 91) return true if (code < 97) return code === 95 if (code < 123) return true if (code <= 0xffff) return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code)) if (astral === false) return false return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes) } acorn-4.0.4/src/index.js000066400000000000000000000047671302576755300151100ustar00rootroot00000000000000// Acorn is a tiny, fast JavaScript parser written in JavaScript. // // Acorn was written by Marijn Haverbeke, Ingvar Stepanyan, and // various contributors and released under an MIT license. // // Git repositories for Acorn are available at // // http://marijnhaverbeke.nl/git/acorn // https://github.com/ternjs/acorn.git // // Please use the [github bug tracker][ghbt] to report issues. // // [ghbt]: https://github.com/ternjs/acorn/issues // // This file defines the main parser interface. The library also comes // with a [error-tolerant parser][dammit] and an // [abstract syntax tree walker][walk], defined in other files. // // [dammit]: acorn_loose.js // [walk]: util/walk.js import {Parser} from "./state" import "./parseutil" import "./statement" import "./lval" import "./expression" import "./location" export {Parser, plugins} from "./state" export {defaultOptions} from "./options" export {Position, SourceLocation, getLineInfo} from "./locutil" export {Node} from "./node" export {TokenType, types as tokTypes} from "./tokentype" export {TokContext, types as tokContexts} from "./tokencontext" export {isIdentifierChar, isIdentifierStart} from "./identifier" export {Token} from "./tokenize" export {isNewLine, lineBreak, lineBreakG} from "./whitespace" export const version = "4.0.4" // The main exported interface (under `self.acorn` when in the // browser) is a `parse` function that takes a code string and // returns an abstract syntax tree as specified by [Mozilla parser // API][api]. // // [api]: https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API export function parse(input, options) { return new Parser(options, input).parse() } // This function tries to parse a single expression at a given // offset in a string. Useful for parsing mixed-language formats // that embed JavaScript expressions. export function parseExpressionAt(input, pos, options) { let p = new Parser(options, input, pos) p.nextToken() return p.parseExpression() } // Acorn is organized as a tokenizer and a recursive-descent parser. // The `tokenizer` export provides an interface to the tokenizer. export function tokenizer(input, options) { return new Parser(options, input) } // This is a terrible kludge to support the existing, pre-ES6 // interface where the loose parser module retroactively adds exports // to this module. export let parse_dammit, LooseParser, pluginsLoose export function addLooseExports(parse, Parser, plugins) { parse_dammit = parse LooseParser = Parser pluginsLoose = plugins } acorn-4.0.4/src/location.js000066400000000000000000000014231302576755300155730ustar00rootroot00000000000000import {Parser} from "./state" import {Position, getLineInfo} from "./locutil" const pp = Parser.prototype // This function is used to raise exceptions on parse errors. It // takes an offset integer (into the current `input`) to indicate // the location of the error, attaches the position to the end // of the error message, and then raises a `SyntaxError` with that // message. pp.raise = function(pos, message) { let loc = getLineInfo(this.input, pos) message += " (" + loc.line + ":" + loc.column + ")" let err = new SyntaxError(message) err.pos = pos; err.loc = loc; err.raisedAt = this.pos throw err } pp.raiseRecoverable = pp.raise pp.curPosition = function() { if (this.options.locations) { return new Position(this.curLine, this.pos - this.lineStart) } } acorn-4.0.4/src/locutil.js000066400000000000000000000020371302576755300154400ustar00rootroot00000000000000import {lineBreakG} from "./whitespace" // These are used when `options.locations` is on, for the // `startLoc` and `endLoc` properties. export class Position { constructor(line, col) { this.line = line this.column = col } offset(n) { return new Position(this.line, this.column + n) } } export class SourceLocation { constructor(p, start, end) { this.start = start this.end = end if (p.sourceFile !== null) this.source = p.sourceFile } } // The `getLineInfo` function is mostly useful when the // `locations` option is off (for performance reasons) and you // want to find the line/column position for a given character // offset. `input` should be the code string that the offset refers // into. export function getLineInfo(input, offset) { for (let line = 1, cur = 0;;) { lineBreakG.lastIndex = cur let match = lineBreakG.exec(input) if (match && match.index < offset) { ++line cur = match.index + match[0].length } else { return new Position(line, offset - cur) } } } acorn-4.0.4/src/loose/000077500000000000000000000000001302576755300145465ustar00rootroot00000000000000acorn-4.0.4/src/loose/expression.js000066400000000000000000000432641302576755300173140ustar00rootroot00000000000000import {LooseParser} from "./state" import {isDummy} from "./parseutil" import {tokTypes as tt} from "../index" const lp = LooseParser.prototype lp.checkLVal = function(expr) { if (!expr) return expr switch (expr.type) { case "Identifier": case "MemberExpression": return expr case "ParenthesizedExpression": expr.expression = this.checkLVal(expr.expression) return expr default: return this.dummyIdent() } } lp.parseExpression = function(noIn) { let start = this.storeCurrentPos() let expr = this.parseMaybeAssign(noIn) if (this.tok.type === tt.comma) { let node = this.startNodeAt(start) node.expressions = [expr] while (this.eat(tt.comma)) node.expressions.push(this.parseMaybeAssign(noIn)) return this.finishNode(node, "SequenceExpression") } return expr } lp.parseParenExpression = function() { this.pushCx() this.expect(tt.parenL) let val = this.parseExpression() this.popCx() this.expect(tt.parenR) return val } lp.parseMaybeAssign = function(noIn) { if (this.toks.isContextual("yield")) { let node = this.startNode() this.next() if (this.semicolon() || this.canInsertSemicolon() || (this.tok.type != tt.star && !this.tok.type.startsExpr)) { node.delegate = false node.argument = null } else { node.delegate = this.eat(tt.star) node.argument = this.parseMaybeAssign() } return this.finishNode(node, "YieldExpression") } let start = this.storeCurrentPos() let left = this.parseMaybeConditional(noIn) if (this.tok.type.isAssign) { let node = this.startNodeAt(start) node.operator = this.tok.value node.left = this.tok.type === tt.eq ? this.toAssignable(left) : this.checkLVal(left) this.next() node.right = this.parseMaybeAssign(noIn) return this.finishNode(node, "AssignmentExpression") } return left } lp.parseMaybeConditional = function(noIn) { let start = this.storeCurrentPos() let expr = this.parseExprOps(noIn) if (this.eat(tt.question)) { let node = this.startNodeAt(start) node.test = expr node.consequent = this.parseMaybeAssign() node.alternate = this.expect(tt.colon) ? this.parseMaybeAssign(noIn) : this.dummyIdent() return this.finishNode(node, "ConditionalExpression") } return expr } lp.parseExprOps = function(noIn) { let start = this.storeCurrentPos() let indent = this.curIndent, line = this.curLineStart return this.parseExprOp(this.parseMaybeUnary(false), start, -1, noIn, indent, line) } lp.parseExprOp = function(left, start, minPrec, noIn, indent, line) { if (this.curLineStart != line && this.curIndent < indent && this.tokenStartsLine()) return left let prec = this.tok.type.binop if (prec != null && (!noIn || this.tok.type !== tt._in)) { if (prec > minPrec) { let node = this.startNodeAt(start) node.left = left node.operator = this.tok.value this.next() if (this.curLineStart != line && this.curIndent < indent && this.tokenStartsLine()) { node.right = this.dummyIdent() } else { let rightStart = this.storeCurrentPos() node.right = this.parseExprOp(this.parseMaybeUnary(false), rightStart, prec, noIn, indent, line) } this.finishNode(node, /&&|\|\|/.test(node.operator) ? "LogicalExpression" : "BinaryExpression") return this.parseExprOp(node, start, minPrec, noIn, indent, line) } } return left } lp.parseMaybeUnary = function(sawUnary) { let start = this.storeCurrentPos(), expr if (this.options.ecmaVersion >= 8 && this.inAsync && this.toks.isContextual("await")) { expr = this.parseAwait() sawUnary = true } else if (this.tok.type.prefix) { let node = this.startNode(), update = this.tok.type === tt.incDec if (!update) sawUnary = true node.operator = this.tok.value node.prefix = true this.next() node.argument = this.parseMaybeUnary(true) if (update) node.argument = this.checkLVal(node.argument) expr = this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression") } else if (this.tok.type === tt.ellipsis) { let node = this.startNode() this.next() node.argument = this.parseMaybeUnary(sawUnary) expr = this.finishNode(node, "SpreadElement") } else { expr = this.parseExprSubscripts() while (this.tok.type.postfix && !this.canInsertSemicolon()) { let node = this.startNodeAt(start) node.operator = this.tok.value node.prefix = false node.argument = this.checkLVal(expr) this.next() expr = this.finishNode(node, "UpdateExpression") } } if (!sawUnary && this.eat(tt.starstar)) { let node = this.startNodeAt(start) node.operator = "**" node.left = expr node.right = this.parseMaybeUnary(false) return this.finishNode(node, "BinaryExpression") } return expr } lp.parseExprSubscripts = function() { let start = this.storeCurrentPos() return this.parseSubscripts(this.parseExprAtom(), start, false, this.curIndent, this.curLineStart) } lp.parseSubscripts = function(base, start, noCalls, startIndent, line) { for (;;) { if (this.curLineStart != line && this.curIndent <= startIndent && this.tokenStartsLine()) { if (this.tok.type == tt.dot && this.curIndent == startIndent) --startIndent else return base } let maybeAsyncArrow = base.type === "Identifier" && base.name === "async" && !this.canInsertSemicolon() if (this.eat(tt.dot)) { let node = this.startNodeAt(start) node.object = base if (this.curLineStart != line && this.curIndent <= startIndent && this.tokenStartsLine()) node.property = this.dummyIdent() else node.property = this.parsePropertyAccessor() || this.dummyIdent() node.computed = false base = this.finishNode(node, "MemberExpression") } else if (this.tok.type == tt.bracketL) { this.pushCx() this.next() let node = this.startNodeAt(start) node.object = base node.property = this.parseExpression() node.computed = true this.popCx() this.expect(tt.bracketR) base = this.finishNode(node, "MemberExpression") } else if (!noCalls && this.tok.type == tt.parenL) { let exprList = this.parseExprList(tt.parenR) if (maybeAsyncArrow && this.eat(tt.arrow)) return this.parseArrowExpression(this.startNodeAt(start), exprList, true) let node = this.startNodeAt(start) node.callee = base node.arguments = exprList base = this.finishNode(node, "CallExpression") } else if (this.tok.type == tt.backQuote) { let node = this.startNodeAt(start) node.tag = base node.quasi = this.parseTemplate() base = this.finishNode(node, "TaggedTemplateExpression") } else { return base } } } lp.parseExprAtom = function() { let node switch (this.tok.type) { case tt._this: case tt._super: let type = this.tok.type === tt._this ? "ThisExpression" : "Super" node = this.startNode() this.next() return this.finishNode(node, type) case tt.name: let start = this.storeCurrentPos() let id = this.parseIdent() let isAsync = false if (id.name === "async" && !this.canInsertSemicolon()) { if (this.eat(tt._function)) return this.parseFunction(this.startNodeAt(start), false, true) if (this.tok.type === tt.name) { id = this.parseIdent() isAsync = true } } return this.eat(tt.arrow) ? this.parseArrowExpression(this.startNodeAt(start), [id], isAsync) : id case tt.regexp: node = this.startNode() let val = this.tok.value node.regex = {pattern: val.pattern, flags: val.flags} node.value = val.value node.raw = this.input.slice(this.tok.start, this.tok.end) this.next() return this.finishNode(node, "Literal") case tt.num: case tt.string: node = this.startNode() node.value = this.tok.value node.raw = this.input.slice(this.tok.start, this.tok.end) this.next() return this.finishNode(node, "Literal") case tt._null: case tt._true: case tt._false: node = this.startNode() node.value = this.tok.type === tt._null ? null : this.tok.type === tt._true node.raw = this.tok.type.keyword this.next() return this.finishNode(node, "Literal") case tt.parenL: let parenStart = this.storeCurrentPos() this.next() let inner = this.parseExpression() this.expect(tt.parenR) if (this.eat(tt.arrow)) { // (a,)=>a // SequenceExpression makes dummy in the last hole. Drop the dummy. let params = inner.expressions || [inner] if (params.length && isDummy(params[params.length - 1])) params.pop() return this.parseArrowExpression(this.startNodeAt(parenStart), params) } if (this.options.preserveParens) { let par = this.startNodeAt(parenStart) par.expression = inner inner = this.finishNode(par, "ParenthesizedExpression") } return inner case tt.bracketL: node = this.startNode() node.elements = this.parseExprList(tt.bracketR, true) return this.finishNode(node, "ArrayExpression") case tt.braceL: return this.parseObj() case tt._class: return this.parseClass() case tt._function: node = this.startNode() this.next() return this.parseFunction(node, false) case tt._new: return this.parseNew() case tt.backQuote: return this.parseTemplate() default: return this.dummyIdent() } } lp.parseNew = function() { let node = this.startNode(), startIndent = this.curIndent, line = this.curLineStart let meta = this.parseIdent(true) if (this.options.ecmaVersion >= 6 && this.eat(tt.dot)) { node.meta = meta node.property = this.parseIdent(true) return this.finishNode(node, "MetaProperty") } let start = this.storeCurrentPos() node.callee = this.parseSubscripts(this.parseExprAtom(), start, true, startIndent, line) if (this.tok.type == tt.parenL) { node.arguments = this.parseExprList(tt.parenR) } else { node.arguments = [] } return this.finishNode(node, "NewExpression") } lp.parseTemplateElement = function() { let elem = this.startNode() elem.value = { raw: this.input.slice(this.tok.start, this.tok.end).replace(/\r\n?/g, '\n'), cooked: this.tok.value } this.next() elem.tail = this.tok.type === tt.backQuote return this.finishNode(elem, "TemplateElement") } lp.parseTemplate = function() { let node = this.startNode() this.next() node.expressions = [] let curElt = this.parseTemplateElement() node.quasis = [curElt] while (!curElt.tail) { this.next() node.expressions.push(this.parseExpression()) if (this.expect(tt.braceR)) { curElt = this.parseTemplateElement() } else { curElt = this.startNode() curElt.value = {cooked: '', raw: ''} curElt.tail = true this.finishNode(curElt, "TemplateElement") } node.quasis.push(curElt) } this.expect(tt.backQuote) return this.finishNode(node, "TemplateLiteral") } lp.parseObj = function() { let node = this.startNode() node.properties = [] this.pushCx() let indent = this.curIndent + 1, line = this.curLineStart this.eat(tt.braceL) if (this.curIndent + 1 < indent) { indent = this.curIndent; line = this.curLineStart } while (!this.closes(tt.braceR, indent, line)) { let prop = this.startNode(), isGenerator, isAsync, start if (this.options.ecmaVersion >= 6) { start = this.storeCurrentPos() prop.method = false prop.shorthand = false isGenerator = this.eat(tt.star) } this.parsePropertyName(prop) if (!prop.computed && prop.key.type === "Identifier" && prop.key.name === "async" && this.tok.type !== tt.parenL && this.tok.type !== tt.colon && !this.canInsertSemicolon()) { this.parsePropertyName(prop) isAsync = true } else { isAsync = false } if (isDummy(prop.key)) { if (isDummy(this.parseMaybeAssign())) this.next(); this.eat(tt.comma); continue } if (this.eat(tt.colon)) { prop.kind = "init" prop.value = this.parseMaybeAssign() } else if (this.options.ecmaVersion >= 6 && (this.tok.type === tt.parenL || this.tok.type === tt.braceL)) { prop.kind = "init" prop.method = true prop.value = this.parseMethod(isGenerator, isAsync) } else if (this.options.ecmaVersion >= 5 && prop.key.type === "Identifier" && !prop.computed && (prop.key.name === "get" || prop.key.name === "set") && (this.tok.type != tt.comma && this.tok.type != tt.braceR)) { prop.kind = prop.key.name this.parsePropertyName(prop) prop.value = this.parseMethod(false) } else { prop.kind = "init" if (this.options.ecmaVersion >= 6) { if (this.eat(tt.eq)) { let assign = this.startNodeAt(start) assign.operator = "=" assign.left = prop.key assign.right = this.parseMaybeAssign() prop.value = this.finishNode(assign, "AssignmentExpression") } else { prop.value = prop.key } } else { prop.value = this.dummyIdent() } prop.shorthand = true } node.properties.push(this.finishNode(prop, "Property")) this.eat(tt.comma) } this.popCx() if (!this.eat(tt.braceR)) { // If there is no closing brace, make the node span to the start // of the next token (this is useful for Tern) this.last.end = this.tok.start if (this.options.locations) this.last.loc.end = this.tok.loc.start } return this.finishNode(node, "ObjectExpression") } lp.parsePropertyName = function(prop) { if (this.options.ecmaVersion >= 6) { if (this.eat(tt.bracketL)) { prop.computed = true prop.key = this.parseExpression() this.expect(tt.bracketR) return } else { prop.computed = false } } let key = (this.tok.type === tt.num || this.tok.type === tt.string) ? this.parseExprAtom() : this.parseIdent() prop.key = key || this.dummyIdent() } lp.parsePropertyAccessor = function() { if (this.tok.type === tt.name || this.tok.type.keyword) return this.parseIdent() } lp.parseIdent = function() { let name = this.tok.type === tt.name ? this.tok.value : this.tok.type.keyword if (!name) return this.dummyIdent() let node = this.startNode() this.next() node.name = name return this.finishNode(node, "Identifier") } lp.initFunction = function(node) { node.id = null node.params = [] if (this.options.ecmaVersion >= 6) { node.generator = false node.expression = false } if (this.options.ecmaVersion >= 8) node.async = false } // Convert existing expression atom to assignable pattern // if possible. lp.toAssignable = function(node, binding) { if (!node || node.type == "Identifier" || (node.type == "MemberExpression" && !binding)) { // Okay } else if (node.type == "ParenthesizedExpression") { node.expression = this.toAssignable(node.expression, binding) } else if (this.options.ecmaVersion < 6) { return this.dummyIdent() } else if (node.type == "ObjectExpression") { node.type = "ObjectPattern" let props = node.properties for (let i = 0; i < props.length; i++) props[i].value = this.toAssignable(props[i].value, binding) } else if (node.type == "ArrayExpression") { node.type = "ArrayPattern" this.toAssignableList(node.elements, binding) } else if (node.type == "SpreadElement") { node.type = "RestElement" node.argument = this.toAssignable(node.argument, binding) } else if (node.type == "AssignmentExpression") { node.type = "AssignmentPattern" delete node.operator } else { return this.dummyIdent() } return node } lp.toAssignableList = function(exprList, binding) { for (let i = 0; i < exprList.length; i++) exprList[i] = this.toAssignable(exprList[i], binding) return exprList } lp.parseFunctionParams = function(params) { params = this.parseExprList(tt.parenR) return this.toAssignableList(params, true) } lp.parseMethod = function(isGenerator, isAsync) { let node = this.startNode(), oldInAsync = this.inAsync this.initFunction(node) if (this.options.ecmaVersion >= 6) node.generator = !!isGenerator if (this.options.ecmaVersion >= 8) node.async = !!isAsync this.inAsync = node.async node.params = this.parseFunctionParams() node.expression = this.options.ecmaVersion >= 6 && this.tok.type !== tt.braceL node.body = node.expression ? this.parseMaybeAssign() : this.parseBlock() this.inAsync = oldInAsync return this.finishNode(node, "FunctionExpression") } lp.parseArrowExpression = function(node, params, isAsync) { let oldInAsync = this.inAsync this.initFunction(node) if (this.options.ecmaVersion >= 8) node.async = !!isAsync this.inAsync = node.async node.params = this.toAssignableList(params, true) node.expression = this.tok.type !== tt.braceL node.body = node.expression ? this.parseMaybeAssign() : this.parseBlock() this.inAsync = oldInAsync return this.finishNode(node, "ArrowFunctionExpression") } lp.parseExprList = function(close, allowEmpty) { this.pushCx() let indent = this.curIndent, line = this.curLineStart, elts = [] this.next() // Opening bracket while (!this.closes(close, indent + 1, line)) { if (this.eat(tt.comma)) { elts.push(allowEmpty ? null : this.dummyIdent()) continue } let elt = this.parseMaybeAssign() if (isDummy(elt)) { if (this.closes(close, indent, line)) break this.next() } else { elts.push(elt) } this.eat(tt.comma) } this.popCx() if (!this.eat(close)) { // If there is no closing brace, make the node span to the start // of the next token (this is useful for Tern) this.last.end = this.tok.start if (this.options.locations) this.last.loc.end = this.tok.loc.start } return elts } lp.parseAwait = function() { let node = this.startNode() this.next() node.argument = this.parseMaybeUnary() return this.finishNode(node, "AwaitExpression") } acorn-4.0.4/src/loose/index.js000066400000000000000000000033241302576755300162150ustar00rootroot00000000000000// Acorn: Loose parser // // This module provides an alternative parser (`parse_dammit`) that // exposes that same interface as `parse`, but will try to parse // anything as JavaScript, repairing syntax error the best it can. // There are circumstances in which it will raise an error and give // up, but they are very rare. The resulting AST will be a mostly // valid JavaScript AST (as per the [Mozilla parser API][api], except // that: // // - Return outside functions is allowed // // - Label consistency (no conflicts, break only to existing labels) // is not enforced. // // - Bogus Identifier nodes with a name of `"✖"` are inserted whenever // the parser got too confused to return anything meaningful. // // [api]: https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API // // The expected use for this is to *first* try `acorn.parse`, and only // if that fails switch to `parse_dammit`. The loose parser might // parse badly indented code incorrectly, so **don't** use it as // your default parser. // // Quite a lot of acorn.js is duplicated here. The alternative was to // add a *lot* of extra cruft to that file, making it less readable // and slower. Copying and editing the code allowed me to make // invasive changes and simplifications without creating a complicated // tangle. import {addLooseExports, defaultOptions} from "../index" import {LooseParser, pluginsLoose} from "./state" import "./tokenize" import "./statement" import "./expression" export {LooseParser, pluginsLoose} from "./state" defaultOptions.tabSize = 4 export function parse_dammit(input, options) { let p = new LooseParser(input, options) p.next() return p.parseTopLevel() } addLooseExports(parse_dammit, LooseParser, pluginsLoose) acorn-4.0.4/src/loose/parseutil.js000066400000000000000000000000731302576755300171140ustar00rootroot00000000000000export function isDummy(node) { return node.name == "✖" }acorn-4.0.4/src/loose/state.js000066400000000000000000000100361302576755300162240ustar00rootroot00000000000000import {tokenizer, SourceLocation, tokTypes as tt, Node, lineBreak, isNewLine} from "../index" // Registered plugins export const pluginsLoose = {} export class LooseParser { constructor(input, options = {}) { this.toks = tokenizer(input, options) this.options = this.toks.options this.input = this.toks.input this.tok = this.last = {type: tt.eof, start: 0, end: 0} if (this.options.locations) { let here = this.toks.curPosition() this.tok.loc = new SourceLocation(this.toks, here, here) } this.ahead = [] // Tokens ahead this.context = [] // Indentation contexted this.curIndent = 0 this.curLineStart = 0 this.nextLineStart = this.lineEnd(this.curLineStart) + 1 this.inAsync = false // Load plugins this.options.pluginsLoose = options.pluginsLoose || {} this.loadPlugins(this.options.pluginsLoose) } startNode() { return new Node(this.toks, this.tok.start, this.options.locations ? this.tok.loc.start : null) } storeCurrentPos() { return this.options.locations ? [this.tok.start, this.tok.loc.start] : this.tok.start } startNodeAt(pos) { if (this.options.locations) { return new Node(this.toks, pos[0], pos[1]) } else { return new Node(this.toks, pos) } } finishNode(node, type) { node.type = type node.end = this.last.end if (this.options.locations) node.loc.end = this.last.loc.end if (this.options.ranges) node.range[1] = this.last.end return node } dummyNode(type) { let dummy = this.startNode() dummy.type = type dummy.end = dummy.start if (this.options.locations) dummy.loc.end = dummy.loc.start if (this.options.ranges) dummy.range[1] = dummy.start this.last = {type: tt.name, start: dummy.start, end: dummy.start, loc: dummy.loc} return dummy } dummyIdent() { let dummy = this.dummyNode("Identifier") dummy.name = "✖" return dummy } dummyString() { let dummy = this.dummyNode("Literal") dummy.value = dummy.raw = "✖" return dummy } eat(type) { if (this.tok.type === type) { this.next() return true } else { return false } } isContextual(name) { return this.tok.type === tt.name && this.tok.value === name } eatContextual(name) { return this.tok.value === name && this.eat(tt.name) } canInsertSemicolon() { return this.tok.type === tt.eof || this.tok.type === tt.braceR || lineBreak.test(this.input.slice(this.last.end, this.tok.start)) } semicolon() { return this.eat(tt.semi) } expect(type) { if (this.eat(type)) return true for (let i = 1; i <= 2; i++) { if (this.lookAhead(i).type == type) { for (let j = 0; j < i; j++) this.next() return true } } } pushCx() { this.context.push(this.curIndent) } popCx() { this.curIndent = this.context.pop() } lineEnd(pos) { while (pos < this.input.length && !isNewLine(this.input.charCodeAt(pos))) ++pos return pos } indentationAfter(pos) { for (let count = 0;; ++pos) { let ch = this.input.charCodeAt(pos) if (ch === 32) ++count else if (ch === 9) count += this.options.tabSize else return count } } closes(closeTok, indent, line, blockHeuristic) { if (this.tok.type === closeTok || this.tok.type === tt.eof) return true return line != this.curLineStart && this.curIndent < indent && this.tokenStartsLine() && (!blockHeuristic || this.nextLineStart >= this.input.length || this.indentationAfter(this.nextLineStart) < indent) } tokenStartsLine() { for (let p = this.tok.start - 1; p >= this.curLineStart; --p) { let ch = this.input.charCodeAt(p) if (ch !== 9 && ch !== 32) return false } return true } extend(name, f) { this[name] = f(this[name]) } loadPlugins(pluginConfigs) { for (let name in pluginConfigs) { let plugin = pluginsLoose[name] if (!plugin) throw new Error("Plugin '" + name + "' not found") plugin(this, pluginConfigs[name]) } } } acorn-4.0.4/src/loose/statement.js000066400000000000000000000350731302576755300171200ustar00rootroot00000000000000import {LooseParser} from "./state" import {isDummy} from "./parseutil" import {getLineInfo, tokTypes as tt} from "../index" const lp = LooseParser.prototype lp.parseTopLevel = function() { let node = this.startNodeAt(this.options.locations ? [0, getLineInfo(this.input, 0)] : 0) node.body = [] while (this.tok.type !== tt.eof) node.body.push(this.parseStatement()) this.last = this.tok if (this.options.ecmaVersion >= 6) { node.sourceType = this.options.sourceType } return this.finishNode(node, "Program") } lp.parseStatement = function() { let starttype = this.tok.type, node = this.startNode(), kind if (this.toks.isLet()) { starttype = tt._var kind = "let" } switch (starttype) { case tt._break: case tt._continue: this.next() let isBreak = starttype === tt._break if (this.semicolon() || this.canInsertSemicolon()) { node.label = null } else { node.label = this.tok.type === tt.name ? this.parseIdent() : null this.semicolon() } return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement") case tt._debugger: this.next() this.semicolon() return this.finishNode(node, "DebuggerStatement") case tt._do: this.next() node.body = this.parseStatement() node.test = this.eat(tt._while) ? this.parseParenExpression() : this.dummyIdent() this.semicolon() return this.finishNode(node, "DoWhileStatement") case tt._for: this.next() this.pushCx() this.expect(tt.parenL) if (this.tok.type === tt.semi) return this.parseFor(node, null) let isLet = this.toks.isLet() if (isLet || this.tok.type === tt._var || this.tok.type === tt._const) { let init = this.parseVar(true, isLet ? "let" : this.tok.value) if (init.declarations.length === 1 && (this.tok.type === tt._in || this.isContextual("of"))) { return this.parseForIn(node, init) } return this.parseFor(node, init) } let init = this.parseExpression(true) if (this.tok.type === tt._in || this.isContextual("of")) return this.parseForIn(node, this.toAssignable(init)) return this.parseFor(node, init) case tt._function: this.next() return this.parseFunction(node, true) case tt._if: this.next() node.test = this.parseParenExpression() node.consequent = this.parseStatement() node.alternate = this.eat(tt._else) ? this.parseStatement() : null return this.finishNode(node, "IfStatement") case tt._return: this.next() if (this.eat(tt.semi) || this.canInsertSemicolon()) node.argument = null else { node.argument = this.parseExpression(); this.semicolon() } return this.finishNode(node, "ReturnStatement") case tt._switch: let blockIndent = this.curIndent, line = this.curLineStart this.next() node.discriminant = this.parseParenExpression() node.cases = [] this.pushCx() this.expect(tt.braceL) let cur while (!this.closes(tt.braceR, blockIndent, line, true)) { if (this.tok.type === tt._case || this.tok.type === tt._default) { let isCase = this.tok.type === tt._case if (cur) this.finishNode(cur, "SwitchCase") node.cases.push(cur = this.startNode()) cur.consequent = [] this.next() if (isCase) cur.test = this.parseExpression() else cur.test = null this.expect(tt.colon) } else { if (!cur) { node.cases.push(cur = this.startNode()) cur.consequent = [] cur.test = null } cur.consequent.push(this.parseStatement()) } } if (cur) this.finishNode(cur, "SwitchCase") this.popCx() this.eat(tt.braceR) return this.finishNode(node, "SwitchStatement") case tt._throw: this.next() node.argument = this.parseExpression() this.semicolon() return this.finishNode(node, "ThrowStatement") case tt._try: this.next() node.block = this.parseBlock() node.handler = null if (this.tok.type === tt._catch) { let clause = this.startNode() this.next() this.expect(tt.parenL) clause.param = this.toAssignable(this.parseExprAtom(), true) this.expect(tt.parenR) clause.body = this.parseBlock() node.handler = this.finishNode(clause, "CatchClause") } node.finalizer = this.eat(tt._finally) ? this.parseBlock() : null if (!node.handler && !node.finalizer) return node.block return this.finishNode(node, "TryStatement") case tt._var: case tt._const: return this.parseVar(false, kind || this.tok.value) case tt._while: this.next() node.test = this.parseParenExpression() node.body = this.parseStatement() return this.finishNode(node, "WhileStatement") case tt._with: this.next() node.object = this.parseParenExpression() node.body = this.parseStatement() return this.finishNode(node, "WithStatement") case tt.braceL: return this.parseBlock() case tt.semi: this.next() return this.finishNode(node, "EmptyStatement") case tt._class: return this.parseClass(true) case tt._import: return this.parseImport() case tt._export: return this.parseExport() default: if (this.toks.isAsyncFunction()) { this.next() this.next() return this.parseFunction(node, true, true) } let expr = this.parseExpression() if (isDummy(expr)) { this.next() if (this.tok.type === tt.eof) return this.finishNode(node, "EmptyStatement") return this.parseStatement() } else if (starttype === tt.name && expr.type === "Identifier" && this.eat(tt.colon)) { node.body = this.parseStatement() node.label = expr return this.finishNode(node, "LabeledStatement") } else { node.expression = expr this.semicolon() return this.finishNode(node, "ExpressionStatement") } } } lp.parseBlock = function() { let node = this.startNode() this.pushCx() this.expect(tt.braceL) let blockIndent = this.curIndent, line = this.curLineStart node.body = [] while (!this.closes(tt.braceR, blockIndent, line, true)) node.body.push(this.parseStatement()) this.popCx() this.eat(tt.braceR) return this.finishNode(node, "BlockStatement") } lp.parseFor = function(node, init) { node.init = init node.test = node.update = null if (this.eat(tt.semi) && this.tok.type !== tt.semi) node.test = this.parseExpression() if (this.eat(tt.semi) && this.tok.type !== tt.parenR) node.update = this.parseExpression() this.popCx() this.expect(tt.parenR) node.body = this.parseStatement() return this.finishNode(node, "ForStatement") } lp.parseForIn = function(node, init) { let type = this.tok.type === tt._in ? "ForInStatement" : "ForOfStatement" this.next() node.left = init node.right = this.parseExpression() this.popCx() this.expect(tt.parenR) node.body = this.parseStatement() return this.finishNode(node, type) } lp.parseVar = function(noIn, kind) { let node = this.startNode() node.kind = kind this.next() node.declarations = [] do { let decl = this.startNode() decl.id = this.options.ecmaVersion >= 6 ? this.toAssignable(this.parseExprAtom(), true) : this.parseIdent() decl.init = this.eat(tt.eq) ? this.parseMaybeAssign(noIn) : null node.declarations.push(this.finishNode(decl, "VariableDeclarator")) } while (this.eat(tt.comma)) if (!node.declarations.length) { let decl = this.startNode() decl.id = this.dummyIdent() node.declarations.push(this.finishNode(decl, "VariableDeclarator")) } if (!noIn) this.semicolon() return this.finishNode(node, "VariableDeclaration") } lp.parseClass = function(isStatement) { let node = this.startNode() this.next() if (this.tok.type === tt.name) node.id = this.parseIdent() else if (isStatement) node.id = this.dummyIdent() else node.id = null node.superClass = this.eat(tt._extends) ? this.parseExpression() : null node.body = this.startNode() node.body.body = [] this.pushCx() let indent = this.curIndent + 1, line = this.curLineStart this.eat(tt.braceL) if (this.curIndent + 1 < indent) { indent = this.curIndent; line = this.curLineStart } while (!this.closes(tt.braceR, indent, line)) { if (this.semicolon()) continue let method = this.startNode(), isGenerator, isAsync if (this.options.ecmaVersion >= 6) { method.static = false isGenerator = this.eat(tt.star) } this.parsePropertyName(method) if (isDummy(method.key)) { if (isDummy(this.parseMaybeAssign())) this.next(); this.eat(tt.comma); continue } if (method.key.type === "Identifier" && !method.computed && method.key.name === "static" && (this.tok.type != tt.parenL && this.tok.type != tt.braceL)) { method.static = true isGenerator = this.eat(tt.star) this.parsePropertyName(method) } else { method.static = false } if (!method.computed && method.key.type === "Identifier" && method.key.name === "async" && this.tok.type !== tt.parenL && !this.canInsertSemicolon()) { this.parsePropertyName(method) isAsync = true } else { isAsync = false } if (this.options.ecmaVersion >= 5 && method.key.type === "Identifier" && !method.computed && (method.key.name === "get" || method.key.name === "set") && this.tok.type !== tt.parenL && this.tok.type !== tt.braceL) { method.kind = method.key.name this.parsePropertyName(method) method.value = this.parseMethod(false) } else { if (!method.computed && !method.static && !isGenerator && !isAsync && ( method.key.type === "Identifier" && method.key.name === "constructor" || method.key.type === "Literal" && method.key.value === "constructor")) { method.kind = "constructor" } else { method.kind = "method" } method.value = this.parseMethod(isGenerator, isAsync) } node.body.body.push(this.finishNode(method, "MethodDefinition")) } this.popCx() if (!this.eat(tt.braceR)) { // If there is no closing brace, make the node span to the start // of the next token (this is useful for Tern) this.last.end = this.tok.start if (this.options.locations) this.last.loc.end = this.tok.loc.start } this.semicolon() this.finishNode(node.body, "ClassBody") return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression") } lp.parseFunction = function(node, isStatement, isAsync) { let oldInAsync = this.inAsync this.initFunction(node) if (this.options.ecmaVersion >= 6) { node.generator = this.eat(tt.star) } if (this.options.ecmaVersion >= 8) { node.async = !!isAsync } if (this.tok.type === tt.name) node.id = this.parseIdent() else if (isStatement) node.id = this.dummyIdent() this.inAsync = node.async node.params = this.parseFunctionParams() node.body = this.parseBlock() this.inAsync = oldInAsync return this.finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression") } lp.parseExport = function() { let node = this.startNode() this.next() if (this.eat(tt.star)) { node.source = this.eatContextual("from") ? this.parseExprAtom() : this.dummyString() return this.finishNode(node, "ExportAllDeclaration") } if (this.eat(tt._default)) { // export default (function foo() {}) // This is FunctionExpression. let isParenL = this.tok.type === tt.parenL let expr = this.parseMaybeAssign() if (!isParenL && expr.id) { switch (expr.type) { case "FunctionExpression": expr.type = "FunctionDeclaration"; break case "ClassExpression": expr.type = "ClassDeclaration"; break } } node.declaration = expr this.semicolon() return this.finishNode(node, "ExportDefaultDeclaration") } if (this.tok.type.keyword || this.toks.isLet() || this.toks.isAsyncFunction()) { node.declaration = this.parseStatement() node.specifiers = [] node.source = null } else { node.declaration = null node.specifiers = this.parseExportSpecifierList() node.source = this.eatContextual("from") ? this.parseExprAtom() : null this.semicolon() } return this.finishNode(node, "ExportNamedDeclaration") } lp.parseImport = function() { let node = this.startNode() this.next() if (this.tok.type === tt.string) { node.specifiers = [] node.source = this.parseExprAtom() node.kind = '' } else { let elt if (this.tok.type === tt.name && this.tok.value !== "from") { elt = this.startNode() elt.local = this.parseIdent() this.finishNode(elt, "ImportDefaultSpecifier") this.eat(tt.comma) } node.specifiers = this.parseImportSpecifierList() node.source = this.eatContextual("from") && this.tok.type == tt.string ? this.parseExprAtom() : this.dummyString() if (elt) node.specifiers.unshift(elt) } this.semicolon() return this.finishNode(node, "ImportDeclaration") } lp.parseImportSpecifierList = function() { let elts = [] if (this.tok.type === tt.star) { let elt = this.startNode() this.next() elt.local = this.eatContextual("as") ? this.parseIdent() : this.dummyIdent() elts.push(this.finishNode(elt, "ImportNamespaceSpecifier")) } else { let indent = this.curIndent, line = this.curLineStart, continuedLine = this.nextLineStart this.pushCx() this.eat(tt.braceL) if (this.curLineStart > continuedLine) continuedLine = this.curLineStart while (!this.closes(tt.braceR, indent + (this.curLineStart <= continuedLine ? 1 : 0), line)) { let elt = this.startNode() if (this.eat(tt.star)) { elt.local = this.eatContextual("as") ? this.parseIdent() : this.dummyIdent() this.finishNode(elt, "ImportNamespaceSpecifier") } else { if (this.isContextual("from")) break elt.imported = this.parseIdent() if (isDummy(elt.imported)) break elt.local = this.eatContextual("as") ? this.parseIdent() : elt.imported this.finishNode(elt, "ImportSpecifier") } elts.push(elt) this.eat(tt.comma) } this.eat(tt.braceR) this.popCx() } return elts } lp.parseExportSpecifierList = function() { let elts = [] let indent = this.curIndent, line = this.curLineStart, continuedLine = this.nextLineStart this.pushCx() this.eat(tt.braceL) if (this.curLineStart > continuedLine) continuedLine = this.curLineStart while (!this.closes(tt.braceR, indent + (this.curLineStart <= continuedLine ? 1 : 0), line)) { if (this.isContextual("from")) break let elt = this.startNode() elt.local = this.parseIdent() if (isDummy(elt.local)) break elt.exported = this.eatContextual("as") ? this.parseIdent() : elt.local this.finishNode(elt, "ExportSpecifier") elts.push(elt) this.eat(tt.comma) } this.eat(tt.braceR) this.popCx() return elts } acorn-4.0.4/src/loose/tokenize.js000066400000000000000000000071371302576755300167440ustar00rootroot00000000000000import {tokTypes as tt, Token, isNewLine, SourceLocation, getLineInfo, lineBreakG} from "../index" import {LooseParser} from "./state" const lp = LooseParser.prototype function isSpace(ch) { return (ch < 14 && ch > 8) || ch === 32 || ch === 160 || isNewLine(ch) } lp.next = function() { this.last = this.tok if (this.ahead.length) this.tok = this.ahead.shift() else this.tok = this.readToken() if (this.tok.start >= this.nextLineStart) { while (this.tok.start >= this.nextLineStart) { this.curLineStart = this.nextLineStart this.nextLineStart = this.lineEnd(this.curLineStart) + 1 } this.curIndent = this.indentationAfter(this.curLineStart) } } lp.readToken = function() { for (;;) { try { this.toks.next() if (this.toks.type === tt.dot && this.input.substr(this.toks.end, 1) === "." && this.options.ecmaVersion >= 6) { this.toks.end++ this.toks.type = tt.ellipsis } return new Token(this.toks) } catch(e) { if (!(e instanceof SyntaxError)) throw e // Try to skip some text, based on the error message, and then continue let msg = e.message, pos = e.raisedAt, replace = true if (/unterminated/i.test(msg)) { pos = this.lineEnd(e.pos + 1) if (/string/.test(msg)) { replace = {start: e.pos, end: pos, type: tt.string, value: this.input.slice(e.pos + 1, pos)} } else if (/regular expr/i.test(msg)) { let re = this.input.slice(e.pos, pos) try { re = new RegExp(re) } catch(e) {} replace = {start: e.pos, end: pos, type: tt.regexp, value: re} } else if (/template/.test(msg)) { replace = {start: e.pos, end: pos, type: tt.template, value: this.input.slice(e.pos, pos)} } else { replace = false } } else if (/invalid (unicode|regexp|number)|expecting unicode|octal literal|is reserved|directly after number|expected number in radix/i.test(msg)) { while (pos < this.input.length && !isSpace(this.input.charCodeAt(pos))) ++pos } else if (/character escape|expected hexadecimal/i.test(msg)) { while (pos < this.input.length) { let ch = this.input.charCodeAt(pos++) if (ch === 34 || ch === 39 || isNewLine(ch)) break } } else if (/unexpected character/i.test(msg)) { pos++ replace = false } else if (/regular expression/i.test(msg)) { replace = true } else { throw e } this.resetTo(pos) if (replace === true) replace = {start: pos, end: pos, type: tt.name, value: "✖"} if (replace) { if (this.options.locations) replace.loc = new SourceLocation( this.toks, getLineInfo(this.input, replace.start), getLineInfo(this.input, replace.end)) return replace } } } } lp.resetTo = function(pos) { this.toks.pos = pos let ch = this.input.charAt(pos - 1) this.toks.exprAllowed = !ch || /[\[\{\(,;:?\/*=+\-~!|&%^<>]/.test(ch) || /[enwfd]/.test(ch) && /\b(keywords|case|else|return|throw|new|in|(instance|type)of|delete|void)$/.test(this.input.slice(pos - 10, pos)) if (this.options.locations) { this.toks.curLine = 1 this.toks.lineStart = lineBreakG.lastIndex = 0 let match while ((match = lineBreakG.exec(this.input)) && match.index < pos) { ++this.toks.curLine this.toks.lineStart = match.index + match[0].length } } } lp.lookAhead = function(n) { while (n > this.ahead.length) this.ahead.push(this.readToken()) return this.ahead[n - 1] } acorn-4.0.4/src/lval.js000066400000000000000000000144011302576755300147210ustar00rootroot00000000000000import {types as tt} from "./tokentype" import {Parser} from "./state" import {has} from "./util" const pp = Parser.prototype // Convert existing expression atom to assignable pattern // if possible. pp.toAssignable = function(node, isBinding) { if (this.options.ecmaVersion >= 6 && node) { switch (node.type) { case "Identifier": if (this.inAsync && node.name === "await") this.raise(node.start, "Can not use 'await' as identifier inside an async function") break case "ObjectPattern": case "ArrayPattern": break case "ObjectExpression": node.type = "ObjectPattern" for (let i = 0; i < node.properties.length; i++) { let prop = node.properties[i] if (prop.kind !== "init") this.raise(prop.key.start, "Object pattern can't contain getter or setter") this.toAssignable(prop.value, isBinding) } break case "ArrayExpression": node.type = "ArrayPattern" this.toAssignableList(node.elements, isBinding) break case "AssignmentExpression": if (node.operator === "=") { node.type = "AssignmentPattern" delete node.operator this.toAssignable(node.left, isBinding) // falls through to AssignmentPattern } else { this.raise(node.left.end, "Only '=' operator can be used for specifying default value.") break } case "AssignmentPattern": break case "ParenthesizedExpression": node.expression = this.toAssignable(node.expression, isBinding) break case "MemberExpression": if (!isBinding) break default: this.raise(node.start, "Assigning to rvalue") } } return node } // Convert list of expression atoms to binding list. pp.toAssignableList = function(exprList, isBinding) { let end = exprList.length if (end) { let last = exprList[end - 1] if (last && last.type == "RestElement") { --end } else if (last && last.type == "SpreadElement") { last.type = "RestElement" let arg = last.argument this.toAssignable(arg, isBinding) if (arg.type !== "Identifier" && arg.type !== "MemberExpression" && arg.type !== "ArrayPattern") this.unexpected(arg.start) --end } if (isBinding && last && last.type === "RestElement" && last.argument.type !== "Identifier") this.unexpected(last.argument.start) } for (let i = 0; i < end; i++) { let elt = exprList[i] if (elt) this.toAssignable(elt, isBinding) } return exprList } // Parses spread element. pp.parseSpread = function(refDestructuringErrors) { let node = this.startNode() this.next() node.argument = this.parseMaybeAssign(false, refDestructuringErrors) return this.finishNode(node, "SpreadElement") } pp.parseRest = function(allowNonIdent) { let node = this.startNode() this.next() // RestElement inside of a function parameter must be an identifier if (allowNonIdent) node.argument = this.type === tt.name ? this.parseIdent() : this.unexpected() else node.argument = this.type === tt.name || this.type === tt.bracketL ? this.parseBindingAtom() : this.unexpected() return this.finishNode(node, "RestElement") } // Parses lvalue (assignable) atom. pp.parseBindingAtom = function() { if (this.options.ecmaVersion < 6) return this.parseIdent() switch (this.type) { case tt.name: return this.parseIdent() case tt.bracketL: let node = this.startNode() this.next() node.elements = this.parseBindingList(tt.bracketR, true, true) return this.finishNode(node, "ArrayPattern") case tt.braceL: return this.parseObj(true) default: this.unexpected() } } pp.parseBindingList = function(close, allowEmpty, allowTrailingComma, allowNonIdent) { let elts = [], first = true while (!this.eat(close)) { if (first) first = false else this.expect(tt.comma) if (allowEmpty && this.type === tt.comma) { elts.push(null) } else if (allowTrailingComma && this.afterTrailingComma(close)) { break } else if (this.type === tt.ellipsis) { let rest = this.parseRest(allowNonIdent) this.parseBindingListItem(rest) elts.push(rest) if (this.type === tt.comma) this.raise(this.start, "Comma is not permitted after the rest element") this.expect(close) break } else { let elem = this.parseMaybeDefault(this.start, this.startLoc) this.parseBindingListItem(elem) elts.push(elem) } } return elts } pp.parseBindingListItem = function(param) { return param } // Parses assignment pattern around given atom if possible. pp.parseMaybeDefault = function(startPos, startLoc, left) { left = left || this.parseBindingAtom() if (this.options.ecmaVersion < 6 || !this.eat(tt.eq)) return left let node = this.startNodeAt(startPos, startLoc) node.left = left node.right = this.parseMaybeAssign() return this.finishNode(node, "AssignmentPattern") } // Verify that a node is an lval — something that can be assigned // to. pp.checkLVal = function(expr, isBinding, checkClashes) { switch (expr.type) { case "Identifier": if (this.strict && this.reservedWordsStrictBind.test(expr.name)) this.raiseRecoverable(expr.start, (isBinding ? "Binding " : "Assigning to ") + expr.name + " in strict mode") if (checkClashes) { if (has(checkClashes, expr.name)) this.raiseRecoverable(expr.start, "Argument name clash") checkClashes[expr.name] = true } break case "MemberExpression": if (isBinding) this.raiseRecoverable(expr.start, (isBinding ? "Binding" : "Assigning to") + " member expression") break case "ObjectPattern": for (let i = 0; i < expr.properties.length; i++) this.checkLVal(expr.properties[i].value, isBinding, checkClashes) break case "ArrayPattern": for (let i = 0; i < expr.elements.length; i++) { let elem = expr.elements[i] if (elem) this.checkLVal(elem, isBinding, checkClashes) } break case "AssignmentPattern": this.checkLVal(expr.left, isBinding, checkClashes) break case "RestElement": this.checkLVal(expr.argument, isBinding, checkClashes) break case "ParenthesizedExpression": this.checkLVal(expr.expression, isBinding, checkClashes) break default: this.raise(expr.start, (isBinding ? "Binding" : "Assigning to") + " rvalue") } } acorn-4.0.4/src/node.js000066400000000000000000000022521302576755300147110ustar00rootroot00000000000000import {Parser} from "./state" import {SourceLocation} from "./locutil" export class Node { constructor(parser, pos, loc) { this.type = "" this.start = pos this.end = 0 if (parser.options.locations) this.loc = new SourceLocation(parser, loc) if (parser.options.directSourceFile) this.sourceFile = parser.options.directSourceFile if (parser.options.ranges) this.range = [pos, 0] } } // Start an AST node, attaching a start offset. const pp = Parser.prototype pp.startNode = function() { return new Node(this, this.start, this.startLoc) } pp.startNodeAt = function(pos, loc) { return new Node(this, pos, loc) } // Finish an AST node, adding `type` and `end` properties. function finishNodeAt(node, type, pos, loc) { node.type = type node.end = pos if (this.options.locations) node.loc.end = loc if (this.options.ranges) node.range[1] = pos return node } pp.finishNode = function(node, type) { return finishNodeAt.call(this, node, type, this.lastTokEnd, this.lastTokEndLoc) } // Finish node at given position pp.finishNodeAt = function(node, type, pos, loc) { return finishNodeAt.call(this, node, type, pos, loc) } acorn-4.0.4/src/options.js000066400000000000000000000121741302576755300154630ustar00rootroot00000000000000import {has, isArray} from "./util" import {SourceLocation} from "./locutil" // A second optional argument can be given to further configure // the parser process. These options are recognized: export const defaultOptions = { // `ecmaVersion` indicates the ECMAScript version to parse. Must // be either 3, 5, 6 (2015), 7 (2016), or 8 (2017). This influences support // for strict mode, the set of reserved words, and support for // new syntax features. The default is 7. ecmaVersion: 7, // `sourceType` indicates the mode the code should be parsed in. // Can be either `"script"` or `"module"`. This influences global // strict mode and parsing of `import` and `export` declarations. sourceType: "script", // `onInsertedSemicolon` can be a callback that will be called // when a semicolon is automatically inserted. It will be passed // th position of the comma as an offset, and if `locations` is // enabled, it is given the location as a `{line, column}` object // as second argument. onInsertedSemicolon: null, // `onTrailingComma` is similar to `onInsertedSemicolon`, but for // trailing commas. onTrailingComma: null, // By default, reserved words are only enforced if ecmaVersion >= 5. // Set `allowReserved` to a boolean value to explicitly turn this on // an off. When this option has the value "never", reserved words // and keywords can also not be used as property names. allowReserved: null, // When enabled, a return at the top level is not considered an // error. allowReturnOutsideFunction: false, // When enabled, import/export statements are not constrained to // appearing at the top of the program. allowImportExportEverywhere: false, // When enabled, hashbang directive in the beginning of file // is allowed and treated as a line comment. allowHashBang: false, // When `locations` is on, `loc` properties holding objects with // `start` and `end` properties in `{line, column}` form (with // line being 1-based and column 0-based) will be attached to the // nodes. locations: false, // A function can be passed as `onToken` option, which will // cause Acorn to call that function with object in the same // format as tokens returned from `tokenizer().getToken()`. Note // that you are not allowed to call the parser from the // callback—that will corrupt its internal state. onToken: null, // A function can be passed as `onComment` option, which will // cause Acorn to call that function with `(block, text, start, // end)` parameters whenever a comment is skipped. `block` is a // boolean indicating whether this is a block (`/* */`) comment, // `text` is the content of the comment, and `start` and `end` are // character offsets that denote the start and end of the comment. // When the `locations` option is on, two more parameters are // passed, the full `{line, column}` locations of the start and // end of the comments. Note that you are not allowed to call the // parser from the callback—that will corrupt its internal state. onComment: null, // Nodes have their start and end characters offsets recorded in // `start` and `end` properties (directly on the node, rather than // the `loc` object, which holds line/column data. To also add a // [semi-standardized][range] `range` property holding a `[start, // end]` array with the same numbers, set the `ranges` option to // `true`. // // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678 ranges: false, // It is possible to parse multiple files into a single AST by // passing the tree produced by parsing the first file as // `program` option in subsequent parses. This will add the // toplevel forms of the parsed file to the `Program` (top) node // of an existing parse tree. program: null, // When `locations` is on, you can pass this to record the source // file in every node's `loc` object. sourceFile: null, // This value, if given, is stored in every node, whether // `locations` is on or off. directSourceFile: null, // When enabled, parenthesized expressions are represented by // (non-standard) ParenthesizedExpression nodes preserveParens: false, plugins: {} } // Interpret and default an options object export function getOptions(opts) { let options = {} for (let opt in defaultOptions) options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions[opt] if (options.ecmaVersion >= 2015) options.ecmaVersion -= 2009 if (options.allowReserved == null) options.allowReserved = options.ecmaVersion < 5 if (isArray(options.onToken)) { let tokens = options.onToken options.onToken = (token) => tokens.push(token) } if (isArray(options.onComment)) options.onComment = pushComment(options, options.onComment) return options } function pushComment(options, array) { return function (block, text, start, end, startLoc, endLoc) { let comment = { type: block ? 'Block' : 'Line', value: text, start: start, end: end } if (options.locations) comment.loc = new SourceLocation(this, startLoc, endLoc) if (options.ranges) comment.range = [start, end] array.push(comment) } } acorn-4.0.4/src/parseutil.js000066400000000000000000000064111302576755300157750ustar00rootroot00000000000000import {types as tt} from "./tokentype" import {Parser} from "./state" import {lineBreak} from "./whitespace" const pp = Parser.prototype // ## Parser utilities // Test whether a statement node is the string literal `"use strict"`. pp.isUseStrict = function(stmt) { return this.options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" && stmt.expression.type === "Literal" && stmt.expression.raw.slice(1, -1) === "use strict" } // Predicate that tests whether the next token is of the given // type, and if yes, consumes it as a side effect. pp.eat = function(type) { if (this.type === type) { this.next() return true } else { return false } } // Tests whether parsed token is a contextual keyword. pp.isContextual = function(name) { return this.type === tt.name && this.value === name } // Consumes contextual keyword if possible. pp.eatContextual = function(name) { return this.value === name && this.eat(tt.name) } // Asserts that following token is given contextual keyword. pp.expectContextual = function(name) { if (!this.eatContextual(name)) this.unexpected() } // Test whether a semicolon can be inserted at the current position. pp.canInsertSemicolon = function() { return this.type === tt.eof || this.type === tt.braceR || lineBreak.test(this.input.slice(this.lastTokEnd, this.start)) } pp.insertSemicolon = function() { if (this.canInsertSemicolon()) { if (this.options.onInsertedSemicolon) this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc) return true } } // Consume a semicolon, or, failing that, see if we are allowed to // pretend that there is a semicolon at this position. pp.semicolon = function() { if (!this.eat(tt.semi) && !this.insertSemicolon()) this.unexpected() } pp.afterTrailingComma = function(tokType, notNext) { if (this.type == tokType) { if (this.options.onTrailingComma) this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc) if (!notNext) this.next() return true } } // Expect a token of a given type. If found, consume it, otherwise, // raise an unexpected token error. pp.expect = function(type) { this.eat(type) || this.unexpected() } // Raise an unexpected token error. pp.unexpected = function(pos) { this.raise(pos != null ? pos : this.start, "Unexpected token") } export class DestructuringErrors { constructor() { this.shorthandAssign = 0 this.trailingComma = 0 } } pp.checkPatternErrors = function(refDestructuringErrors, andThrow) { let trailing = refDestructuringErrors && refDestructuringErrors.trailingComma if (!andThrow) return !!trailing if (trailing) this.raise(trailing, "Comma is not permitted after the rest element") } pp.checkExpressionErrors = function(refDestructuringErrors, andThrow) { let pos = refDestructuringErrors && refDestructuringErrors.shorthandAssign if (!andThrow) return !!pos if (pos) this.raise(pos, "Shorthand property assignments are valid only in destructuring patterns") } pp.checkYieldAwaitInDefaultParams = function() { if (this.yieldPos && (!this.awaitPos || this.yieldPos < this.awaitPos)) this.raise(this.yieldPos, "Yield expression cannot be a default value") if (this.awaitPos) this.raise(this.awaitPos, "Await expression cannot be a default value") } acorn-4.0.4/src/state.js000066400000000000000000000073561302576755300151160ustar00rootroot00000000000000import {reservedWords, keywords} from "./identifier" import {types as tt} from "./tokentype" import {lineBreak} from "./whitespace" import {getOptions} from "./options" // Registered plugins export const plugins = {} function keywordRegexp(words) { return new RegExp("^(" + words.replace(/ /g, "|") + ")$") } export class Parser { constructor(options, input, startPos) { this.options = options = getOptions(options) this.sourceFile = options.sourceFile this.keywords = keywordRegexp(keywords[options.ecmaVersion >= 6 ? 6 : 5]) let reserved = "" if (!options.allowReserved) { for (let v = options.ecmaVersion;; v--) if (reserved = reservedWords[v]) break if (options.sourceType == "module") reserved += " await" } this.reservedWords = keywordRegexp(reserved) let reservedStrict = (reserved ? reserved + " " : "") + reservedWords.strict this.reservedWordsStrict = keywordRegexp(reservedStrict) this.reservedWordsStrictBind = keywordRegexp(reservedStrict + " " + reservedWords.strictBind) this.input = String(input) // Used to signal to callers of `readWord1` whether the word // contained any escape sequences. This is needed because words with // escape sequences must not be interpreted as keywords. this.containsEsc = false // Load plugins this.loadPlugins(options.plugins) // Set up token state // The current position of the tokenizer in the input. if (startPos) { this.pos = startPos this.lineStart = this.input.lastIndexOf("\n", startPos - 1) + 1 this.curLine = this.input.slice(0, this.lineStart).split(lineBreak).length } else { this.pos = this.lineStart = 0 this.curLine = 1 } // Properties of the current token: // Its type this.type = tt.eof // For tokens that include more information than their type, the value this.value = null // Its start and end offset this.start = this.end = this.pos // And, if locations are used, the {line, column} object // corresponding to those offsets this.startLoc = this.endLoc = this.curPosition() // Position information for the previous token this.lastTokEndLoc = this.lastTokStartLoc = null this.lastTokStart = this.lastTokEnd = this.pos // The context stack is used to superficially track syntactic // context to predict whether a regular expression is allowed in a // given position. this.context = this.initialContext() this.exprAllowed = true // Figure out if it's a module code. this.strict = this.inModule = options.sourceType === "module" // Used to signify the start of a potential arrow function this.potentialArrowAt = -1 // Flags to track whether we are in a function, a generator, an async function. this.inFunction = this.inGenerator = this.inAsync = false // Positions to delayed-check that yield/await does not exist in default parameters. this.yieldPos = this.awaitPos = 0 // Labels in scope. this.labels = [] // If enabled, skip leading hashbang line. if (this.pos === 0 && options.allowHashBang && this.input.slice(0, 2) === '#!') this.skipLineComment(2) } // DEPRECATED Kept for backwards compatibility until 3.0 in case a plugin uses them isKeyword(word) { return this.keywords.test(word) } isReservedWord(word) { return this.reservedWords.test(word) } extend(name, f) { this[name] = f(this[name]) } loadPlugins(pluginConfigs) { for (let name in pluginConfigs) { let plugin = plugins[name] if (!plugin) throw new Error("Plugin '" + name + "' not found") plugin(this, pluginConfigs[name]) } } parse() { let node = this.options.program || this.startNode() this.nextToken() return this.parseTopLevel(node) } } acorn-4.0.4/src/statement.js000066400000000000000000000625621302576755300160020ustar00rootroot00000000000000import {types as tt} from "./tokentype" import {Parser} from "./state" import {lineBreak, skipWhiteSpace} from "./whitespace" import {isIdentifierStart, isIdentifierChar} from "./identifier" import {DestructuringErrors} from "./parseutil" const pp = Parser.prototype // ### Statement parsing // Parse a program. Initializes the parser, reads any number of // statements, and wraps them in a Program node. Optionally takes a // `program` argument. If present, the statements will be appended // to its body instead of creating a new node. pp.parseTopLevel = function(node) { let first = true, exports = {} if (!node.body) node.body = [] while (this.type !== tt.eof) { let stmt = this.parseStatement(true, true, exports) node.body.push(stmt) if (first) { if (this.isUseStrict(stmt)) this.setStrict(true) first = false } } this.next() if (this.options.ecmaVersion >= 6) { node.sourceType = this.options.sourceType } return this.finishNode(node, "Program") } const loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"} pp.isLet = function() { if (this.type !== tt.name || this.options.ecmaVersion < 6 || this.value != "let") return false skipWhiteSpace.lastIndex = this.pos let skip = skipWhiteSpace.exec(this.input) let next = this.pos + skip[0].length, nextCh = this.input.charCodeAt(next) if (nextCh === 91 || nextCh == 123) return true // '{' and '[' if (isIdentifierStart(nextCh, true)) { for (var pos = next + 1; isIdentifierChar(this.input.charCodeAt(pos), true); ++pos) {} let ident = this.input.slice(next, pos) if (!this.isKeyword(ident)) return true } return false } // check 'async [no LineTerminator here] function' // - 'async /*foo*/ function' is OK. // - 'async /*\n*/ function' is invalid. pp.isAsyncFunction = function() { if (this.type !== tt.name || this.options.ecmaVersion < 8 || this.value != "async") return false skipWhiteSpace.lastIndex = this.pos let skip = skipWhiteSpace.exec(this.input) let next = this.pos + skip[0].length return !lineBreak.test(this.input.slice(this.pos, next)) && this.input.slice(next, next + 8) === "function" && (next + 8 == this.input.length || !isIdentifierChar(this.input.charAt(next + 8))) } // Parse a single statement. // // If expecting a statement and finding a slash operator, parse a // regular expression literal. This is to handle cases like // `if (foo) /blah/.exec(foo)`, where looking at the previous token // does not help. pp.parseStatement = function(declaration, topLevel, exports) { let starttype = this.type, node = this.startNode(), kind if (this.isLet()) { starttype = tt._var kind = "let" } // Most types of statements are recognized by the keyword they // start with. Many are trivial to parse, some require a bit of // complexity. switch (starttype) { case tt._break: case tt._continue: return this.parseBreakContinueStatement(node, starttype.keyword) case tt._debugger: return this.parseDebuggerStatement(node) case tt._do: return this.parseDoStatement(node) case tt._for: return this.parseForStatement(node) case tt._function: if (!declaration && this.options.ecmaVersion >= 6) this.unexpected() return this.parseFunctionStatement(node, false) case tt._class: if (!declaration) this.unexpected() return this.parseClass(node, true) case tt._if: return this.parseIfStatement(node) case tt._return: return this.parseReturnStatement(node) case tt._switch: return this.parseSwitchStatement(node) case tt._throw: return this.parseThrowStatement(node) case tt._try: return this.parseTryStatement(node) case tt._const: case tt._var: kind = kind || this.value if (!declaration && kind != "var") this.unexpected() return this.parseVarStatement(node, kind) case tt._while: return this.parseWhileStatement(node) case tt._with: return this.parseWithStatement(node) case tt.braceL: return this.parseBlock() case tt.semi: return this.parseEmptyStatement(node) case tt._export: case tt._import: if (!this.options.allowImportExportEverywhere) { if (!topLevel) this.raise(this.start, "'import' and 'export' may only appear at the top level") if (!this.inModule) this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'") } return starttype === tt._import ? this.parseImport(node) : this.parseExport(node, exports) // If the statement does not start with a statement keyword or a // brace, it's an ExpressionStatement or LabeledStatement. We // simply start parsing an expression, and afterwards, if the // next token is a colon and the expression was a simple // Identifier node, we switch to interpreting it as a label. default: if (this.isAsyncFunction() && declaration) { this.next() return this.parseFunctionStatement(node, true) } let maybeName = this.value, expr = this.parseExpression() if (starttype === tt.name && expr.type === "Identifier" && this.eat(tt.colon)) return this.parseLabeledStatement(node, maybeName, expr) else return this.parseExpressionStatement(node, expr) } } pp.parseBreakContinueStatement = function(node, keyword) { let isBreak = keyword == "break" this.next() if (this.eat(tt.semi) || this.insertSemicolon()) node.label = null else if (this.type !== tt.name) this.unexpected() else { node.label = this.parseIdent() this.semicolon() } // Verify that there is an actual destination to break or // continue to. for (var i = 0; i < this.labels.length; ++i) { let lab = this.labels[i] if (node.label == null || lab.name === node.label.name) { if (lab.kind != null && (isBreak || lab.kind === "loop")) break if (node.label && isBreak) break } } if (i === this.labels.length) this.raise(node.start, "Unsyntactic " + keyword) return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement") } pp.parseDebuggerStatement = function(node) { this.next() this.semicolon() return this.finishNode(node, "DebuggerStatement") } pp.parseDoStatement = function(node) { this.next() this.labels.push(loopLabel) node.body = this.parseStatement(false) this.labels.pop() this.expect(tt._while) node.test = this.parseParenExpression() if (this.options.ecmaVersion >= 6) this.eat(tt.semi) else this.semicolon() return this.finishNode(node, "DoWhileStatement") } // Disambiguating between a `for` and a `for`/`in` or `for`/`of` // loop is non-trivial. Basically, we have to parse the init `var` // statement or expression, disallowing the `in` operator (see // the second parameter to `parseExpression`), and then check // whether the next token is `in` or `of`. When there is no init // part (semicolon immediately after the opening parenthesis), it // is a regular `for` loop. pp.parseForStatement = function(node) { this.next() this.labels.push(loopLabel) this.expect(tt.parenL) if (this.type === tt.semi) return this.parseFor(node, null) let isLet = this.isLet() if (this.type === tt._var || this.type === tt._const || isLet) { let init = this.startNode(), kind = isLet ? "let" : this.value this.next() this.parseVar(init, true, kind) this.finishNode(init, "VariableDeclaration") if ((this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) && init.declarations.length === 1 && !(kind !== "var" && init.declarations[0].init)) return this.parseForIn(node, init) return this.parseFor(node, init) } let refDestructuringErrors = new DestructuringErrors let init = this.parseExpression(true, refDestructuringErrors) if (this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) { this.checkPatternErrors(refDestructuringErrors, true) this.toAssignable(init) this.checkLVal(init) return this.parseForIn(node, init) } else { this.checkExpressionErrors(refDestructuringErrors, true) } return this.parseFor(node, init) } pp.parseFunctionStatement = function(node, isAsync) { this.next() return this.parseFunction(node, true, false, isAsync) } pp.isFunction = function() { return this.type === tt._function || this.isAsyncFunction() } pp.parseIfStatement = function(node) { this.next() node.test = this.parseParenExpression() // allow function declarations in branches, but only in non-strict mode node.consequent = this.parseStatement(!this.strict && this.isFunction()) node.alternate = this.eat(tt._else) ? this.parseStatement(!this.strict && this.isFunction()) : null return this.finishNode(node, "IfStatement") } pp.parseReturnStatement = function(node) { if (!this.inFunction && !this.options.allowReturnOutsideFunction) this.raise(this.start, "'return' outside of function") this.next() // In `return` (and `break`/`continue`), the keywords with // optional arguments, we eagerly look for a semicolon or the // possibility to insert one. if (this.eat(tt.semi) || this.insertSemicolon()) node.argument = null else { node.argument = this.parseExpression(); this.semicolon() } return this.finishNode(node, "ReturnStatement") } pp.parseSwitchStatement = function(node) { this.next() node.discriminant = this.parseParenExpression() node.cases = [] this.expect(tt.braceL) this.labels.push(switchLabel) // Statements under must be grouped (by label) in SwitchCase // nodes. `cur` is used to keep the node that we are currently // adding statements to. for (var cur, sawDefault = false; this.type != tt.braceR;) { if (this.type === tt._case || this.type === tt._default) { let isCase = this.type === tt._case if (cur) this.finishNode(cur, "SwitchCase") node.cases.push(cur = this.startNode()) cur.consequent = [] this.next() if (isCase) { cur.test = this.parseExpression() } else { if (sawDefault) this.raiseRecoverable(this.lastTokStart, "Multiple default clauses") sawDefault = true cur.test = null } this.expect(tt.colon) } else { if (!cur) this.unexpected() cur.consequent.push(this.parseStatement(true)) } } if (cur) this.finishNode(cur, "SwitchCase") this.next() // Closing brace this.labels.pop() return this.finishNode(node, "SwitchStatement") } pp.parseThrowStatement = function(node) { this.next() if (lineBreak.test(this.input.slice(this.lastTokEnd, this.start))) this.raise(this.lastTokEnd, "Illegal newline after throw") node.argument = this.parseExpression() this.semicolon() return this.finishNode(node, "ThrowStatement") } // Reused empty array added for node fields that are always empty. const empty = [] pp.parseTryStatement = function(node) { this.next() node.block = this.parseBlock() node.handler = null if (this.type === tt._catch) { let clause = this.startNode() this.next() this.expect(tt.parenL) clause.param = this.parseBindingAtom() this.checkLVal(clause.param, true) this.expect(tt.parenR) clause.body = this.parseBlock() node.handler = this.finishNode(clause, "CatchClause") } node.finalizer = this.eat(tt._finally) ? this.parseBlock() : null if (!node.handler && !node.finalizer) this.raise(node.start, "Missing catch or finally clause") return this.finishNode(node, "TryStatement") } pp.parseVarStatement = function(node, kind) { this.next() this.parseVar(node, false, kind) this.semicolon() return this.finishNode(node, "VariableDeclaration") } pp.parseWhileStatement = function(node) { this.next() node.test = this.parseParenExpression() this.labels.push(loopLabel) node.body = this.parseStatement(false) this.labels.pop() return this.finishNode(node, "WhileStatement") } pp.parseWithStatement = function(node) { if (this.strict) this.raise(this.start, "'with' in strict mode") this.next() node.object = this.parseParenExpression() node.body = this.parseStatement(false) return this.finishNode(node, "WithStatement") } pp.parseEmptyStatement = function(node) { this.next() return this.finishNode(node, "EmptyStatement") } pp.parseLabeledStatement = function(node, maybeName, expr) { for (let i = 0; i < this.labels.length; ++i) if (this.labels[i].name === maybeName) this.raise(expr.start, "Label '" + maybeName + "' is already declared") let kind = this.type.isLoop ? "loop" : this.type === tt._switch ? "switch" : null for (let i = this.labels.length - 1; i >= 0; i--) { let label = this.labels[i] if (label.statementStart == node.start) { label.statementStart = this.start label.kind = kind } else break } this.labels.push({name: maybeName, kind: kind, statementStart: this.start}) node.body = this.parseStatement(true) this.labels.pop() node.label = expr return this.finishNode(node, "LabeledStatement") } pp.parseExpressionStatement = function(node, expr) { node.expression = expr this.semicolon() return this.finishNode(node, "ExpressionStatement") } // Parse a semicolon-enclosed block of statements, handling `"use // strict"` declarations when `allowStrict` is true (used for // function bodies). pp.parseBlock = function(allowStrict) { let node = this.startNode(), first = true, oldStrict node.body = [] this.expect(tt.braceL) while (!this.eat(tt.braceR)) { let stmt = this.parseStatement(true) node.body.push(stmt) if (first && allowStrict && this.isUseStrict(stmt)) { oldStrict = this.strict this.setStrict(this.strict = true) } first = false } if (oldStrict === false) this.setStrict(false) return this.finishNode(node, "BlockStatement") } // Parse a regular `for` loop. The disambiguation code in // `parseStatement` will already have parsed the init statement or // expression. pp.parseFor = function(node, init) { node.init = init this.expect(tt.semi) node.test = this.type === tt.semi ? null : this.parseExpression() this.expect(tt.semi) node.update = this.type === tt.parenR ? null : this.parseExpression() this.expect(tt.parenR) node.body = this.parseStatement(false) this.labels.pop() return this.finishNode(node, "ForStatement") } // Parse a `for`/`in` and `for`/`of` loop, which are almost // same from parser's perspective. pp.parseForIn = function(node, init) { let type = this.type === tt._in ? "ForInStatement" : "ForOfStatement" this.next() node.left = init node.right = this.parseExpression() this.expect(tt.parenR) node.body = this.parseStatement(false) this.labels.pop() return this.finishNode(node, type) } // Parse a list of variable declarations. pp.parseVar = function(node, isFor, kind) { node.declarations = [] node.kind = kind for (;;) { let decl = this.startNode() this.parseVarId(decl) if (this.eat(tt.eq)) { decl.init = this.parseMaybeAssign(isFor) } else if (kind === "const" && !(this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of")))) { this.unexpected() } else if (decl.id.type != "Identifier" && !(isFor && (this.type === tt._in || this.isContextual("of")))) { this.raise(this.lastTokEnd, "Complex binding patterns require an initialization value") } else { decl.init = null } node.declarations.push(this.finishNode(decl, "VariableDeclarator")) if (!this.eat(tt.comma)) break } return node } pp.parseVarId = function(decl) { decl.id = this.parseBindingAtom() this.checkLVal(decl.id, true) } // Parse a function declaration or literal (depending on the // `isStatement` parameter). pp.parseFunction = function(node, isStatement, allowExpressionBody, isAsync) { this.initFunction(node) if (this.options.ecmaVersion >= 6 && !isAsync) node.generator = this.eat(tt.star) if (this.options.ecmaVersion >= 8) node.async = !!isAsync if (isStatement) node.id = this.parseIdent() let oldInGen = this.inGenerator, oldInAsync = this.inAsync, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos this.inGenerator = node.generator this.inAsync = node.async this.yieldPos = 0 this.awaitPos = 0 if (!isStatement && this.type === tt.name) node.id = this.parseIdent() this.parseFunctionParams(node) this.parseFunctionBody(node, allowExpressionBody) this.inGenerator = oldInGen this.inAsync = oldInAsync this.yieldPos = oldYieldPos this.awaitPos = oldAwaitPos return this.finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression") } pp.parseFunctionParams = function(node) { this.expect(tt.parenL) node.params = this.parseBindingList(tt.parenR, false, this.options.ecmaVersion >= 8, true) this.checkYieldAwaitInDefaultParams() } // Parse a class declaration or literal (depending on the // `isStatement` parameter). pp.parseClass = function(node, isStatement) { this.next() this.parseClassId(node, isStatement) this.parseClassSuper(node) let classBody = this.startNode() let hadConstructor = false classBody.body = [] this.expect(tt.braceL) while (!this.eat(tt.braceR)) { if (this.eat(tt.semi)) continue let method = this.startNode() let isGenerator = this.eat(tt.star) let isAsync = false let isMaybeStatic = this.type === tt.name && this.value === "static" this.parsePropertyName(method) method.static = isMaybeStatic && this.type !== tt.parenL if (method.static) { if (isGenerator) this.unexpected() isGenerator = this.eat(tt.star) this.parsePropertyName(method) } if (this.options.ecmaVersion >= 8 && !isGenerator && !method.computed && method.key.type === "Identifier" && method.key.name === "async" && this.type !== tt.parenL && !this.canInsertSemicolon()) { isAsync = true this.parsePropertyName(method) } method.kind = "method" let isGetSet = false if (!method.computed) { let {key} = method if (!isGenerator && !isAsync && key.type === "Identifier" && this.type !== tt.parenL && (key.name === "get" || key.name === "set")) { isGetSet = true method.kind = key.name key = this.parsePropertyName(method) } if (!method.static && (key.type === "Identifier" && key.name === "constructor" || key.type === "Literal" && key.value === "constructor")) { if (hadConstructor) this.raise(key.start, "Duplicate constructor in the same class") if (isGetSet) this.raise(key.start, "Constructor can't have get/set modifier") if (isGenerator) this.raise(key.start, "Constructor can't be a generator") if (isAsync) this.raise(key.start, "Constructor can't be an async method") method.kind = "constructor" hadConstructor = true } } this.parseClassMethod(classBody, method, isGenerator, isAsync) if (isGetSet) { let paramCount = method.kind === "get" ? 0 : 1 if (method.value.params.length !== paramCount) { let start = method.value.start if (method.kind === "get") this.raiseRecoverable(start, "getter should have no params") else this.raiseRecoverable(start, "setter should have exactly one param") } else { if (method.kind === "set" && method.value.params[0].type === "RestElement") this.raiseRecoverable(method.value.params[0].start, "Setter cannot use rest params") } } } node.body = this.finishNode(classBody, "ClassBody") return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression") } pp.parseClassMethod = function(classBody, method, isGenerator, isAsync) { method.value = this.parseMethod(isGenerator, isAsync) classBody.body.push(this.finishNode(method, "MethodDefinition")) } pp.parseClassId = function(node, isStatement) { node.id = this.type === tt.name ? this.parseIdent() : isStatement ? this.unexpected() : null } pp.parseClassSuper = function(node) { node.superClass = this.eat(tt._extends) ? this.parseExprSubscripts() : null } // Parses module export declaration. pp.parseExport = function(node, exports) { this.next() // export * from '...' if (this.eat(tt.star)) { this.expectContextual("from") node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected() this.semicolon() return this.finishNode(node, "ExportAllDeclaration") } if (this.eat(tt._default)) { // export default ... this.checkExport(exports, "default", this.lastTokStart) let parens = this.type == tt.parenL let expr = this.parseMaybeAssign() let needsSemi = true if (!parens && (expr.type == "FunctionExpression" || expr.type == "ClassExpression")) { needsSemi = false if (expr.id) { expr.type = expr.type == "FunctionExpression" ? "FunctionDeclaration" : "ClassDeclaration" } } node.declaration = expr if (needsSemi) this.semicolon() return this.finishNode(node, "ExportDefaultDeclaration") } // export var|const|let|function|class ... if (this.shouldParseExportStatement()) { node.declaration = this.parseStatement(true) if (node.declaration.type === "VariableDeclaration") this.checkVariableExport(exports, node.declaration.declarations) else this.checkExport(exports, node.declaration.id.name, node.declaration.id.start) node.specifiers = [] node.source = null } else { // export { x, y as z } [from '...'] node.declaration = null node.specifiers = this.parseExportSpecifiers(exports) if (this.eatContextual("from")) { node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected() } else { // check for keywords used as local names for (let i = 0; i < node.specifiers.length; i++) { if (this.keywords.test(node.specifiers[i].local.name) || this.reservedWords.test(node.specifiers[i].local.name)) { this.unexpected(node.specifiers[i].local.start) } } node.source = null } this.semicolon() } return this.finishNode(node, "ExportNamedDeclaration") } pp.checkExport = function(exports, name, pos) { if (!exports) return if (Object.prototype.hasOwnProperty.call(exports, name)) this.raiseRecoverable(pos, "Duplicate export '" + name + "'") exports[name] = true } pp.checkPatternExport = function(exports, pat) { let type = pat.type if (type == "Identifier") this.checkExport(exports, pat.name, pat.start) else if (type == "ObjectPattern") for (let i = 0; i < pat.properties.length; ++i) this.checkPatternExport(exports, pat.properties[i].value) else if (type == "ArrayPattern") for (let i = 0; i < pat.elements.length; ++i) { let elt = pat.elements[i] if (elt) this.checkPatternExport(exports, elt) } else if (type == "AssignmentPattern") this.checkPatternExport(exports, pat.left) else if (type == "ParenthesizedExpression") this.checkPatternExport(exports, pat.expression) } pp.checkVariableExport = function(exports, decls) { if (!exports) return for (let i = 0; i < decls.length; i++) this.checkPatternExport(exports, decls[i].id) } pp.shouldParseExportStatement = function() { return this.type.keyword === "var" || this.type.keyword === "const" || this.type.keyword === "class" || this.type.keyword === "function" || this.isLet() || this.isAsyncFunction() } // Parses a comma-separated list of module exports. pp.parseExportSpecifiers = function(exports) { let nodes = [], first = true // export { x, y as z } [from '...'] this.expect(tt.braceL) while (!this.eat(tt.braceR)) { if (!first) { this.expect(tt.comma) if (this.afterTrailingComma(tt.braceR)) break } else first = false let node = this.startNode() node.local = this.parseIdent(this.type === tt._default) node.exported = this.eatContextual("as") ? this.parseIdent(true) : node.local this.checkExport(exports, node.exported.name, node.exported.start) nodes.push(this.finishNode(node, "ExportSpecifier")) } return nodes } // Parses import declaration. pp.parseImport = function(node) { this.next() // import '...' if (this.type === tt.string) { node.specifiers = empty node.source = this.parseExprAtom() } else { node.specifiers = this.parseImportSpecifiers() this.expectContextual("from") node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected() } this.semicolon() return this.finishNode(node, "ImportDeclaration") } // Parses a comma-separated list of module imports. pp.parseImportSpecifiers = function() { let nodes = [], first = true if (this.type === tt.name) { // import defaultObj, { x, y as z } from '...' let node = this.startNode() node.local = this.parseIdent() this.checkLVal(node.local, true) nodes.push(this.finishNode(node, "ImportDefaultSpecifier")) if (!this.eat(tt.comma)) return nodes } if (this.type === tt.star) { let node = this.startNode() this.next() this.expectContextual("as") node.local = this.parseIdent() this.checkLVal(node.local, true) nodes.push(this.finishNode(node, "ImportNamespaceSpecifier")) return nodes } this.expect(tt.braceL) while (!this.eat(tt.braceR)) { if (!first) { this.expect(tt.comma) if (this.afterTrailingComma(tt.braceR)) break } else first = false let node = this.startNode() node.imported = this.parseIdent(true) if (this.eatContextual("as")) { node.local = this.parseIdent() } else { node.local = node.imported if (this.isKeyword(node.local.name)) this.unexpected(node.local.start) if (this.reservedWordsStrict.test(node.local.name)) this.raiseRecoverable(node.local.start, "The keyword '" + node.local.name + "' is reserved") } this.checkLVal(node.local, true) nodes.push(this.finishNode(node, "ImportSpecifier")) } return nodes } acorn-4.0.4/src/tokencontext.js000066400000000000000000000062461302576755300165200ustar00rootroot00000000000000// The algorithm used to determine whether a regexp can appear at a // given point in the program is loosely based on sweet.js' approach. // See https://github.com/mozilla/sweet.js/wiki/design import {Parser} from "./state" import {types as tt} from "./tokentype" import {lineBreak} from "./whitespace" export class TokContext { constructor(token, isExpr, preserveSpace, override) { this.token = token this.isExpr = !!isExpr this.preserveSpace = !!preserveSpace this.override = override } } export const types = { b_stat: new TokContext("{", false), b_expr: new TokContext("{", true), b_tmpl: new TokContext("${", true), p_stat: new TokContext("(", false), p_expr: new TokContext("(", true), q_tmpl: new TokContext("`", true, true, p => p.readTmplToken()), f_expr: new TokContext("function", true) } const pp = Parser.prototype pp.initialContext = function() { return [types.b_stat] } pp.braceIsBlock = function(prevType) { if (prevType === tt.colon) { let parent = this.curContext() if (parent === types.b_stat || parent === types.b_expr) return !parent.isExpr } if (prevType === tt._return) return lineBreak.test(this.input.slice(this.lastTokEnd, this.start)) if (prevType === tt._else || prevType === tt.semi || prevType === tt.eof || prevType === tt.parenR) return true if (prevType == tt.braceL) return this.curContext() === types.b_stat return !this.exprAllowed } pp.updateContext = function(prevType) { let update, type = this.type if (type.keyword && prevType == tt.dot) this.exprAllowed = false else if (update = type.updateContext) update.call(this, prevType) else this.exprAllowed = type.beforeExpr } // Token-specific context update code tt.parenR.updateContext = tt.braceR.updateContext = function() { if (this.context.length == 1) { this.exprAllowed = true return } let out = this.context.pop() if (out === types.b_stat && this.curContext() === types.f_expr) { this.context.pop() this.exprAllowed = false } else if (out === types.b_tmpl) { this.exprAllowed = true } else { this.exprAllowed = !out.isExpr } } tt.braceL.updateContext = function(prevType) { this.context.push(this.braceIsBlock(prevType) ? types.b_stat : types.b_expr) this.exprAllowed = true } tt.dollarBraceL.updateContext = function() { this.context.push(types.b_tmpl) this.exprAllowed = true } tt.parenL.updateContext = function(prevType) { let statementParens = prevType === tt._if || prevType === tt._for || prevType === tt._with || prevType === tt._while this.context.push(statementParens ? types.p_stat : types.p_expr) this.exprAllowed = true } tt.incDec.updateContext = function() { // tokExprAllowed stays unchanged } tt._function.updateContext = function(prevType) { if (prevType.beforeExpr && prevType !== tt.semi && prevType !== tt._else && !((prevType === tt.colon || prevType === tt.braceL) && this.curContext() === types.b_stat)) this.context.push(types.f_expr) this.exprAllowed = false } tt.backQuote.updateContext = function() { if (this.curContext() === types.q_tmpl) this.context.pop() else this.context.push(types.q_tmpl) this.exprAllowed = false } acorn-4.0.4/src/tokenize.js000066400000000000000000000550761302576755300156300ustar00rootroot00000000000000import {isIdentifierStart, isIdentifierChar} from "./identifier" import {types as tt, keywords as keywordTypes} from "./tokentype" import {Parser} from "./state" import {SourceLocation} from "./locutil" import {lineBreak, lineBreakG, isNewLine, nonASCIIwhitespace} from "./whitespace" // Object type used to represent tokens. Note that normally, tokens // simply exist as properties on the parser object. This is only // used for the onToken callback and the external tokenizer. export class Token { constructor(p) { this.type = p.type this.value = p.value this.start = p.start this.end = p.end if (p.options.locations) this.loc = new SourceLocation(p, p.startLoc, p.endLoc) if (p.options.ranges) this.range = [p.start, p.end] } } // ## Tokenizer const pp = Parser.prototype // Are we running under Rhino? const isRhino = typeof Packages == "object" && Object.prototype.toString.call(Packages) == "[object JavaPackage]" // Move to the next token pp.next = function() { if (this.options.onToken) this.options.onToken(new Token(this)) this.lastTokEnd = this.end this.lastTokStart = this.start this.lastTokEndLoc = this.endLoc this.lastTokStartLoc = this.startLoc this.nextToken() } pp.getToken = function() { this.next() return new Token(this) } // If we're in an ES6 environment, make parsers iterable if (typeof Symbol !== "undefined") pp[Symbol.iterator] = function () { let self = this return {next: function () { let token = self.getToken() return { done: token.type === tt.eof, value: token } }} } // Toggle strict mode. Re-reads the next number or string to please // pedantic tests (`"use strict"; 010;` should fail). pp.setStrict = function(strict) { this.strict = strict if (this.type !== tt.num && this.type !== tt.string) return this.pos = this.start if (this.options.locations) { while (this.pos < this.lineStart) { this.lineStart = this.input.lastIndexOf("\n", this.lineStart - 2) + 1 --this.curLine } } this.nextToken() } pp.curContext = function() { return this.context[this.context.length - 1] } // Read a single token, updating the parser object's token-related // properties. pp.nextToken = function() { let curContext = this.curContext() if (!curContext || !curContext.preserveSpace) this.skipSpace() this.start = this.pos if (this.options.locations) this.startLoc = this.curPosition() if (this.pos >= this.input.length) return this.finishToken(tt.eof) if (curContext.override) return curContext.override(this) else this.readToken(this.fullCharCodeAtPos()) } pp.readToken = function(code) { // Identifier or keyword. '\uXXXX' sequences are allowed in // identifiers, so '\' also dispatches to that. if (isIdentifierStart(code, this.options.ecmaVersion >= 6) || code === 92 /* '\' */) return this.readWord() return this.getTokenFromCode(code) } pp.fullCharCodeAtPos = function() { let code = this.input.charCodeAt(this.pos) if (code <= 0xd7ff || code >= 0xe000) return code let next = this.input.charCodeAt(this.pos + 1) return (code << 10) + next - 0x35fdc00 } pp.skipBlockComment = function() { let startLoc = this.options.onComment && this.curPosition() let start = this.pos, end = this.input.indexOf("*/", this.pos += 2) if (end === -1) this.raise(this.pos - 2, "Unterminated comment") this.pos = end + 2 if (this.options.locations) { lineBreakG.lastIndex = start let match while ((match = lineBreakG.exec(this.input)) && match.index < this.pos) { ++this.curLine this.lineStart = match.index + match[0].length } } if (this.options.onComment) this.options.onComment(true, this.input.slice(start + 2, end), start, this.pos, startLoc, this.curPosition()) } pp.skipLineComment = function(startSkip) { let start = this.pos let startLoc = this.options.onComment && this.curPosition() let ch = this.input.charCodeAt(this.pos+=startSkip) while (this.pos < this.input.length && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) { ++this.pos ch = this.input.charCodeAt(this.pos) } if (this.options.onComment) this.options.onComment(false, this.input.slice(start + startSkip, this.pos), start, this.pos, startLoc, this.curPosition()) } // Called at the start of the parse and after every token. Skips // whitespace and comments, and. pp.skipSpace = function() { loop: while (this.pos < this.input.length) { let ch = this.input.charCodeAt(this.pos) switch (ch) { case 32: case 160: // ' ' ++this.pos break case 13: if (this.input.charCodeAt(this.pos + 1) === 10) { ++this.pos } case 10: case 8232: case 8233: ++this.pos if (this.options.locations) { ++this.curLine this.lineStart = this.pos } break case 47: // '/' switch (this.input.charCodeAt(this.pos + 1)) { case 42: // '*' this.skipBlockComment() break case 47: this.skipLineComment(2) break default: break loop } break default: if (ch > 8 && ch < 14 || ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) { ++this.pos } else { break loop } } } } // Called at the end of every token. Sets `end`, `val`, and // maintains `context` and `exprAllowed`, and skips the space after // the token, so that the next one's `start` will point at the // right position. pp.finishToken = function(type, val) { this.end = this.pos if (this.options.locations) this.endLoc = this.curPosition() let prevType = this.type this.type = type this.value = val this.updateContext(prevType) } // ### Token reading // This is the function that is called to fetch the next token. It // is somewhat obscure, because it works in character codes rather // than characters, and because operator parsing has been inlined // into it. // // All in the name of speed. // pp.readToken_dot = function() { let next = this.input.charCodeAt(this.pos + 1) if (next >= 48 && next <= 57) return this.readNumber(true) let next2 = this.input.charCodeAt(this.pos + 2) if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) { // 46 = dot '.' this.pos += 3 return this.finishToken(tt.ellipsis) } else { ++this.pos return this.finishToken(tt.dot) } } pp.readToken_slash = function() { // '/' let next = this.input.charCodeAt(this.pos + 1) if (this.exprAllowed) {++this.pos; return this.readRegexp()} if (next === 61) return this.finishOp(tt.assign, 2) return this.finishOp(tt.slash, 1) } pp.readToken_mult_modulo_exp = function(code) { // '%*' let next = this.input.charCodeAt(this.pos + 1) let size = 1 let tokentype = code === 42 ? tt.star : tt.modulo // exponentiation operator ** and **= if (this.options.ecmaVersion >= 7 && next === 42) { ++size tokentype = tt.starstar next = this.input.charCodeAt(this.pos + 2) } if (next === 61) return this.finishOp(tt.assign, size + 1) return this.finishOp(tokentype, size) } pp.readToken_pipe_amp = function(code) { // '|&' let next = this.input.charCodeAt(this.pos + 1) if (next === code) return this.finishOp(code === 124 ? tt.logicalOR : tt.logicalAND, 2) if (next === 61) return this.finishOp(tt.assign, 2) return this.finishOp(code === 124 ? tt.bitwiseOR : tt.bitwiseAND, 1) } pp.readToken_caret = function() { // '^' let next = this.input.charCodeAt(this.pos + 1) if (next === 61) return this.finishOp(tt.assign, 2) return this.finishOp(tt.bitwiseXOR, 1) } pp.readToken_plus_min = function(code) { // '+-' let next = this.input.charCodeAt(this.pos + 1) if (next === code) { if (next == 45 && this.input.charCodeAt(this.pos + 2) == 62 && lineBreak.test(this.input.slice(this.lastTokEnd, this.pos))) { // A `-->` line comment this.skipLineComment(3) this.skipSpace() return this.nextToken() } return this.finishOp(tt.incDec, 2) } if (next === 61) return this.finishOp(tt.assign, 2) return this.finishOp(tt.plusMin, 1) } pp.readToken_lt_gt = function(code) { // '<>' let next = this.input.charCodeAt(this.pos + 1) let size = 1 if (next === code) { size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2 if (this.input.charCodeAt(this.pos + size) === 61) return this.finishOp(tt.assign, size + 1) return this.finishOp(tt.bitShift, size) } if (next == 33 && code == 60 && this.input.charCodeAt(this.pos + 2) == 45 && this.input.charCodeAt(this.pos + 3) == 45) { if (this.inModule) this.unexpected() // `' is a single-line comment index += 3; skipSingleLineComment(3); } else { break; } } else if (ch === 0x3C) { // U+003C is '<' if (source.slice(index + 1, index + 4) === '!--') { ++index; // `<` ++index; // `!` ++index; // `-` ++index; // `-` skipSingleLineComment(4); } else { break; } } else { break; } } } function scanHexEscape(prefix) { var i, len, ch, code = 0; len = (prefix === 'u') ? 4 : 2; for (i = 0; i < len; ++i) { if (index < length && isHexDigit(source[index])) { ch = source[index++]; code = code * 16 + '0123456789abcdef'.indexOf(ch.toLowerCase()); } else { return ''; } } return String.fromCharCode(code); } function scanUnicodeCodePointEscape() { var ch, code, cu1, cu2; ch = source[index]; code = 0; // At least, one hex digit is required. if (ch === '}') { throwUnexpectedToken(); } while (index < length) { ch = source[index++]; if (!isHexDigit(ch)) { break; } code = code * 16 + '0123456789abcdef'.indexOf(ch.toLowerCase()); } if (code > 0x10FFFF || ch !== '}') { throwUnexpectedToken(); } // UTF-16 Encoding if (code <= 0xFFFF) { return String.fromCharCode(code); } cu1 = ((code - 0x10000) >> 10) + 0xD800; cu2 = ((code - 0x10000) & 1023) + 0xDC00; return String.fromCharCode(cu1, cu2); } function getEscapedIdentifier() { var ch, id; ch = source.charCodeAt(index++); id = String.fromCharCode(ch); // '\u' (U+005C, U+0075) denotes an escaped character. if (ch === 0x5C) { if (source.charCodeAt(index) !== 0x75) { throwUnexpectedToken(); } ++index; ch = scanHexEscape('u'); if (!ch || ch === '\\' || !isIdentifierStart(ch.charCodeAt(0))) { throwUnexpectedToken(); } id = ch; } while (index < length) { ch = source.charCodeAt(index); if (!isIdentifierPart(ch)) { break; } ++index; id += String.fromCharCode(ch); // '\u' (U+005C, U+0075) denotes an escaped character. if (ch === 0x5C) { id = id.substr(0, id.length - 1); if (source.charCodeAt(index) !== 0x75) { throwUnexpectedToken(); } ++index; ch = scanHexEscape('u'); if (!ch || ch === '\\' || !isIdentifierPart(ch.charCodeAt(0))) { throwUnexpectedToken(); } id += ch; } } return id; } function getIdentifier() { var start, ch; start = index++; while (index < length) { ch = source.charCodeAt(index); if (ch === 0x5C) { // Blackslash (U+005C) marks Unicode escape sequence. index = start; return getEscapedIdentifier(); } if (isIdentifierPart(ch)) { ++index; } else { break; } } return source.slice(start, index); } function scanIdentifier() { var start, id, type; start = index; // Backslash (U+005C) starts an escaped character. id = (source.charCodeAt(index) === 0x5C) ? getEscapedIdentifier() : getIdentifier(); // There is no keyword or literal with only one character. // Thus, it must be an identifier. if (id.length === 1) { type = Token.Identifier; } else if (isKeyword(id)) { type = Token.Keyword; } else if (id === 'null') { type = Token.NullLiteral; } else if (id === 'true' || id === 'false') { type = Token.BooleanLiteral; } else { type = Token.Identifier; } return { type: type, value: id, lineNumber: lineNumber, lineStart: lineStart, start: start, end: index }; } // 7.7 Punctuators function scanPunctuator() { var token, str; token = { type: Token.Punctuator, value: '', lineNumber: lineNumber, lineStart: lineStart, start: index, end: index }; // Check for most common single-character punctuators. str = source[index]; switch (str) { case '(': if (extra.tokenize) { extra.openParenToken = extra.tokens.length; } ++index; break; case '{': if (extra.tokenize) { extra.openCurlyToken = extra.tokens.length; } ++index; break; case '.': ++index; if (source[index] === '.' && source[index + 1] === '.') { // Spread operator: ... index += 2; str = '...'; } break; case ')': case ';': case ',': case '}': case '[': case ']': case ':': case '?': case '~': ++index; break; default: // 4-character punctuator. str = source.substr(index, 4); if (str === '>>>=') { index += 4; } else { // 3-character punctuators. str = str.substr(0, 3); if (str === '===' || str === '!==' || str === '>>>' || str === '<<=' || str === '>>=') { index += 3; } else { // 2-character punctuators. str = str.substr(0, 2); if (str === '&&' || str === '||' || str === '==' || str === '!=' || str === '+=' || str === '-=' || str === '*=' || str === '/=' || str === '++' || str === '--' || str === '<<' || str === '>>' || str === '&=' || str === '|=' || str === '^=' || str === '%=' || str === '<=' || str === '>=' || str === '=>') { index += 2; } else { // 1-character punctuators. str = source[index]; if ('<>=!+-*%&|^/'.indexOf(str) >= 0) { ++index; } } } } } if (index === token.start) { throwUnexpectedToken(); } token.end = index; token.value = str; return token; } // 7.8.3 Numeric Literals function scanHexLiteral(start) { var number = ''; while (index < length) { if (!isHexDigit(source[index])) { break; } number += source[index++]; } if (number.length === 0) { throwUnexpectedToken(); } if (isIdentifierStart(source.charCodeAt(index))) { throwUnexpectedToken(); } return { type: Token.NumericLiteral, value: parseInt('0x' + number, 16), lineNumber: lineNumber, lineStart: lineStart, start: start, end: index }; } function scanBinaryLiteral(start) { var ch, number; number = ''; while (index < length) { ch = source[index]; if (ch !== '0' && ch !== '1') { break; } number += source[index++]; } if (number.length === 0) { // only 0b or 0B throwUnexpectedToken(); } if (index < length) { ch = source.charCodeAt(index); /* istanbul ignore else */ if (isIdentifierStart(ch) || isDecimalDigit(ch)) { throwUnexpectedToken(); } } return { type: Token.NumericLiteral, value: parseInt(number, 2), lineNumber: lineNumber, lineStart: lineStart, start: start, end: index }; } function scanOctalLiteral(prefix, start) { var number, octal; if (isOctalDigit(prefix)) { octal = true; number = '0' + source[index++]; } else { octal = false; ++index; number = ''; } while (index < length) { if (!isOctalDigit(source[index])) { break; } number += source[index++]; } if (!octal && number.length === 0) { // only 0o or 0O throwUnexpectedToken(); } if (isIdentifierStart(source.charCodeAt(index)) || isDecimalDigit(source.charCodeAt(index))) { throwUnexpectedToken(); } return { type: Token.NumericLiteral, value: parseInt(number, 8), octal: octal, lineNumber: lineNumber, lineStart: lineStart, start: start, end: index }; } function isImplicitOctalLiteral() { var i, ch; // Implicit octal, unless there is a non-octal digit. // (Annex B.1.1 on Numeric Literals) for (i = index + 1; i < length; ++i) { ch = source[i]; if (ch === '8' || ch === '9') { return false; } if (!isOctalDigit(ch)) { return true; } } return true; } function scanNumericLiteral() { var number, start, ch; ch = source[index]; assert(isDecimalDigit(ch.charCodeAt(0)) || (ch === '.'), 'Numeric literal must start with a decimal digit or a decimal point'); start = index; number = ''; if (ch !== '.') { number = source[index++]; ch = source[index]; // Hex number starts with '0x'. // Octal number starts with '0'. // Octal number in ES6 starts with '0o'. // Binary number in ES6 starts with '0b'. if (number === '0') { if (ch === 'x' || ch === 'X') { ++index; return scanHexLiteral(start); } if (ch === 'b' || ch === 'B') { ++index; return scanBinaryLiteral(start); } if (ch === 'o' || ch === 'O') { return scanOctalLiteral(ch, start); } if (isOctalDigit(ch)) { if (isImplicitOctalLiteral()) { return scanOctalLiteral(ch, start); } } } while (isDecimalDigit(source.charCodeAt(index))) { number += source[index++]; } ch = source[index]; } if (ch === '.') { number += source[index++]; while (isDecimalDigit(source.charCodeAt(index))) { number += source[index++]; } ch = source[index]; } if (ch === 'e' || ch === 'E') { number += source[index++]; ch = source[index]; if (ch === '+' || ch === '-') { number += source[index++]; } if (isDecimalDigit(source.charCodeAt(index))) { while (isDecimalDigit(source.charCodeAt(index))) { number += source[index++]; } } else { throwUnexpectedToken(); } } if (isIdentifierStart(source.charCodeAt(index))) { throwUnexpectedToken(); } return { type: Token.NumericLiteral, value: parseFloat(number), lineNumber: lineNumber, lineStart: lineStart, start: start, end: index }; } // 7.8.4 String Literals function scanStringLiteral() { var str = '', quote, start, ch, code, unescaped, restore, octal = false; quote = source[index]; assert((quote === '\'' || quote === '"'), 'String literal must starts with a quote'); start = index; ++index; while (index < length) { ch = source[index++]; if (ch === quote) { quote = ''; break; } else if (ch === '\\') { ch = source[index++]; if (!ch || !isLineTerminator(ch.charCodeAt(0))) { switch (ch) { case 'u': case 'x': if (source[index] === '{') { ++index; str += scanUnicodeCodePointEscape(); } else { restore = index; unescaped = scanHexEscape(ch); if (unescaped) { str += unescaped; } else { index = restore; str += ch; } } break; case 'n': str += '\n'; break; case 'r': str += '\r'; break; case 't': str += '\t'; break; case 'b': str += '\b'; break; case 'f': str += '\f'; break; case 'v': str += '\x0B'; break; default: if (isOctalDigit(ch)) { code = '01234567'.indexOf(ch); // \0 is not octal escape sequence if (code !== 0) { octal = true; } if (index < length && isOctalDigit(source[index])) { octal = true; code = code * 8 + '01234567'.indexOf(source[index++]); // 3 digits are only allowed when string starts // with 0, 1, 2, 3 if ('0123'.indexOf(ch) >= 0 && index < length && isOctalDigit(source[index])) { code = code * 8 + '01234567'.indexOf(source[index++]); } } str += String.fromCharCode(code); } else { str += ch; } break; } } else { ++lineNumber; if (ch === '\r' && source[index] === '\n') { ++index; } lineStart = index; } } else if (isLineTerminator(ch.charCodeAt(0))) { break; } else { str += ch; } } if (quote !== '') { throwUnexpectedToken(); } return { type: Token.StringLiteral, value: str, octal: octal, lineNumber: startLineNumber, lineStart: startLineStart, start: start, end: index }; } function testRegExp(pattern, flags) { var tmp = pattern; if (flags.indexOf('u') >= 0) { // Replace each astral symbol and every Unicode code point // escape sequence with a single ASCII symbol to avoid throwing on // regular expressions that are only valid in combination with the // `/u` flag. // Note: replacing with the ASCII symbol `x` might cause false // negatives in unlikely scenarios. For example, `[\u{61}-b]` is a // perfectly valid pattern that is equivalent to `[a-b]`, but it // would be replaced by `[x-b]` which throws an error. tmp = tmp .replace(/\\u\{([0-9a-fA-F]+)\}/g, function ($0, $1) { if (parseInt($1, 16) <= 0x10FFFF) { return 'x'; } throwUnexpectedToken(null, Messages.InvalidRegExp); }) .replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, 'x'); } // First, detect invalid regular expressions. try { RegExp(tmp); } catch (e) { throwUnexpectedToken(null, Messages.InvalidRegExp); } // Return a regular expression object for this pattern-flag pair, or // `null` in case the current environment doesn't support the flags it // uses. try { return new RegExp(pattern, flags); } catch (exception) { return null; } } function scanRegExpBody() { var ch, str, classMarker, terminated, body; ch = source[index]; assert(ch === '/', 'Regular expression literal must start with a slash'); str = source[index++]; classMarker = false; terminated = false; while (index < length) { ch = source[index++]; str += ch; if (ch === '\\') { ch = source[index++]; // ECMA-262 7.8.5 if (isLineTerminator(ch.charCodeAt(0))) { throwUnexpectedToken(null, Messages.UnterminatedRegExp); } str += ch; } else if (isLineTerminator(ch.charCodeAt(0))) { throwUnexpectedToken(null, Messages.UnterminatedRegExp); } else if (classMarker) { if (ch === ']') { classMarker = false; } } else { if (ch === '/') { terminated = true; break; } else if (ch === '[') { classMarker = true; } } } if (!terminated) { throwUnexpectedToken(null, Messages.UnterminatedRegExp); } // Exclude leading and trailing slash. body = str.substr(1, str.length - 2); return { value: body, literal: str }; } function scanRegExpFlags() { var ch, str, flags, restore; str = ''; flags = ''; while (index < length) { ch = source[index]; if (!isIdentifierPart(ch.charCodeAt(0))) { break; } ++index; if (ch === '\\' && index < length) { ch = source[index]; if (ch === 'u') { ++index; restore = index; ch = scanHexEscape('u'); if (ch) { flags += ch; for (str += '\\u'; restore < index; ++restore) { str += source[restore]; } } else { index = restore; flags += 'u'; str += '\\u'; } tolerateUnexpectedToken(); } else { str += '\\'; tolerateUnexpectedToken(); } } else { flags += ch; str += ch; } } return { value: flags, literal: str }; } function scanRegExp() { scanning = true; var start, body, flags, value; lookahead = null; skipComment(); start = index; body = scanRegExpBody(); flags = scanRegExpFlags(); value = testRegExp(body.value, flags.value); scanning = false; if (extra.tokenize) { return { type: Token.RegularExpression, value: value, regex: { pattern: body.value, flags: flags.value }, lineNumber: lineNumber, lineStart: lineStart, start: start, end: index }; } return { literal: body.literal + flags.literal, value: value, regex: { pattern: body.value, flags: flags.value }, start: start, end: index }; } function collectRegex() { var pos, loc, regex, token; skipComment(); pos = index; loc = { start: { line: lineNumber, column: index - lineStart } }; regex = scanRegExp(); loc.end = { line: lineNumber, column: index - lineStart }; /* istanbul ignore next */ if (!extra.tokenize) { // Pop the previous token, which is likely '/' or '/=' if (extra.tokens.length > 0) { token = extra.tokens[extra.tokens.length - 1]; if (token.range[0] === pos && token.type === 'Punctuator') { if (token.value === '/' || token.value === '/=') { extra.tokens.pop(); } } } extra.tokens.push({ type: 'RegularExpression', value: regex.literal, regex: regex.regex, range: [pos, index], loc: loc }); } return regex; } function isIdentifierName(token) { return token.type === Token.Identifier || token.type === Token.Keyword || token.type === Token.BooleanLiteral || token.type === Token.NullLiteral; } function advanceSlash() { var prevToken, checkToken; // Using the following algorithm: // https://github.com/mozilla/sweet.js/wiki/design prevToken = extra.tokens[extra.tokens.length - 1]; if (!prevToken) { // Nothing before that: it cannot be a division. return collectRegex(); } if (prevToken.type === 'Punctuator') { if (prevToken.value === ']') { return scanPunctuator(); } if (prevToken.value === ')') { checkToken = extra.tokens[extra.openParenToken - 1]; if (checkToken && checkToken.type === 'Keyword' && (checkToken.value === 'if' || checkToken.value === 'while' || checkToken.value === 'for' || checkToken.value === 'with')) { return collectRegex(); } return scanPunctuator(); } if (prevToken.value === '}') { // Dividing a function by anything makes little sense, // but we have to check for that. if (extra.tokens[extra.openCurlyToken - 3] && extra.tokens[extra.openCurlyToken - 3].type === 'Keyword') { // Anonymous function. checkToken = extra.tokens[extra.openCurlyToken - 4]; if (!checkToken) { return scanPunctuator(); } } else if (extra.tokens[extra.openCurlyToken - 4] && extra.tokens[extra.openCurlyToken - 4].type === 'Keyword') { // Named function. checkToken = extra.tokens[extra.openCurlyToken - 5]; if (!checkToken) { return collectRegex(); } } else { return scanPunctuator(); } // checkToken determines whether the function is // a declaration or an expression. if (FnExprTokens.indexOf(checkToken.value) >= 0) { // It is an expression. return scanPunctuator(); } // It is a declaration. return collectRegex(); } return collectRegex(); } if (prevToken.type === 'Keyword' && prevToken.value !== 'this') { return collectRegex(); } return scanPunctuator(); } function advance() { var ch; if (index >= length) { return { type: Token.EOF, lineNumber: lineNumber, lineStart: lineStart, start: index, end: index }; } ch = source.charCodeAt(index); if (isIdentifierStart(ch)) { return scanIdentifier(); } // Very common: ( and ) and ; if (ch === 0x28 || ch === 0x29 || ch === 0x3B) { return scanPunctuator(); } // String literal starts with single quote (U+0027) or double quote (U+0022). if (ch === 0x27 || ch === 0x22) { return scanStringLiteral(); } // Dot (.) U+002E can also start a floating-point number, hence the need // to check the next character. if (ch === 0x2E) { if (isDecimalDigit(source.charCodeAt(index + 1))) { return scanNumericLiteral(); } return scanPunctuator(); } if (isDecimalDigit(ch)) { return scanNumericLiteral(); } // Slash (/) U+002F can also start a regex. if (extra.tokenize && ch === 0x2F) { return advanceSlash(); } return scanPunctuator(); } function collectToken() { var loc, token, value, entry; loc = { start: { line: lineNumber, column: index - lineStart } }; token = advance(); loc.end = { line: lineNumber, column: index - lineStart }; if (token.type !== Token.EOF) { value = source.slice(token.start, token.end); entry = { type: TokenName[token.type], value: value, range: [token.start, token.end], loc: loc }; if (token.regex) { entry.regex = { pattern: token.regex.pattern, flags: token.regex.flags }; } extra.tokens.push(entry); } return token; } function lex() { var token; scanning = true; lastIndex = index; lastLineNumber = lineNumber; lastLineStart = lineStart; skipComment(); token = lookahead; startIndex = index; startLineNumber = lineNumber; startLineStart = lineStart; lookahead = (typeof extra.tokens !== 'undefined') ? collectToken() : advance(); scanning = false; return token; } function peek() { scanning = true; skipComment(); lastIndex = index; lastLineNumber = lineNumber; lastLineStart = lineStart; startIndex = index; startLineNumber = lineNumber; startLineStart = lineStart; lookahead = (typeof extra.tokens !== 'undefined') ? collectToken() : advance(); scanning = false; } function Position() { this.line = startLineNumber; this.column = startIndex - startLineStart; } function SourceLocation() { this.start = new Position(); this.end = null; } function WrappingSourceLocation(startToken) { this.start = { line: startToken.lineNumber, column: startToken.start - startToken.lineStart }; this.end = null; } function Node() { if (extra.range) { this.range = [startIndex, 0]; } if (extra.loc) { this.loc = new SourceLocation(); } } function WrappingNode(startToken) { if (extra.range) { this.range = [startToken.start, 0]; } if (extra.loc) { this.loc = new WrappingSourceLocation(startToken); } } WrappingNode.prototype = Node.prototype = { processComment: function () { var lastChild, leadingComments, trailingComments, bottomRight = extra.bottomRightStack, i, comment, last = bottomRight[bottomRight.length - 1]; if (this.type === Syntax.Program) { if (this.body.length > 0) { return; } } if (extra.trailingComments.length > 0) { trailingComments = []; for (i = extra.trailingComments.length - 1; i >= 0; --i) { comment = extra.trailingComments[i]; if (comment.range[0] >= this.range[1]) { trailingComments.unshift(comment); extra.trailingComments.splice(i, 1); } } extra.trailingComments = []; } else { if (last && last.trailingComments && last.trailingComments[0].range[0] >= this.range[1]) { trailingComments = last.trailingComments; delete last.trailingComments; } } // Eating the stack. if (last) { while (last && last.range[0] >= this.range[0]) { lastChild = last; last = bottomRight.pop(); } } if (lastChild) { if (lastChild.leadingComments && lastChild.leadingComments[lastChild.leadingComments.length - 1].range[1] <= this.range[0]) { this.leadingComments = lastChild.leadingComments; lastChild.leadingComments = undefined; } } else if (extra.leadingComments.length > 0) { leadingComments = []; for (i = extra.leadingComments.length - 1; i >= 0; --i) { comment = extra.leadingComments[i]; if (comment.range[1] <= this.range[0]) { leadingComments.unshift(comment); extra.leadingComments.splice(i, 1); } } } if (leadingComments && leadingComments.length > 0) { this.leadingComments = leadingComments; } if (trailingComments && trailingComments.length > 0) { this.trailingComments = trailingComments; } bottomRight.push(this); }, finish: function () { if (extra.range) { this.range[1] = lastIndex; } if (extra.loc) { this.loc.end = { line: lastLineNumber, column: lastIndex - lastLineStart }; if (extra.source) { this.loc.source = extra.source; } } if (extra.attachComment) { this.processComment(); } }, finishArrayExpression: function (elements) { this.type = Syntax.ArrayExpression; this.elements = elements; this.finish(); return this; }, finishArrowFunctionExpression: function (params, defaults, body, expression) { this.type = Syntax.ArrowFunctionExpression; this.id = null; this.params = params; this.defaults = defaults; this.body = body; this.generator = false; this.expression = expression; this.finish(); return this; }, finishAssignmentExpression: function (operator, left, right) { this.type = Syntax.AssignmentExpression; this.operator = operator; this.left = left; this.right = right; this.finish(); return this; }, finishBinaryExpression: function (operator, left, right) { this.type = (operator === '||' || operator === '&&') ? Syntax.LogicalExpression : Syntax.BinaryExpression; this.operator = operator; this.left = left; this.right = right; this.finish(); return this; }, finishBlockStatement: function (body) { this.type = Syntax.BlockStatement; this.body = body; this.finish(); return this; }, finishBreakStatement: function (label) { this.type = Syntax.BreakStatement; this.label = label; this.finish(); return this; }, finishCallExpression: function (callee, args) { this.type = Syntax.CallExpression; this.callee = callee; this.arguments = args; this.finish(); return this; }, finishCatchClause: function (param, body) { this.type = Syntax.CatchClause; this.param = param; this.body = body; this.finish(); return this; }, finishClassBody: function (body) { this.type = Syntax.ClassBody; this.body = body; this.finish(); return this; }, finishClassDeclaration: function (id, superClass, body) { this.type = Syntax.ClassDeclaration; this.id = id; this.superClass = superClass; this.body = body; this.finish(); return this; }, finishClassExpression: function (id, superClass, body) { this.type = Syntax.ClassExpression; this.id = id; this.superClass = superClass; this.body = body; this.finish(); return this; }, finishConditionalExpression: function (test, consequent, alternate) { this.type = Syntax.ConditionalExpression; this.test = test; this.consequent = consequent; this.alternate = alternate; this.finish(); return this; }, finishContinueStatement: function (label) { this.type = Syntax.ContinueStatement; this.label = label; this.finish(); return this; }, finishDebuggerStatement: function () { this.type = Syntax.DebuggerStatement; this.finish(); return this; }, finishDoWhileStatement: function (body, test) { this.type = Syntax.DoWhileStatement; this.body = body; this.test = test; this.finish(); return this; }, finishEmptyStatement: function () { this.type = Syntax.EmptyStatement; this.finish(); return this; }, finishExpressionStatement: function (expression) { this.type = Syntax.ExpressionStatement; this.expression = expression; this.finish(); return this; }, finishForStatement: function (init, test, update, body) { this.type = Syntax.ForStatement; this.init = init; this.test = test; this.update = update; this.body = body; this.finish(); return this; }, finishForInStatement: function (left, right, body) { this.type = Syntax.ForInStatement; this.left = left; this.right = right; this.body = body; this.each = false; this.finish(); return this; }, finishFunctionDeclaration: function (id, params, defaults, body) { this.type = Syntax.FunctionDeclaration; this.id = id; this.params = params; this.defaults = defaults; this.body = body; this.generator = false; this.expression = false; this.finish(); return this; }, finishFunctionExpression: function (id, params, defaults, body) { this.type = Syntax.FunctionExpression; this.id = id; this.params = params; this.defaults = defaults; this.body = body; this.generator = false; this.expression = false; this.finish(); return this; }, finishIdentifier: function (name) { this.type = Syntax.Identifier; this.name = name; this.finish(); return this; }, finishIfStatement: function (test, consequent, alternate) { this.type = Syntax.IfStatement; this.test = test; this.consequent = consequent; this.alternate = alternate; this.finish(); return this; }, finishLabeledStatement: function (label, body) { this.type = Syntax.LabeledStatement; this.label = label; this.body = body; this.finish(); return this; }, finishLiteral: function (token) { this.type = Syntax.Literal; this.value = token.value; this.raw = source.slice(token.start, token.end); if (token.regex) { this.regex = token.regex; } this.finish(); return this; }, finishMemberExpression: function (accessor, object, property) { this.type = Syntax.MemberExpression; this.computed = accessor === '['; this.object = object; this.property = property; this.finish(); return this; }, finishNewExpression: function (callee, args) { this.type = Syntax.NewExpression; this.callee = callee; this.arguments = args; this.finish(); return this; }, finishObjectExpression: function (properties) { this.type = Syntax.ObjectExpression; this.properties = properties; this.finish(); return this; }, finishPostfixExpression: function (operator, argument) { this.type = Syntax.UpdateExpression; this.operator = operator; this.argument = argument; this.prefix = false; this.finish(); return this; }, finishProgram: function (body) { this.type = Syntax.Program; this.body = body; this.finish(); return this; }, finishProperty: function (kind, key, computed, value, method, shorthand) { this.type = Syntax.Property; this.key = key; this.computed = computed; this.value = value; this.kind = kind; this.method = method; this.shorthand = shorthand; this.finish(); return this; }, finishRestElement: function (argument) { this.type = Syntax.RestElement; this.argument = argument; this.finish(); return this; }, finishReturnStatement: function (argument) { this.type = Syntax.ReturnStatement; this.argument = argument; this.finish(); return this; }, finishSequenceExpression: function (expressions) { this.type = Syntax.SequenceExpression; this.expressions = expressions; this.finish(); return this; }, finishSwitchCase: function (test, consequent) { this.type = Syntax.SwitchCase; this.test = test; this.consequent = consequent; this.finish(); return this; }, finishSwitchStatement: function (discriminant, cases) { this.type = Syntax.SwitchStatement; this.discriminant = discriminant; this.cases = cases; this.finish(); return this; }, finishThisExpression: function () { this.type = Syntax.ThisExpression; this.finish(); return this; }, finishThrowStatement: function (argument) { this.type = Syntax.ThrowStatement; this.argument = argument; this.finish(); return this; }, finishTryStatement: function (block, handler, finalizer) { this.type = Syntax.TryStatement; this.block = block; this.handlers = handler ? [ handler ] : []; this.handler = handler; this.finalizer = finalizer; this.finish(); return this; }, finishUnaryExpression: function (operator, argument) { this.type = (operator === '++' || operator === '--') ? Syntax.UpdateExpression : Syntax.UnaryExpression; this.operator = operator; this.argument = argument; this.prefix = true; this.finish(); return this; }, finishVariableDeclaration: function (declarations) { this.type = Syntax.VariableDeclaration; this.declarations = declarations; this.kind = 'var'; this.finish(); return this; }, finishLexicalDeclaration: function (declarations, kind) { this.type = Syntax.VariableDeclaration; this.declarations = declarations; this.kind = kind; this.finish(); return this; }, finishVariableDeclarator: function (id, init) { this.type = Syntax.VariableDeclarator; this.id = id; this.init = init; this.finish(); return this; }, finishWhileStatement: function (test, body) { this.type = Syntax.WhileStatement; this.test = test; this.body = body; this.finish(); return this; }, finishWithStatement: function (object, body) { this.type = Syntax.WithStatement; this.object = object; this.body = body; this.finish(); return this; } }; function recordError(error) { var e, existing; for (e = 0; e < extra.errors.length; e++) { existing = extra.errors[e]; // Prevent duplicated error. /* istanbul ignore next */ if (existing.index === error.index && existing.message === error.message) { return; } } extra.errors.push(error); } function createError(line, pos, description) { var error = new Error('Line ' + line + ': ' + description); error.index = pos; error.lineNumber = line; error.column = pos - (scanning ? lineStart : lastLineStart) + 1; error.description = description; return error; } // Throw an exception function throwError(messageFormat) { var args, msg; args = Array.prototype.slice.call(arguments, 1); msg = messageFormat.replace(/%(\d)/g, function (whole, idx) { assert(idx < args.length, 'Message reference must be in range'); return args[idx]; } ); throw createError(lastLineNumber, lastIndex, msg); } function tolerateError(messageFormat) { var args, msg, error; args = Array.prototype.slice.call(arguments, 1); /* istanbul ignore next */ msg = messageFormat.replace(/%(\d)/g, function (whole, idx) { assert(idx < args.length, 'Message reference must be in range'); return args[idx]; } ); error = createError(lineNumber, lastIndex, msg); if (extra.errors) { recordError(error); } else { throw error; } } // Throw an exception because of the token. function unexpectedTokenError(token, message) { var msg = message || Messages.UnexpectedToken; if (token && !message) { msg = (token.type === Token.EOF) ? Messages.UnexpectedEOS : (token.type === Token.Identifier) ? Messages.UnexpectedIdentifier : (token.type === Token.NumericLiteral) ? Messages.UnexpectedNumber : (token.type === Token.StringLiteral) ? Messages.UnexpectedString : Messages.UnexpectedToken; if (token.type === Token.Keyword) { if (isFutureReservedWord(token.value)) { msg = Messages.UnexpectedReserved; } else if (strict && isStrictModeReservedWord(token.value)) { msg = Messages.StrictReservedWord; } } } msg = msg.replace('%0', token ? token.value : 'ILLEGAL'); return (token && typeof token.lineNumber === 'number') ? createError(token.lineNumber, token.start, msg) : createError(scanning ? lineNumber : lastLineNumber, scanning ? index : lastIndex, msg); } function throwUnexpectedToken(token, message) { throw unexpectedTokenError(token, message); } function tolerateUnexpectedToken(token, message) { var error = unexpectedTokenError(token, message); if (extra.errors) { recordError(error); } else { throw error; } } // Expect the next token to match the specified punctuator. // If not, an exception will be thrown. function expect(value) { var token = lex(); if (token.type !== Token.Punctuator || token.value !== value) { throwUnexpectedToken(token); } } /** * @name expectCommaSeparator * @description Quietly expect a comma when in tolerant mode, otherwise delegates * to expect(value) * @since 2.0 */ function expectCommaSeparator() { var token; if (extra.errors) { token = lookahead; if (token.type === Token.Punctuator && token.value === ',') { lex(); } else if (token.type === Token.Punctuator && token.value === ';') { lex(); tolerateUnexpectedToken(token); } else { tolerateUnexpectedToken(token, Messages.UnexpectedToken); } } else { expect(','); } } // Expect the next token to match the specified keyword. // If not, an exception will be thrown. function expectKeyword(keyword) { var token = lex(); if (token.type !== Token.Keyword || token.value !== keyword) { throwUnexpectedToken(token); } } // Return true if the next token matches the specified punctuator. function match(value) { return lookahead.type === Token.Punctuator && lookahead.value === value; } // Return true if the next token matches the specified keyword function matchKeyword(keyword) { return lookahead.type === Token.Keyword && lookahead.value === keyword; } // Return true if the next token is an assignment operator function matchAssign() { var op; if (lookahead.type !== Token.Punctuator) { return false; } op = lookahead.value; return op === '=' || op === '*=' || op === '/=' || op === '%=' || op === '+=' || op === '-=' || op === '<<=' || op === '>>=' || op === '>>>=' || op === '&=' || op === '^=' || op === '|='; } function consumeSemicolon() { // Catch the very common case first: immediately a semicolon (U+003B). if (source.charCodeAt(startIndex) === 0x3B || match(';')) { lex(); return; } if (hasLineTerminator) { return; } // FIXME(ikarienator): this is seemingly an issue in the previous location info convention. lastIndex = startIndex; lastLineNumber = startLineNumber; lastLineStart = startLineStart; if (lookahead.type !== Token.EOF && !match('}')) { throwUnexpectedToken(lookahead); } } // Return true if provided expression is LeftHandSideExpression function isLeftHandSide(expr) { return expr.type === Syntax.Identifier || expr.type === Syntax.MemberExpression; } // 11.1.4 Array Initialiser function parseArrayInitialiser() { var elements = [], node = new Node(); expect('['); while (!match(']')) { if (match(',')) { lex(); elements.push(null); } else { elements.push(parseAssignmentExpression()); if (!match(']')) { expect(','); } } } lex(); return node.finishArrayExpression(elements); } // 11.1.5 Object Initialiser function parsePropertyFunction(node, paramInfo) { var previousStrict, body; previousStrict = strict; body = parseFunctionSourceElements(); if (strict && paramInfo.firstRestricted) { tolerateUnexpectedToken(paramInfo.firstRestricted, paramInfo.message); } if (strict && paramInfo.stricted) { tolerateUnexpectedToken(paramInfo.stricted, paramInfo.message); } strict = previousStrict; return node.finishFunctionExpression(null, paramInfo.params, paramInfo.defaults, body); } function parsePropertyMethodFunction() { var params, method, node = new Node(); params = parseParams(); method = parsePropertyFunction(node, params); return method; } // This function returns a tuple `[PropertyName, boolean]` where the PropertyName is the key being consumed and the second // element indicate whether its a computed PropertyName or a static PropertyName. function parseObjectPropertyKey() { var token, node = new Node(), expr; token = lex(); // Note: This function is called only from parseObjectProperty(), where // EOF and Punctuator tokens are already filtered out. switch (token.type) { case Token.StringLiteral: case Token.NumericLiteral: if (strict && token.octal) { tolerateUnexpectedToken(token, Messages.StrictOctalLiteral); } return node.finishLiteral(token); case Token.Identifier: case Token.BooleanLiteral: case Token.NullLiteral: case Token.Keyword: return node.finishIdentifier(token.value); case Token.Punctuator: if (token.value === '[') { expr = parseAssignmentExpression(); expect(']'); return expr; } break; } throwUnexpectedToken(token); } function lookaheadPropertyName() { switch (lookahead.type) { case Token.Identifier: case Token.StringLiteral: case Token.BooleanLiteral: case Token.NullLiteral: case Token.NumericLiteral: case Token.Keyword: return true; case Token.Punctuator: return lookahead.value === '['; } return false; } // This function is to try to parse a MethodDefinition as defined in 14.3. But in the case of object literals, // it might be called at a position where there is in fact a short hand identifier pattern or a data property. // This can only be determined after we consumed up to the left parentheses. // // In order to avoid back tracking, it returns `null` if the position is not a MethodDefinition and the caller // is responsible to visit other options. function tryParseMethodDefinition(token, key, computed, node) { var value, options, methodNode; if (token.type === Token.Identifier) { // check for `get` and `set`; if (token.value === 'get' && lookaheadPropertyName()) { computed = match('['); key = parseObjectPropertyKey(); methodNode = new Node(); expect('('); expect(')'); value = parsePropertyFunction(methodNode, { params: [], defaults: [], stricted: null, firstRestricted: null, message: null }); return node.finishProperty('get', key, computed, value, false, false); } else if (token.value === 'set' && lookaheadPropertyName()) { computed = match('['); key = parseObjectPropertyKey(); methodNode = new Node(); expect('('); options = { params: [], defaultCount: 0, defaults: [], firstRestricted: null, paramSet: {} }; if (match(')')) { tolerateUnexpectedToken(lookahead); } else { parseParam(options); if (options.defaultCount === 0) { options.defaults = []; } } expect(')'); value = parsePropertyFunction(methodNode, options); return node.finishProperty('set', key, computed, value, false, false); } } if (match('(')) { value = parsePropertyMethodFunction(); return node.finishProperty('init', key, computed, value, true, false); } // Not a MethodDefinition. return null; } function checkProto(key, computed, hasProto) { if (computed === false && (key.type === Syntax.Identifier && key.name === '__proto__' || key.type === Syntax.Literal && key.value === '__proto__')) { if (hasProto.value) { tolerateError(Messages.DuplicateProtoProperty); } else { hasProto.value = true; } } } function parseObjectProperty(hasProto) { var token = lookahead, node = new Node(), computed, key, maybeMethod, value; computed = match('['); key = parseObjectPropertyKey(); maybeMethod = tryParseMethodDefinition(token, key, computed, node); if (maybeMethod) { checkProto(maybeMethod.key, maybeMethod.computed, hasProto); // finished return maybeMethod; } // init property or short hand property. checkProto(key, computed, hasProto); if (match(':')) { lex(); value = parseAssignmentExpression(); return node.finishProperty('init', key, computed, value, false, false); } if (token.type === Token.Identifier) { return node.finishProperty('init', key, computed, key, false, true); } throwUnexpectedToken(lookahead); } function parseObjectInitialiser() { var properties = [], hasProto = {value: false}, node = new Node(); expect('{'); while (!match('}')) { properties.push(parseObjectProperty(hasProto)); if (!match('}')) { expectCommaSeparator(); } } expect('}'); return node.finishObjectExpression(properties); } // 11.1.6 The Grouping Operator function parseGroupExpression() { var expr, expressions, startToken, isValidArrowParameter = true; expect('('); if (match(')')) { lex(); if (!match('=>')) { expect('=>'); } return { type: PlaceHolders.ArrowParameterPlaceHolder, params: [] }; } startToken = lookahead; if (match('...')) { expr = parseRestElement(); expect(')'); if (!match('=>')) { expect('=>'); } return { type: PlaceHolders.ArrowParameterPlaceHolder, params: [expr] }; } if (match('(')) { isValidArrowParameter = false; } expr = parseAssignmentExpression(); if (match(',')) { expressions = [expr]; while (startIndex < length) { if (!match(',')) { break; } lex(); if (match('...')) { if (!isValidArrowParameter) { throwUnexpectedToken(lookahead); } expressions.push(parseRestElement()); expect(')'); if (!match('=>')) { expect('=>'); } return { type: PlaceHolders.ArrowParameterPlaceHolder, params: expressions }; } else if (match('(')) { isValidArrowParameter = false; } expressions.push(parseAssignmentExpression()); } expr = new WrappingNode(startToken).finishSequenceExpression(expressions); } expect(')'); if (match('=>') && !isValidArrowParameter) { throwUnexpectedToken(lookahead); } return expr; } // 11.1 Primary Expressions function parsePrimaryExpression() { var type, token, expr, node; if (match('(')) { return parseGroupExpression(); } if (match('[')) { return parseArrayInitialiser(); } if (match('{')) { return parseObjectInitialiser(); } type = lookahead.type; node = new Node(); if (type === Token.Identifier) { expr = node.finishIdentifier(lex().value); } else if (type === Token.StringLiteral || type === Token.NumericLiteral) { if (strict && lookahead.octal) { tolerateUnexpectedToken(lookahead, Messages.StrictOctalLiteral); } expr = node.finishLiteral(lex()); } else if (type === Token.Keyword) { if (matchKeyword('function')) { return parseFunctionExpression(); } if (matchKeyword('this')) { lex(); return node.finishThisExpression(); } if (matchKeyword('class')) { return parseClassExpression(); } throwUnexpectedToken(lex()); } else if (type === Token.BooleanLiteral) { token = lex(); token.value = (token.value === 'true'); expr = node.finishLiteral(token); } else if (type === Token.NullLiteral) { token = lex(); token.value = null; expr = node.finishLiteral(token); } else if (match('/') || match('/=')) { index = startIndex; if (typeof extra.tokens !== 'undefined') { token = collectRegex(); } else { token = scanRegExp(); } lex(); expr = node.finishLiteral(token); } else { throwUnexpectedToken(lex()); } return expr; } // 11.2 Left-Hand-Side Expressions function parseArguments() { var args = []; expect('('); if (!match(')')) { while (startIndex < length) { args.push(parseAssignmentExpression()); if (match(')')) { break; } expectCommaSeparator(); } } expect(')'); return args; } function parseNonComputedProperty() { var token, node = new Node(); token = lex(); if (!isIdentifierName(token)) { throwUnexpectedToken(token); } return node.finishIdentifier(token.value); } function parseNonComputedMember() { expect('.'); return parseNonComputedProperty(); } function parseComputedMember() { var expr; expect('['); expr = parseExpression(); expect(']'); return expr; } function parseNewExpression() { var callee, args, node = new Node(); expectKeyword('new'); callee = parseLeftHandSideExpression(); args = match('(') ? parseArguments() : []; return node.finishNewExpression(callee, args); } function parseLeftHandSideExpressionAllowCall() { var expr, args, property, startToken, previousAllowIn = state.allowIn; startToken = lookahead; state.allowIn = true; expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression(); for (;;) { if (match('.')) { property = parseNonComputedMember(); expr = new WrappingNode(startToken).finishMemberExpression('.', expr, property); } else if (match('(')) { args = parseArguments(); expr = new WrappingNode(startToken).finishCallExpression(expr, args); } else if (match('[')) { property = parseComputedMember(); expr = new WrappingNode(startToken).finishMemberExpression('[', expr, property); } else { break; } } state.allowIn = previousAllowIn; return expr; } function parseLeftHandSideExpression() { var expr, property, startToken; assert(state.allowIn, 'callee of new expression always allow in keyword.'); startToken = lookahead; expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression(); for (;;) { if (match('[')) { property = parseComputedMember(); expr = new WrappingNode(startToken).finishMemberExpression('[', expr, property); } else if (match('.')) { property = parseNonComputedMember(); expr = new WrappingNode(startToken).finishMemberExpression('.', expr, property); } else { break; } } return expr; } // 11.3 Postfix Expressions function parsePostfixExpression() { var expr, token, startToken = lookahead; expr = parseLeftHandSideExpressionAllowCall(); if (!hasLineTerminator && lookahead.type === Token.Punctuator) { if (match('++') || match('--')) { // 11.3.1, 11.3.2 if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) { tolerateError(Messages.StrictLHSPostfix); } if (!isLeftHandSide(expr)) { tolerateError(Messages.InvalidLHSInAssignment); } token = lex(); expr = new WrappingNode(startToken).finishPostfixExpression(token.value, expr); } } return expr; } // 11.4 Unary Operators function parseUnaryExpression() { var token, expr, startToken; if (lookahead.type !== Token.Punctuator && lookahead.type !== Token.Keyword) { expr = parsePostfixExpression(); } else if (match('++') || match('--')) { startToken = lookahead; token = lex(); expr = parseUnaryExpression(); // 11.4.4, 11.4.5 if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) { tolerateError(Messages.StrictLHSPrefix); } if (!isLeftHandSide(expr)) { tolerateError(Messages.InvalidLHSInAssignment); } expr = new WrappingNode(startToken).finishUnaryExpression(token.value, expr); } else if (match('+') || match('-') || match('~') || match('!')) { startToken = lookahead; token = lex(); expr = parseUnaryExpression(); expr = new WrappingNode(startToken).finishUnaryExpression(token.value, expr); } else if (matchKeyword('delete') || matchKeyword('void') || matchKeyword('typeof')) { startToken = lookahead; token = lex(); expr = parseUnaryExpression(); expr = new WrappingNode(startToken).finishUnaryExpression(token.value, expr); if (strict && expr.operator === 'delete' && expr.argument.type === Syntax.Identifier) { tolerateError(Messages.StrictDelete); } } else { expr = parsePostfixExpression(); } return expr; } function binaryPrecedence(token, allowIn) { var prec = 0; if (token.type !== Token.Punctuator && token.type !== Token.Keyword) { return 0; } switch (token.value) { case '||': prec = 1; break; case '&&': prec = 2; break; case '|': prec = 3; break; case '^': prec = 4; break; case '&': prec = 5; break; case '==': case '!=': case '===': case '!==': prec = 6; break; case '<': case '>': case '<=': case '>=': case 'instanceof': prec = 7; break; case 'in': prec = allowIn ? 7 : 0; break; case '<<': case '>>': case '>>>': prec = 8; break; case '+': case '-': prec = 9; break; case '*': case '/': case '%': prec = 11; break; default: break; } return prec; } // 11.5 Multiplicative Operators // 11.6 Additive Operators // 11.7 Bitwise Shift Operators // 11.8 Relational Operators // 11.9 Equality Operators // 11.10 Binary Bitwise Operators // 11.11 Binary Logical Operators function parseBinaryExpression() { var marker, markers, expr, token, prec, stack, right, operator, left, i; marker = lookahead; left = parseUnaryExpression(); token = lookahead; prec = binaryPrecedence(token, state.allowIn); if (prec === 0) { return left; } token.prec = prec; lex(); markers = [marker, lookahead]; right = parseUnaryExpression(); stack = [left, token, right]; while ((prec = binaryPrecedence(lookahead, state.allowIn)) > 0) { // Reduce: make a binary expression from the three topmost entries. while ((stack.length > 2) && (prec <= stack[stack.length - 2].prec)) { right = stack.pop(); operator = stack.pop().value; left = stack.pop(); markers.pop(); expr = new WrappingNode(markers[markers.length - 1]).finishBinaryExpression(operator, left, right); stack.push(expr); } // Shift. token = lex(); token.prec = prec; stack.push(token); markers.push(lookahead); expr = parseUnaryExpression(); stack.push(expr); } // Final reduce to clean-up the stack. i = stack.length - 1; expr = stack[i]; markers.pop(); while (i > 1) { expr = new WrappingNode(markers.pop()).finishBinaryExpression(stack[i - 1].value, stack[i - 2], expr); i -= 2; } return expr; } // 11.12 Conditional Operator function parseConditionalExpression() { var expr, previousAllowIn, consequent, alternate, startToken; startToken = lookahead; expr = parseBinaryExpression(); if (match('?')) { lex(); previousAllowIn = state.allowIn; state.allowIn = true; consequent = parseAssignmentExpression(); state.allowIn = previousAllowIn; expect(':'); alternate = parseAssignmentExpression(); expr = new WrappingNode(startToken).finishConditionalExpression(expr, consequent, alternate); } return expr; } // [ES6] 14.2 Arrow Function function parseConciseBody() { if (match('{')) { return parseFunctionSourceElements(); } return parseAssignmentExpression(); } function reinterpretAsCoverFormalsList(expr) { var i, len, param, params, defaults, defaultCount, options, token; defaults = []; defaultCount = 0; params = [expr]; switch (expr.type) { case Syntax.Identifier: case Syntax.AssignmentExpression: break; case Syntax.SequenceExpression: params = expr.expressions; break; case PlaceHolders.ArrowParameterPlaceHolder: params = expr.params; break; default: return null; } options = { paramSet: {} }; for (i = 0, len = params.length; i < len; i += 1) { param = params[i]; if (param.type === Syntax.Identifier) { params[i] = param; defaults.push(null); validateParam(options, param, param.name); } else if (param.type === Syntax.RestElement) { params[i] = param; defaults.push(null); validateParam(options, param.argument, param.argument.name); } else if (param.type === Syntax.AssignmentExpression) { params[i] = param.left; defaults.push(param.right); ++defaultCount; validateParam(options, param.left, param.left.name); } else { return null; } } if (options.message === Messages.StrictParamDupe) { token = strict ? options.stricted : options.firstRestricted; throwUnexpectedToken(token, options.message); } if (defaultCount === 0) { defaults = []; } return { params: params, defaults: defaults, stricted: options.stricted, firstRestricted: options.firstRestricted, message: options.message }; } function parseArrowFunctionExpression(options, node) { var previousStrict, body; expect('=>'); previousStrict = strict; body = parseConciseBody(); if (strict && options.firstRestricted) { throwUnexpectedToken(options.firstRestricted, options.message); } if (strict && options.stricted) { tolerateUnexpectedToken(options.stricted, options.message); } strict = previousStrict; return node.finishArrowFunctionExpression(options.params, options.defaults, body, body.type !== Syntax.BlockStatement); } // 11.13 Assignment Operators function parseAssignmentExpression() { var token, expr, right, list, startToken; startToken = lookahead; token = lookahead; expr = parseConditionalExpression(); if (expr.type === PlaceHolders.ArrowParameterPlaceHolder || match('=>')) { list = reinterpretAsCoverFormalsList(expr); if (list) { return parseArrowFunctionExpression(list, new WrappingNode(startToken)); } } if (matchAssign()) { // LeftHandSideExpression if (!isLeftHandSide(expr)) { tolerateError(Messages.InvalidLHSInAssignment); } // 11.13.1 if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) { tolerateUnexpectedToken(token, Messages.StrictLHSAssignment); } token = lex(); right = parseAssignmentExpression(); expr = new WrappingNode(startToken).finishAssignmentExpression(token.value, expr, right); } return expr; } // 11.14 Comma Operator function parseExpression() { var expr, startToken = lookahead, expressions; expr = parseAssignmentExpression(); if (match(',')) { expressions = [expr]; while (startIndex < length) { if (!match(',')) { break; } lex(); expressions.push(parseAssignmentExpression()); } expr = new WrappingNode(startToken).finishSequenceExpression(expressions); } return expr; } // 12.1 Block function parseStatementListItem() { if (lookahead.type === Token.Keyword) { switch (lookahead.value) { case 'const': case 'let': return parseLexicalDeclaration(); case 'function': return parseFunctionDeclaration(new Node()); case 'class': return parseClassDeclaration(); } } return parseStatement(); } function parseStatementList() { var list = []; while (startIndex < length) { if (match('}')) { break; } list.push(parseStatementListItem()); } return list; } function parseBlock() { var block, node = new Node(); expect('{'); block = parseStatementList(); expect('}'); return node.finishBlockStatement(block); } // 12.2 Variable Statement function parseVariableIdentifier() { var token, node = new Node(); token = lex(); if (token.type !== Token.Identifier) { if (strict && token.type === Token.Keyword && isStrictModeReservedWord(token.value)) { tolerateUnexpectedToken(token, Messages.StrictReservedWord); } else { throwUnexpectedToken(token); } } return node.finishIdentifier(token.value); } function parseVariableDeclaration() { var init = null, id, node = new Node(); id = parseVariableIdentifier(); // 12.2.1 if (strict && isRestrictedWord(id.name)) { tolerateError(Messages.StrictVarName); } if (match('=')) { lex(); init = parseAssignmentExpression(); } return node.finishVariableDeclarator(id, init); } function parseVariableDeclarationList() { var list = []; do { list.push(parseVariableDeclaration()); if (!match(',')) { break; } lex(); } while (startIndex < length); return list; } function parseVariableStatement(node) { var declarations; expectKeyword('var'); declarations = parseVariableDeclarationList(); consumeSemicolon(); return node.finishVariableDeclaration(declarations); } function parseLexicalBinding(kind) { var init = null, id, node = new Node(); id = parseVariableIdentifier(); // 12.2.1 if (strict && isRestrictedWord(id.name)) { tolerateError(Messages.StrictVarName); } if (kind === 'const') { if (!matchKeyword('in')) { expect('='); init = parseAssignmentExpression(); } } else if (match('=')) { lex(); init = parseAssignmentExpression(); } return node.finishVariableDeclarator(id, init); } function parseBindingList(kind) { var list = []; do { list.push(parseLexicalBinding(kind)); if (!match(',')) { break; } lex(); } while (startIndex < length); return list; } function parseLexicalDeclaration() { var kind, declarations, node = new Node(); kind = lex().value; assert(kind === 'let' || kind === 'const', 'Lexical declaration must be either let or const'); declarations = parseBindingList(kind); consumeSemicolon(); return node.finishLexicalDeclaration(declarations, kind); } function parseRestElement() { var param, node = new Node(); lex(); if (match('{')) { throwError(Messages.ObjectPatternAsRestParameter); } param = parseVariableIdentifier(); if (match('=')) { throwError(Messages.DefaultRestParameter); } if (!match(')')) { throwError(Messages.ParameterAfterRestParameter); } return node.finishRestElement(param); } // 12.3 Empty Statement function parseEmptyStatement(node) { expect(';'); return node.finishEmptyStatement(); } // 12.4 Expression Statement function parseExpressionStatement(node) { var expr = parseExpression(); consumeSemicolon(); return node.finishExpressionStatement(expr); } // 12.5 If statement function parseIfStatement(node) { var test, consequent, alternate; expectKeyword('if'); expect('('); test = parseExpression(); expect(')'); consequent = parseStatement(); if (matchKeyword('else')) { lex(); alternate = parseStatement(); } else { alternate = null; } return node.finishIfStatement(test, consequent, alternate); } // 12.6 Iteration Statements function parseDoWhileStatement(node) { var body, test, oldInIteration; expectKeyword('do'); oldInIteration = state.inIteration; state.inIteration = true; body = parseStatement(); state.inIteration = oldInIteration; expectKeyword('while'); expect('('); test = parseExpression(); expect(')'); if (match(';')) { lex(); } return node.finishDoWhileStatement(body, test); } function parseWhileStatement(node) { var test, body, oldInIteration; expectKeyword('while'); expect('('); test = parseExpression(); expect(')'); oldInIteration = state.inIteration; state.inIteration = true; body = parseStatement(); state.inIteration = oldInIteration; return node.finishWhileStatement(test, body); } function parseForStatement(node) { var init, test, update, left, right, kind, declarations, body, oldInIteration, previousAllowIn = state.allowIn; init = test = update = null; expectKeyword('for'); expect('('); if (match(';')) { lex(); } else { if (matchKeyword('var')) { init = new Node(); lex(); state.allowIn = false; init = init.finishVariableDeclaration(parseVariableDeclarationList()); state.allowIn = previousAllowIn; if (init.declarations.length === 1 && matchKeyword('in')) { lex(); left = init; right = parseExpression(); init = null; } else { expect(';'); } } else if (matchKeyword('const') || matchKeyword('let')) { init = new Node(); kind = lex().value; state.allowIn = false; declarations = parseBindingList(kind); state.allowIn = previousAllowIn; if (declarations.length === 1 && declarations[0].init === null && matchKeyword('in')) { init = init.finishLexicalDeclaration(declarations, kind); lex(); left = init; right = parseExpression(); init = null; } else { consumeSemicolon(); init = init.finishLexicalDeclaration(declarations, kind); } } else { state.allowIn = false; init = parseExpression(); state.allowIn = previousAllowIn; if (matchKeyword('in')) { // LeftHandSideExpression if (!isLeftHandSide(init)) { tolerateError(Messages.InvalidLHSInForIn); } lex(); left = init; right = parseExpression(); init = null; } else { expect(';'); } } } if (typeof left === 'undefined') { if (!match(';')) { test = parseExpression(); } expect(';'); if (!match(')')) { update = parseExpression(); } } expect(')'); oldInIteration = state.inIteration; state.inIteration = true; body = parseStatement(); state.inIteration = oldInIteration; return (typeof left === 'undefined') ? node.finishForStatement(init, test, update, body) : node.finishForInStatement(left, right, body); } // 12.7 The continue statement function parseContinueStatement(node) { var label = null, key; expectKeyword('continue'); // Optimize the most common form: 'continue;'. if (source.charCodeAt(startIndex) === 0x3B) { lex(); if (!state.inIteration) { throwError(Messages.IllegalContinue); } return node.finishContinueStatement(null); } if (hasLineTerminator) { if (!state.inIteration) { throwError(Messages.IllegalContinue); } return node.finishContinueStatement(null); } if (lookahead.type === Token.Identifier) { label = parseVariableIdentifier(); key = '$' + label.name; if (!Object.prototype.hasOwnProperty.call(state.labelSet, key)) { throwError(Messages.UnknownLabel, label.name); } } consumeSemicolon(); if (label === null && !state.inIteration) { throwError(Messages.IllegalContinue); } return node.finishContinueStatement(label); } // 12.8 The break statement function parseBreakStatement(node) { var label = null, key; expectKeyword('break'); // Catch the very common case first: immediately a semicolon (U+003B). if (source.charCodeAt(lastIndex) === 0x3B) { lex(); if (!(state.inIteration || state.inSwitch)) { throwError(Messages.IllegalBreak); } return node.finishBreakStatement(null); } if (hasLineTerminator) { if (!(state.inIteration || state.inSwitch)) { throwError(Messages.IllegalBreak); } return node.finishBreakStatement(null); } if (lookahead.type === Token.Identifier) { label = parseVariableIdentifier(); key = '$' + label.name; if (!Object.prototype.hasOwnProperty.call(state.labelSet, key)) { throwError(Messages.UnknownLabel, label.name); } } consumeSemicolon(); if (label === null && !(state.inIteration || state.inSwitch)) { throwError(Messages.IllegalBreak); } return node.finishBreakStatement(label); } // 12.9 The return statement function parseReturnStatement(node) { var argument = null; expectKeyword('return'); if (!state.inFunctionBody) { tolerateError(Messages.IllegalReturn); } // 'return' followed by a space and an identifier is very common. if (source.charCodeAt(lastIndex) === 0x20) { if (isIdentifierStart(source.charCodeAt(lastIndex + 1))) { argument = parseExpression(); consumeSemicolon(); return node.finishReturnStatement(argument); } } if (hasLineTerminator) { // HACK return node.finishReturnStatement(null); } if (!match(';')) { if (!match('}') && lookahead.type !== Token.EOF) { argument = parseExpression(); } } consumeSemicolon(); return node.finishReturnStatement(argument); } // 12.10 The with statement function parseWithStatement(node) { var object, body; if (strict) { tolerateError(Messages.StrictModeWith); } expectKeyword('with'); expect('('); object = parseExpression(); expect(')'); body = parseStatement(); return node.finishWithStatement(object, body); } // 12.10 The swith statement function parseSwitchCase() { var test, consequent = [], statement, node = new Node(); if (matchKeyword('default')) { lex(); test = null; } else { expectKeyword('case'); test = parseExpression(); } expect(':'); while (startIndex < length) { if (match('}') || matchKeyword('default') || matchKeyword('case')) { break; } statement = parseStatementListItem(); consequent.push(statement); } return node.finishSwitchCase(test, consequent); } function parseSwitchStatement(node) { var discriminant, cases, clause, oldInSwitch, defaultFound; expectKeyword('switch'); expect('('); discriminant = parseExpression(); expect(')'); expect('{'); cases = []; if (match('}')) { lex(); return node.finishSwitchStatement(discriminant, cases); } oldInSwitch = state.inSwitch; state.inSwitch = true; defaultFound = false; while (startIndex < length) { if (match('}')) { break; } clause = parseSwitchCase(); if (clause.test === null) { if (defaultFound) { throwError(Messages.MultipleDefaultsInSwitch); } defaultFound = true; } cases.push(clause); } state.inSwitch = oldInSwitch; expect('}'); return node.finishSwitchStatement(discriminant, cases); } // 12.13 The throw statement function parseThrowStatement(node) { var argument; expectKeyword('throw'); if (hasLineTerminator) { throwError(Messages.NewlineAfterThrow); } argument = parseExpression(); consumeSemicolon(); return node.finishThrowStatement(argument); } // 12.14 The try statement function parseCatchClause() { var param, body, node = new Node(); expectKeyword('catch'); expect('('); if (match(')')) { throwUnexpectedToken(lookahead); } param = parseVariableIdentifier(); // 12.14.1 if (strict && isRestrictedWord(param.name)) { tolerateError(Messages.StrictCatchVariable); } expect(')'); body = parseBlock(); return node.finishCatchClause(param, body); } function parseTryStatement(node) { var block, handler = null, finalizer = null; expectKeyword('try'); block = parseBlock(); if (matchKeyword('catch')) { handler = parseCatchClause(); } if (matchKeyword('finally')) { lex(); finalizer = parseBlock(); } if (!handler && !finalizer) { throwError(Messages.NoCatchOrFinally); } return node.finishTryStatement(block, handler, finalizer); } // 12.15 The debugger statement function parseDebuggerStatement(node) { expectKeyword('debugger'); consumeSemicolon(); return node.finishDebuggerStatement(); } // 12 Statements function parseStatement() { var type = lookahead.type, expr, labeledBody, key, node; if (type === Token.EOF) { throwUnexpectedToken(lookahead); } if (type === Token.Punctuator && lookahead.value === '{') { return parseBlock(); } node = new Node(); if (type === Token.Punctuator) { switch (lookahead.value) { case ';': return parseEmptyStatement(node); case '(': return parseExpressionStatement(node); default: break; } } else if (type === Token.Keyword) { switch (lookahead.value) { case 'break': return parseBreakStatement(node); case 'continue': return parseContinueStatement(node); case 'debugger': return parseDebuggerStatement(node); case 'do': return parseDoWhileStatement(node); case 'for': return parseForStatement(node); case 'function': return parseFunctionDeclaration(node); case 'if': return parseIfStatement(node); case 'return': return parseReturnStatement(node); case 'switch': return parseSwitchStatement(node); case 'throw': return parseThrowStatement(node); case 'try': return parseTryStatement(node); case 'var': return parseVariableStatement(node); case 'while': return parseWhileStatement(node); case 'with': return parseWithStatement(node); default: break; } } expr = parseExpression(); // 12.12 Labelled Statements if ((expr.type === Syntax.Identifier) && match(':')) { lex(); key = '$' + expr.name; if (Object.prototype.hasOwnProperty.call(state.labelSet, key)) { throwError(Messages.Redeclaration, 'Label', expr.name); } state.labelSet[key] = true; labeledBody = parseStatement(); delete state.labelSet[key]; return node.finishLabeledStatement(expr, labeledBody); } consumeSemicolon(); return node.finishExpressionStatement(expr); } // 13 Function Definition function parseFunctionSourceElements() { var statement, body = [], token, directive, firstRestricted, oldLabelSet, oldInIteration, oldInSwitch, oldInFunctionBody, oldParenthesisCount, node = new Node(); expect('{'); while (startIndex < length) { if (lookahead.type !== Token.StringLiteral) { break; } token = lookahead; statement = parseStatementListItem(); body.push(statement); if (statement.expression.type !== Syntax.Literal) { // this is not directive break; } directive = source.slice(token.start + 1, token.end - 1); if (directive === 'use strict') { strict = true; if (firstRestricted) { tolerateUnexpectedToken(firstRestricted, Messages.StrictOctalLiteral); } } else { if (!firstRestricted && token.octal) { firstRestricted = token; } } } oldLabelSet = state.labelSet; oldInIteration = state.inIteration; oldInSwitch = state.inSwitch; oldInFunctionBody = state.inFunctionBody; oldParenthesisCount = state.parenthesizedCount; state.labelSet = {}; state.inIteration = false; state.inSwitch = false; state.inFunctionBody = true; state.parenthesizedCount = 0; while (startIndex < length) { if (match('}')) { break; } body.push(parseStatementListItem()); } expect('}'); state.labelSet = oldLabelSet; state.inIteration = oldInIteration; state.inSwitch = oldInSwitch; state.inFunctionBody = oldInFunctionBody; state.parenthesizedCount = oldParenthesisCount; return node.finishBlockStatement(body); } function validateParam(options, param, name) { var key = '$' + name; if (strict) { if (isRestrictedWord(name)) { options.stricted = param; options.message = Messages.StrictParamName; } if (Object.prototype.hasOwnProperty.call(options.paramSet, key)) { options.stricted = param; options.message = Messages.StrictParamDupe; } } else if (!options.firstRestricted) { if (isRestrictedWord(name)) { options.firstRestricted = param; options.message = Messages.StrictParamName; } else if (isStrictModeReservedWord(name)) { options.firstRestricted = param; options.message = Messages.StrictReservedWord; } else if (Object.prototype.hasOwnProperty.call(options.paramSet, key)) { options.firstRestricted = param; options.message = Messages.StrictParamDupe; } } options.paramSet[key] = true; } function parseParam(options) { var token, param, def; token = lookahead; if (token.value === '...') { param = parseRestElement(); validateParam(options, param.argument, param.argument.name); options.params.push(param); options.defaults.push(null); return false; } param = parseVariableIdentifier(); validateParam(options, token, token.value); if (match('=')) { lex(); def = parseAssignmentExpression(); ++options.defaultCount; } options.params.push(param); options.defaults.push(def); return !match(')'); } function parseParams(firstRestricted) { var options; options = { params: [], defaultCount: 0, defaults: [], firstRestricted: firstRestricted }; expect('('); if (!match(')')) { options.paramSet = {}; while (startIndex < length) { if (!parseParam(options)) { break; } expect(','); } } expect(')'); if (options.defaultCount === 0) { options.defaults = []; } return { params: options.params, defaults: options.defaults, stricted: options.stricted, firstRestricted: options.firstRestricted, message: options.message }; } function parseFunctionDeclaration(node) { var id, params = [], defaults = [], body, token, stricted, tmp, firstRestricted, message, previousStrict; expectKeyword('function'); token = lookahead; id = parseVariableIdentifier(); if (strict) { if (isRestrictedWord(token.value)) { tolerateUnexpectedToken(token, Messages.StrictFunctionName); } } else { if (isRestrictedWord(token.value)) { firstRestricted = token; message = Messages.StrictFunctionName; } else if (isStrictModeReservedWord(token.value)) { firstRestricted = token; message = Messages.StrictReservedWord; } } tmp = parseParams(firstRestricted); params = tmp.params; defaults = tmp.defaults; stricted = tmp.stricted; firstRestricted = tmp.firstRestricted; if (tmp.message) { message = tmp.message; } previousStrict = strict; body = parseFunctionSourceElements(); if (strict && firstRestricted) { throwUnexpectedToken(firstRestricted, message); } if (strict && stricted) { tolerateUnexpectedToken(stricted, message); } strict = previousStrict; return node.finishFunctionDeclaration(id, params, defaults, body); } function parseFunctionExpression() { var token, id = null, stricted, firstRestricted, message, tmp, params = [], defaults = [], body, previousStrict, node = new Node(); expectKeyword('function'); if (!match('(')) { token = lookahead; id = parseVariableIdentifier(); if (strict) { if (isRestrictedWord(token.value)) { tolerateUnexpectedToken(token, Messages.StrictFunctionName); } } else { if (isRestrictedWord(token.value)) { firstRestricted = token; message = Messages.StrictFunctionName; } else if (isStrictModeReservedWord(token.value)) { firstRestricted = token; message = Messages.StrictReservedWord; } } } tmp = parseParams(firstRestricted); params = tmp.params; defaults = tmp.defaults; stricted = tmp.stricted; firstRestricted = tmp.firstRestricted; if (tmp.message) { message = tmp.message; } previousStrict = strict; body = parseFunctionSourceElements(); if (strict && firstRestricted) { throwUnexpectedToken(firstRestricted, message); } if (strict && stricted) { tolerateUnexpectedToken(stricted, message); } strict = previousStrict; return node.finishFunctionExpression(id, params, defaults, body); } function parseClassBody() { var classBody, token, isStatic, hasConstructor = false, body, method, computed, key; classBody = new Node(); expect('{'); body = []; while (!match('}')) { if (match(';')) { lex(); } else { method = new Node(); token = lookahead; isStatic = false; computed = match('['); key = parseObjectPropertyKey(); if (key.name === 'static' && lookaheadPropertyName()) { token = lookahead; isStatic = true; computed = match('['); key = parseObjectPropertyKey(); } method = tryParseMethodDefinition(token, key, computed, method); if (method) { method.static = isStatic; if (method.kind === 'init') { method.kind = 'method'; } if (!isStatic) { if (!method.computed && (method.key.name || method.key.value.toString()) === 'constructor') { if (method.kind !== 'method' || !method.method || method.value.generator) { throwUnexpectedToken(token, Messages.ConstructorSpecialMethod); } if (hasConstructor) { throwUnexpectedToken(token, Messages.DuplicateConstructor); } else { hasConstructor = true; } method.kind = 'constructor'; } } else { if (!method.computed && (method.key.name || method.key.value.toString()) === 'prototype') { throwUnexpectedToken(token, Messages.StaticPrototype); } } method.type = Syntax.MethodDefinition; delete method.method; delete method.shorthand; body.push(method); } else { throwUnexpectedToken(lookahead); } } } lex(); return classBody.finishClassBody(body); } function parseClassDeclaration() { var id = null, superClass = null, classNode = new Node(), classBody, previousStrict = strict; strict = true; expectKeyword('class'); id = parseVariableIdentifier(); if (matchKeyword('extends')) { lex(); superClass = parseLeftHandSideExpressionAllowCall(); } classBody = parseClassBody(); strict = previousStrict; return classNode.finishClassDeclaration(id, superClass, classBody); } function parseClassExpression() { var id = null, superClass = null, classNode = new Node(), classBody, previousStrict = strict; strict = true; expectKeyword('class'); if (lookahead.type === Token.Identifier) { id = parseVariableIdentifier(); } if (matchKeyword('extends')) { lex(); superClass = parseLeftHandSideExpressionAllowCall(); } classBody = parseClassBody(); strict = previousStrict; return classNode.finishClassExpression(id, superClass, classBody); } // 14 Program function parseScriptBody() { var statement, body = [], token, directive, firstRestricted; while (startIndex < length) { token = lookahead; if (token.type !== Token.StringLiteral) { break; } statement = parseStatementListItem(); body.push(statement); if (statement.expression.type !== Syntax.Literal) { // this is not directive break; } directive = source.slice(token.start + 1, token.end - 1); if (directive === 'use strict') { strict = true; if (firstRestricted) { tolerateUnexpectedToken(firstRestricted, Messages.StrictOctalLiteral); } } else { if (!firstRestricted && token.octal) { firstRestricted = token; } } } while (startIndex < length) { statement = parseStatementListItem(); /* istanbul ignore if */ if (typeof statement === 'undefined') { break; } body.push(statement); } return body; } function parseProgram() { var body, node; peek(); node = new Node(); strict = false; body = parseScriptBody(); return node.finishProgram(body); } function filterTokenLocation() { var i, entry, token, tokens = []; for (i = 0; i < extra.tokens.length; ++i) { entry = extra.tokens[i]; token = { type: entry.type, value: entry.value }; if (entry.regex) { token.regex = { pattern: entry.regex.pattern, flags: entry.regex.flags }; } if (extra.range) { token.range = entry.range; } if (extra.loc) { token.loc = entry.loc; } tokens.push(token); } extra.tokens = tokens; } function tokenize(code, options) { var toString, tokens; toString = String; if (typeof code !== 'string' && !(code instanceof String)) { code = toString(code); } source = code; index = 0; lineNumber = (source.length > 0) ? 1 : 0; lineStart = 0; startIndex = index; startLineNumber = lineNumber; startLineStart = lineStart; length = source.length; lookahead = null; state = { allowIn: true, labelSet: {}, inFunctionBody: false, inIteration: false, inSwitch: false, lastCommentStart: -1 }; extra = {}; // Options matching. options = options || {}; // Of course we collect tokens here. options.tokens = true; extra.tokens = []; extra.tokenize = true; // The following two fields are necessary to compute the Regex tokens. extra.openParenToken = -1; extra.openCurlyToken = -1; extra.range = (typeof options.range === 'boolean') && options.range; extra.loc = (typeof options.loc === 'boolean') && options.loc; if (typeof options.comment === 'boolean' && options.comment) { extra.comments = []; } if (typeof options.tolerant === 'boolean' && options.tolerant) { extra.errors = []; } try { peek(); if (lookahead.type === Token.EOF) { return extra.tokens; } lex(); while (lookahead.type !== Token.EOF) { try { lex(); } catch (lexError) { if (extra.errors) { recordError(lexError); // We have to break on the first error // to avoid infinite loops. break; } else { throw lexError; } } } filterTokenLocation(); tokens = extra.tokens; if (typeof extra.comments !== 'undefined') { tokens.comments = extra.comments; } if (typeof extra.errors !== 'undefined') { tokens.errors = extra.errors; } } catch (e) { throw e; } finally { extra = {}; } return tokens; } function parse(code, options) { var program, toString; toString = String; if (typeof code !== 'string' && !(code instanceof String)) { code = toString(code); } source = code; index = 0; lineNumber = (source.length > 0) ? 1 : 0; lineStart = 0; startIndex = index; startLineNumber = lineNumber; startLineStart = lineStart; length = source.length; lookahead = null; state = { allowIn: true, labelSet: {}, inFunctionBody: false, inIteration: false, inSwitch: false, lastCommentStart: -1 }; extra = {}; if (typeof options !== 'undefined') { extra.range = (typeof options.range === 'boolean') && options.range; extra.loc = (typeof options.loc === 'boolean') && options.loc; extra.attachComment = (typeof options.attachComment === 'boolean') && options.attachComment; if (extra.loc && options.source !== null && options.source !== undefined) { extra.source = toString(options.source); } if (typeof options.tokens === 'boolean' && options.tokens) { extra.tokens = []; } if (typeof options.comment === 'boolean' && options.comment) { extra.comments = []; } if (typeof options.tolerant === 'boolean' && options.tolerant) { extra.errors = []; } if (extra.attachComment) { extra.range = true; extra.comments = []; extra.bottomRightStack = []; extra.trailingComments = []; extra.leadingComments = []; } } try { program = parseProgram(); if (typeof extra.comments !== 'undefined') { program.comments = extra.comments; } if (typeof extra.tokens !== 'undefined') { filterTokenLocation(); program.tokens = extra.tokens; } if (typeof extra.errors !== 'undefined') { program.errors = extra.errors; } } catch (e) { throw e; } finally { extra = {}; } return program; } // Sync with *.json manifests. exports.version = '2.1.0'; exports.tokenize = tokenize; exports.parse = parse; // Deep copy. /* istanbul ignore next */ exports.Syntax = (function () { var name, types = {}; if (typeof Object.create === 'function') { types = Object.create(null); } for (name in Syntax) { if (Syntax.hasOwnProperty(name)) { types[name] = Syntax[name]; } } if (typeof Object.freeze === 'function') { Object.freeze(types); } return types; }()); })); /* vim: set sw=4 ts=4 et tw=80 : */ acorn-4.0.4/test/compare/traceur.js000066400000000000000000034254511302576755300172640ustar00rootroot00000000000000(function(global) { 'use strict'; if (global.$traceurRuntime) { return; } var $Object = Object; var $TypeError = TypeError; var $create = $Object.create; var $defineProperties = $Object.defineProperties; var $defineProperty = $Object.defineProperty; var $freeze = $Object.freeze; var $getOwnPropertyDescriptor = $Object.getOwnPropertyDescriptor; var $getOwnPropertyNames = $Object.getOwnPropertyNames; var $keys = $Object.keys; var $hasOwnProperty = $Object.prototype.hasOwnProperty; var $toString = $Object.prototype.toString; var $preventExtensions = Object.preventExtensions; var $seal = Object.seal; var $isExtensible = Object.isExtensible; function nonEnum(value) { return { configurable: true, enumerable: false, value: value, writable: true }; } var types = { void: function voidType() {}, any: function any() {}, string: function string() {}, number: function number() {}, boolean: function boolean() {} }; var method = nonEnum; var counter = 0; function newUniqueString() { return '__$' + Math.floor(Math.random() * 1e9) + '$' + ++counter + '$__'; } var symbolInternalProperty = newUniqueString(); var symbolDescriptionProperty = newUniqueString(); var symbolDataProperty = newUniqueString(); var symbolValues = $create(null); var privateNames = $create(null); function createPrivateName() { var s = newUniqueString(); privateNames[s] = true; return s; } function isSymbol(symbol) { return typeof symbol === 'object' && symbol instanceof SymbolValue; } function typeOf(v) { if (isSymbol(v)) return 'symbol'; return typeof v; } function Symbol(description) { var value = new SymbolValue(description); if (!(this instanceof Symbol)) return value; throw new TypeError('Symbol cannot be new\'ed'); } $defineProperty(Symbol.prototype, 'constructor', nonEnum(Symbol)); $defineProperty(Symbol.prototype, 'toString', method(function() { var symbolValue = this[symbolDataProperty]; if (!getOption('symbols')) return symbolValue[symbolInternalProperty]; if (!symbolValue) throw TypeError('Conversion from symbol to string'); var desc = symbolValue[symbolDescriptionProperty]; if (desc === undefined) desc = ''; return 'Symbol(' + desc + ')'; })); $defineProperty(Symbol.prototype, 'valueOf', method(function() { var symbolValue = this[symbolDataProperty]; if (!symbolValue) throw TypeError('Conversion from symbol to string'); if (!getOption('symbols')) return symbolValue[symbolInternalProperty]; return symbolValue; })); function SymbolValue(description) { var key = newUniqueString(); $defineProperty(this, symbolDataProperty, {value: this}); $defineProperty(this, symbolInternalProperty, {value: key}); $defineProperty(this, symbolDescriptionProperty, {value: description}); freeze(this); symbolValues[key] = this; } $defineProperty(SymbolValue.prototype, 'constructor', nonEnum(Symbol)); $defineProperty(SymbolValue.prototype, 'toString', { value: Symbol.prototype.toString, enumerable: false }); $defineProperty(SymbolValue.prototype, 'valueOf', { value: Symbol.prototype.valueOf, enumerable: false }); var hashProperty = createPrivateName(); var hashPropertyDescriptor = {value: undefined}; var hashObjectProperties = { hash: {value: undefined}, self: {value: undefined} }; var hashCounter = 0; function getOwnHashObject(object) { var hashObject = object[hashProperty]; if (hashObject && hashObject.self === object) return hashObject; if ($isExtensible(object)) { hashObjectProperties.hash.value = hashCounter++; hashObjectProperties.self.value = object; hashPropertyDescriptor.value = $create(null, hashObjectProperties); $defineProperty(object, hashProperty, hashPropertyDescriptor); return hashPropertyDescriptor.value; } return undefined; } function freeze(object) { getOwnHashObject(object); return $freeze.apply(this, arguments); } function preventExtensions(object) { getOwnHashObject(object); return $preventExtensions.apply(this, arguments); } function seal(object) { getOwnHashObject(object); return $seal.apply(this, arguments); } Symbol.iterator = Symbol(); freeze(SymbolValue.prototype); function toProperty(name) { if (isSymbol(name)) return name[symbolInternalProperty]; return name; } function getOwnPropertyNames(object) { var rv = []; var names = $getOwnPropertyNames(object); for (var i = 0; i < names.length; i++) { var name = names[i]; if (!symbolValues[name] && !privateNames[name]) rv.push(name); } return rv; } function getOwnPropertyDescriptor(object, name) { return $getOwnPropertyDescriptor(object, toProperty(name)); } function getOwnPropertySymbols(object) { var rv = []; var names = $getOwnPropertyNames(object); for (var i = 0; i < names.length; i++) { var symbol = symbolValues[names[i]]; if (symbol) rv.push(symbol); } return rv; } function hasOwnProperty(name) { return $hasOwnProperty.call(this, toProperty(name)); } function getOption(name) { return global.traceur && global.traceur.options[name]; } function setProperty(object, name, value) { var sym, desc; if (isSymbol(name)) { sym = name; name = name[symbolInternalProperty]; } object[name] = value; if (sym && (desc = $getOwnPropertyDescriptor(object, name))) $defineProperty(object, name, {enumerable: false}); return value; } function defineProperty(object, name, descriptor) { if (isSymbol(name)) { if (descriptor.enumerable) { descriptor = $create(descriptor, {enumerable: {value: false}}); } name = name[symbolInternalProperty]; } $defineProperty(object, name, descriptor); return object; } function polyfillObject(Object) { $defineProperty(Object, 'defineProperty', {value: defineProperty}); $defineProperty(Object, 'getOwnPropertyNames', {value: getOwnPropertyNames}); $defineProperty(Object, 'getOwnPropertyDescriptor', {value: getOwnPropertyDescriptor}); $defineProperty(Object.prototype, 'hasOwnProperty', {value: hasOwnProperty}); $defineProperty(Object, 'freeze', {value: freeze}); $defineProperty(Object, 'preventExtensions', {value: preventExtensions}); $defineProperty(Object, 'seal', {value: seal}); Object.getOwnPropertySymbols = getOwnPropertySymbols; } function exportStar(object) { for (var i = 1; i < arguments.length; i++) { var names = $getOwnPropertyNames(arguments[i]); for (var j = 0; j < names.length; j++) { var name = names[j]; if (privateNames[name]) continue; (function(mod, name) { $defineProperty(object, name, { get: function() { return mod[name]; }, enumerable: true }); })(arguments[i], names[j]); } } return object; } function isObject(x) { return x != null && (typeof x === 'object' || typeof x === 'function'); } function toObject(x) { if (x == null) throw $TypeError(); return $Object(x); } function assertObject(x) { if (!isObject(x)) throw $TypeError(x + ' is not an Object'); return x; } function setupGlobals(global) { global.Symbol = Symbol; global.Reflect = global.Reflect || {}; global.Reflect.global = global.Reflect.global || global; polyfillObject(global.Object); } setupGlobals(global); global.$traceurRuntime = { assertObject: assertObject, createPrivateName: createPrivateName, exportStar: exportStar, getOwnHashObject: getOwnHashObject, privateNames: privateNames, setProperty: setProperty, setupGlobals: setupGlobals, toObject: toObject, isObject: isObject, toProperty: toProperty, type: types, typeof: typeOf, defineProperties: $defineProperties, defineProperty: $defineProperty, getOwnPropertyDescriptor: $getOwnPropertyDescriptor, getOwnPropertyNames: $getOwnPropertyNames, keys: $keys }; })(typeof global !== 'undefined' ? global : this); (function() { 'use strict'; function spread() { var rv = [], j = 0, iterResult; for (var i = 0; i < arguments.length; i++) { var valueToSpread = arguments[i]; if (!$traceurRuntime.isObject(valueToSpread)) { throw new TypeError('Cannot spread non-object.'); } if (typeof valueToSpread[$traceurRuntime.toProperty(Symbol.iterator)] !== 'function') { throw new TypeError('Cannot spread non-iterable object.'); } var iter = valueToSpread[$traceurRuntime.toProperty(Symbol.iterator)](); while (!(iterResult = iter.next()).done) { rv[j++] = iterResult.value; } } return rv; } $traceurRuntime.spread = spread; })(); (function() { 'use strict'; var $Object = Object; var $TypeError = TypeError; var $create = $Object.create; var $defineProperties = $traceurRuntime.defineProperties; var $defineProperty = $traceurRuntime.defineProperty; var $getOwnPropertyDescriptor = $traceurRuntime.getOwnPropertyDescriptor; var $getOwnPropertyNames = $traceurRuntime.getOwnPropertyNames; var $getPrototypeOf = Object.getPrototypeOf; function superDescriptor(homeObject, name) { var proto = $getPrototypeOf(homeObject); do { var result = $getOwnPropertyDescriptor(proto, name); if (result) return result; proto = $getPrototypeOf(proto); } while (proto); return undefined; } function superCall(self, homeObject, name, args) { return superGet(self, homeObject, name).apply(self, args); } function superGet(self, homeObject, name) { var descriptor = superDescriptor(homeObject, name); if (descriptor) { if (!descriptor.get) return descriptor.value; return descriptor.get.call(self); } return undefined; } function superSet(self, homeObject, name, value) { var descriptor = superDescriptor(homeObject, name); if (descriptor && descriptor.set) { descriptor.set.call(self, value); return value; } throw $TypeError("super has no setter '" + name + "'."); } function getDescriptors(object) { var descriptors = {}, name, names = $getOwnPropertyNames(object); for (var i = 0; i < names.length; i++) { var name = names[i]; descriptors[name] = $getOwnPropertyDescriptor(object, name); } return descriptors; } function createClass(ctor, object, staticObject, superClass) { $defineProperty(object, 'constructor', { value: ctor, configurable: true, enumerable: false, writable: true }); if (arguments.length > 3) { if (typeof superClass === 'function') ctor.__proto__ = superClass; ctor.prototype = $create(getProtoParent(superClass), getDescriptors(object)); } else { ctor.prototype = object; } $defineProperty(ctor, 'prototype', { configurable: false, writable: false }); return $defineProperties(ctor, getDescriptors(staticObject)); } function getProtoParent(superClass) { if (typeof superClass === 'function') { var prototype = superClass.prototype; if ($Object(prototype) === prototype || prototype === null) return superClass.prototype; throw new $TypeError('super prototype must be an Object or null'); } if (superClass === null) return null; throw new $TypeError('Super expression must either be null or a function'); } function defaultSuperCall(self, homeObject, args) { if ($getPrototypeOf(homeObject) !== null) superCall(self, homeObject, 'constructor', args); } $traceurRuntime.createClass = createClass; $traceurRuntime.defaultSuperCall = defaultSuperCall; $traceurRuntime.superCall = superCall; $traceurRuntime.superGet = superGet; $traceurRuntime.superSet = superSet; })(); (function() { 'use strict'; var createPrivateName = $traceurRuntime.createPrivateName; var $defineProperties = $traceurRuntime.defineProperties; var $defineProperty = $traceurRuntime.defineProperty; var $create = Object.create; var $TypeError = TypeError; function nonEnum(value) { return { configurable: true, enumerable: false, value: value, writable: true }; } var ST_NEWBORN = 0; var ST_EXECUTING = 1; var ST_SUSPENDED = 2; var ST_CLOSED = 3; var END_STATE = -2; var RETHROW_STATE = -3; function getInternalError(state) { return new Error('Traceur compiler bug: invalid state in state machine: ' + state); } function GeneratorContext() { this.state = 0; this.GState = ST_NEWBORN; this.storedException = undefined; this.finallyFallThrough = undefined; this.sent_ = undefined; this.returnValue = undefined; this.tryStack_ = []; } GeneratorContext.prototype = { pushTry: function(catchState, finallyState) { if (finallyState !== null) { var finallyFallThrough = null; for (var i = this.tryStack_.length - 1; i >= 0; i--) { if (this.tryStack_[i].catch !== undefined) { finallyFallThrough = this.tryStack_[i].catch; break; } } if (finallyFallThrough === null) finallyFallThrough = RETHROW_STATE; this.tryStack_.push({ finally: finallyState, finallyFallThrough: finallyFallThrough }); } if (catchState !== null) { this.tryStack_.push({catch: catchState}); } }, popTry: function() { this.tryStack_.pop(); }, get sent() { this.maybeThrow(); return this.sent_; }, set sent(v) { this.sent_ = v; }, get sentIgnoreThrow() { return this.sent_; }, maybeThrow: function() { if (this.action === 'throw') { this.action = 'next'; throw this.sent_; } }, end: function() { switch (this.state) { case END_STATE: return this; case RETHROW_STATE: throw this.storedException; default: throw getInternalError(this.state); } }, handleException: function(ex) { this.GState = ST_CLOSED; this.state = END_STATE; throw ex; } }; function nextOrThrow(ctx, moveNext, action, x) { switch (ctx.GState) { case ST_EXECUTING: throw new Error(("\"" + action + "\" on executing generator")); case ST_CLOSED: if (action == 'next') { return { value: undefined, done: true }; } throw x; case ST_NEWBORN: if (action === 'throw') { ctx.GState = ST_CLOSED; throw x; } if (x !== undefined) throw $TypeError('Sent value to newborn generator'); case ST_SUSPENDED: ctx.GState = ST_EXECUTING; ctx.action = action; ctx.sent = x; var value = moveNext(ctx); var done = value === ctx; if (done) value = ctx.returnValue; ctx.GState = done ? ST_CLOSED : ST_SUSPENDED; return { value: value, done: done }; } } var ctxName = createPrivateName(); var moveNextName = createPrivateName(); function GeneratorFunction() {} function GeneratorFunctionPrototype() {} GeneratorFunction.prototype = GeneratorFunctionPrototype; $defineProperty(GeneratorFunctionPrototype, 'constructor', nonEnum(GeneratorFunction)); GeneratorFunctionPrototype.prototype = { constructor: GeneratorFunctionPrototype, next: function(v) { return nextOrThrow(this[ctxName], this[moveNextName], 'next', v); }, throw: function(v) { return nextOrThrow(this[ctxName], this[moveNextName], 'throw', v); } }; $defineProperties(GeneratorFunctionPrototype.prototype, { constructor: {enumerable: false}, next: {enumerable: false}, throw: {enumerable: false} }); Object.defineProperty(GeneratorFunctionPrototype.prototype, Symbol.iterator, nonEnum(function() { return this; })); function createGeneratorInstance(innerFunction, functionObject, self) { var moveNext = getMoveNext(innerFunction, self); var ctx = new GeneratorContext(); var object = $create(functionObject.prototype); object[ctxName] = ctx; object[moveNextName] = moveNext; return object; } function initGeneratorFunction(functionObject) { functionObject.prototype = $create(GeneratorFunctionPrototype.prototype); functionObject.__proto__ = GeneratorFunctionPrototype; return functionObject; } function AsyncFunctionContext() { GeneratorContext.call(this); this.err = undefined; var ctx = this; ctx.result = new Promise(function(resolve, reject) { ctx.resolve = resolve; ctx.reject = reject; }); } AsyncFunctionContext.prototype = $create(GeneratorContext.prototype); AsyncFunctionContext.prototype.end = function() { switch (this.state) { case END_STATE: this.resolve(this.returnValue); break; case RETHROW_STATE: this.reject(this.storedException); break; default: this.reject(getInternalError(this.state)); } }; AsyncFunctionContext.prototype.handleException = function() { this.state = RETHROW_STATE; }; function asyncWrap(innerFunction, self) { var moveNext = getMoveNext(innerFunction, self); var ctx = new AsyncFunctionContext(); ctx.createCallback = function(newState) { return function(value) { ctx.state = newState; ctx.value = value; moveNext(ctx); }; }; ctx.errback = function(err) { handleCatch(ctx, err); moveNext(ctx); }; moveNext(ctx); return ctx.result; } function getMoveNext(innerFunction, self) { return function(ctx) { while (true) { try { return innerFunction.call(self, ctx); } catch (ex) { handleCatch(ctx, ex); } } }; } function handleCatch(ctx, ex) { ctx.storedException = ex; var last = ctx.tryStack_[ctx.tryStack_.length - 1]; if (!last) { ctx.handleException(ex); return; } ctx.state = last.catch !== undefined ? last.catch : last.finally; if (last.finallyFallThrough !== undefined) ctx.finallyFallThrough = last.finallyFallThrough; } $traceurRuntime.asyncWrap = asyncWrap; $traceurRuntime.initGeneratorFunction = initGeneratorFunction; $traceurRuntime.createGeneratorInstance = createGeneratorInstance; })(); (function() { function buildFromEncodedParts(opt_scheme, opt_userInfo, opt_domain, opt_port, opt_path, opt_queryData, opt_fragment) { var out = []; if (opt_scheme) { out.push(opt_scheme, ':'); } if (opt_domain) { out.push('//'); if (opt_userInfo) { out.push(opt_userInfo, '@'); } out.push(opt_domain); if (opt_port) { out.push(':', opt_port); } } if (opt_path) { out.push(opt_path); } if (opt_queryData) { out.push('?', opt_queryData); } if (opt_fragment) { out.push('#', opt_fragment); } return out.join(''); } ; var splitRe = new RegExp('^' + '(?:' + '([^:/?#.]+)' + ':)?' + '(?://' + '(?:([^/?#]*)@)?' + '([\\w\\d\\-\\u0100-\\uffff.%]*)' + '(?::([0-9]+))?' + ')?' + '([^?#]+)?' + '(?:\\?([^#]*))?' + '(?:#(.*))?' + '$'); var ComponentIndex = { SCHEME: 1, USER_INFO: 2, DOMAIN: 3, PORT: 4, PATH: 5, QUERY_DATA: 6, FRAGMENT: 7 }; function split(uri) { return (uri.match(splitRe)); } function removeDotSegments(path) { if (path === '/') return '/'; var leadingSlash = path[0] === '/' ? '/' : ''; var trailingSlash = path.slice(-1) === '/' ? '/' : ''; var segments = path.split('/'); var out = []; var up = 0; for (var pos = 0; pos < segments.length; pos++) { var segment = segments[pos]; switch (segment) { case '': case '.': break; case '..': if (out.length) out.pop(); else up++; break; default: out.push(segment); } } if (!leadingSlash) { while (up-- > 0) { out.unshift('..'); } if (out.length === 0) out.push('.'); } return leadingSlash + out.join('/') + trailingSlash; } function joinAndCanonicalizePath(parts) { var path = parts[ComponentIndex.PATH] || ''; path = removeDotSegments(path); parts[ComponentIndex.PATH] = path; return buildFromEncodedParts(parts[ComponentIndex.SCHEME], parts[ComponentIndex.USER_INFO], parts[ComponentIndex.DOMAIN], parts[ComponentIndex.PORT], parts[ComponentIndex.PATH], parts[ComponentIndex.QUERY_DATA], parts[ComponentIndex.FRAGMENT]); } function canonicalizeUrl(url) { var parts = split(url); return joinAndCanonicalizePath(parts); } function resolveUrl(base, url) { var parts = split(url); var baseParts = split(base); if (parts[ComponentIndex.SCHEME]) { return joinAndCanonicalizePath(parts); } else { parts[ComponentIndex.SCHEME] = baseParts[ComponentIndex.SCHEME]; } for (var i = ComponentIndex.SCHEME; i <= ComponentIndex.PORT; i++) { if (!parts[i]) { parts[i] = baseParts[i]; } } if (parts[ComponentIndex.PATH][0] == '/') { return joinAndCanonicalizePath(parts); } var path = baseParts[ComponentIndex.PATH]; var index = path.lastIndexOf('/'); path = path.slice(0, index + 1) + parts[ComponentIndex.PATH]; parts[ComponentIndex.PATH] = path; return joinAndCanonicalizePath(parts); } function isAbsolute(name) { if (!name) return false; if (name[0] === '/') return true; var parts = split(name); if (parts[ComponentIndex.SCHEME]) return true; return false; } $traceurRuntime.canonicalizeUrl = canonicalizeUrl; $traceurRuntime.isAbsolute = isAbsolute; $traceurRuntime.removeDotSegments = removeDotSegments; $traceurRuntime.resolveUrl = resolveUrl; })(); (function(global) { 'use strict'; var $__2 = $traceurRuntime.assertObject($traceurRuntime), canonicalizeUrl = $__2.canonicalizeUrl, resolveUrl = $__2.resolveUrl, isAbsolute = $__2.isAbsolute; var moduleInstantiators = Object.create(null); var baseURL; if (global.location && global.location.href) baseURL = resolveUrl(global.location.href, './'); else baseURL = ''; var UncoatedModuleEntry = function UncoatedModuleEntry(url, uncoatedModule) { this.url = url; this.value_ = uncoatedModule; }; ($traceurRuntime.createClass)(UncoatedModuleEntry, {}, {}); var ModuleEvaluationError = function ModuleEvaluationError(erroneousModuleName, cause) { this.message = this.constructor.name + (cause ? ': \'' + cause + '\'' : '') + ' in ' + erroneousModuleName; }; ($traceurRuntime.createClass)(ModuleEvaluationError, {loadedBy: function(moduleName) { this.message += '\n loaded by ' + moduleName; }}, {}, Error); var UncoatedModuleInstantiator = function UncoatedModuleInstantiator(url, func) { $traceurRuntime.superCall(this, $UncoatedModuleInstantiator.prototype, "constructor", [url, null]); this.func = func; }; var $UncoatedModuleInstantiator = UncoatedModuleInstantiator; ($traceurRuntime.createClass)(UncoatedModuleInstantiator, {getUncoatedModule: function() { if (this.value_) return this.value_; try { return this.value_ = this.func.call(global); } catch (ex) { if (ex instanceof ModuleEvaluationError) { ex.loadedBy(this.url); throw ex; } throw new ModuleEvaluationError(this.url, ex); } }}, {}, UncoatedModuleEntry); function getUncoatedModuleInstantiator(name) { if (!name) return; var url = ModuleStore.normalize(name); return moduleInstantiators[url]; } ; var moduleInstances = Object.create(null); var liveModuleSentinel = {}; function Module(uncoatedModule) { var isLive = arguments[1]; var coatedModule = Object.create(null); Object.getOwnPropertyNames(uncoatedModule).forEach((function(name) { var getter, value; if (isLive === liveModuleSentinel) { var descr = Object.getOwnPropertyDescriptor(uncoatedModule, name); if (descr.get) getter = descr.get; } if (!getter) { value = uncoatedModule[name]; getter = function() { return value; }; } Object.defineProperty(coatedModule, name, { get: getter, enumerable: true }); })); Object.preventExtensions(coatedModule); return coatedModule; } var ModuleStore = { normalize: function(name, refererName, refererAddress) { if (typeof name !== "string") throw new TypeError("module name must be a string, not " + typeof name); if (isAbsolute(name)) return canonicalizeUrl(name); if (/[^\.]\/\.\.\//.test(name)) { throw new Error('module name embeds /../: ' + name); } if (name[0] === '.' && refererName) return resolveUrl(refererName, name); return canonicalizeUrl(name); }, get: function(normalizedName) { var m = getUncoatedModuleInstantiator(normalizedName); if (!m) return undefined; var moduleInstance = moduleInstances[m.url]; if (moduleInstance) return moduleInstance; moduleInstance = Module(m.getUncoatedModule(), liveModuleSentinel); return moduleInstances[m.url] = moduleInstance; }, set: function(normalizedName, module) { normalizedName = String(normalizedName); moduleInstantiators[normalizedName] = new UncoatedModuleInstantiator(normalizedName, (function() { return module; })); moduleInstances[normalizedName] = module; }, get baseURL() { return baseURL; }, set baseURL(v) { baseURL = String(v); }, registerModule: function(name, func) { var normalizedName = ModuleStore.normalize(name); if (moduleInstantiators[normalizedName]) throw new Error('duplicate module named ' + normalizedName); moduleInstantiators[normalizedName] = new UncoatedModuleInstantiator(normalizedName, func); }, bundleStore: Object.create(null), register: function(name, deps, func) { if (!deps || !deps.length && !func.length) { this.registerModule(name, func); } else { this.bundleStore[name] = { deps: deps, execute: function() { var $__0 = arguments; var depMap = {}; deps.forEach((function(dep, index) { return depMap[dep] = $__0[index]; })); var registryEntry = func.call(this, depMap); registryEntry.execute.call(this); return registryEntry.exports; } }; } }, getAnonymousModule: function(func) { return new Module(func.call(global), liveModuleSentinel); }, getForTesting: function(name) { var $__0 = this; if (!this.testingPrefix_) { Object.keys(moduleInstances).some((function(key) { var m = /(traceur@[^\/]*\/)/.exec(key); if (m) { $__0.testingPrefix_ = m[1]; return true; } })); } return this.get(this.testingPrefix_ + name); } }; ModuleStore.set('@traceur/src/runtime/ModuleStore', new Module({ModuleStore: ModuleStore})); var setupGlobals = $traceurRuntime.setupGlobals; $traceurRuntime.setupGlobals = function(global) { setupGlobals(global); }; $traceurRuntime.ModuleStore = ModuleStore; global.System = { register: ModuleStore.register.bind(ModuleStore), get: ModuleStore.get, set: ModuleStore.set, normalize: ModuleStore.normalize }; $traceurRuntime.getModuleImpl = function(name) { var instantiator = getUncoatedModuleInstantiator(name); return instantiator && instantiator.getUncoatedModule(); }; })(typeof global !== 'undefined' ? global : this); System.register("traceur@0.0.52/src/runtime/polyfills/utils", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/runtime/polyfills/utils"; var $ceil = Math.ceil; var $floor = Math.floor; var $isFinite = isFinite; var $isNaN = isNaN; var $pow = Math.pow; var $min = Math.min; var toObject = $traceurRuntime.toObject; function toUint32(x) { return x >>> 0; } function isObject(x) { return x && (typeof x === 'object' || typeof x === 'function'); } function isCallable(x) { return typeof x === 'function'; } function isNumber(x) { return typeof x === 'number'; } function toInteger(x) { x = +x; if ($isNaN(x)) return 0; if (x === 0 || !$isFinite(x)) return x; return x > 0 ? $floor(x) : $ceil(x); } var MAX_SAFE_LENGTH = $pow(2, 53) - 1; function toLength(x) { var len = toInteger(x); return len < 0 ? 0 : $min(len, MAX_SAFE_LENGTH); } function checkIterable(x) { return !isObject(x) ? undefined : x[Symbol.iterator]; } function isConstructor(x) { return isCallable(x); } return { get toObject() { return toObject; }, get toUint32() { return toUint32; }, get isObject() { return isObject; }, get isCallable() { return isCallable; }, get isNumber() { return isNumber; }, get toInteger() { return toInteger; }, get toLength() { return toLength; }, get checkIterable() { return checkIterable; }, get isConstructor() { return isConstructor; } }; }); System.register("traceur@0.0.52/src/runtime/polyfills/Array", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/runtime/polyfills/Array"; var $__3 = System.get("traceur@0.0.52/src/runtime/polyfills/utils"), isCallable = $__3.isCallable, isConstructor = $__3.isConstructor, checkIterable = $__3.checkIterable, toInteger = $__3.toInteger, toLength = $__3.toLength, toObject = $__3.toObject; function from(arrLike) { var mapFn = arguments[1]; var thisArg = arguments[2]; var C = this; var items = toObject(arrLike); var mapping = mapFn !== undefined; var k = 0; var arr, len; if (mapping && !isCallable(mapFn)) { throw TypeError(); } if (checkIterable(items)) { arr = isConstructor(C) ? new C() : []; for (var $__4 = items[Symbol.iterator](), $__5; !($__5 = $__4.next()).done; ) { var item = $__5.value; { if (mapping) { arr[k] = mapFn.call(thisArg, item, k); } else { arr[k] = item; } k++; } } arr.length = k; return arr; } len = toLength(items.length); arr = isConstructor(C) ? new C(len) : new Array(len); for (; k < len; k++) { if (mapping) { arr[k] = mapFn.call(thisArg, items[k], k); } else { arr[k] = items[k]; } } arr.length = len; return arr; } function fill(value) { var start = arguments[1] !== (void 0) ? arguments[1] : 0; var end = arguments[2]; var object = toObject(this); var len = toLength(object.length); var fillStart = toInteger(start); var fillEnd = end !== undefined ? toInteger(end) : len; fillStart = fillStart < 0 ? Math.max(len + fillStart, 0) : Math.min(fillStart, len); fillEnd = fillEnd < 0 ? Math.max(len + fillEnd, 0) : Math.min(fillEnd, len); while (fillStart < fillEnd) { object[fillStart] = value; fillStart++; } return object; } function find(predicate) { var thisArg = arguments[1]; return findHelper(this, predicate, thisArg); } function findIndex(predicate) { var thisArg = arguments[1]; return findHelper(this, predicate, thisArg, true); } function findHelper(self, predicate) { var thisArg = arguments[2]; var returnIndex = arguments[3] !== (void 0) ? arguments[3] : false; var object = toObject(self); var len = toLength(object.length); if (!isCallable(predicate)) { throw TypeError(); } for (var i = 0; i < len; i++) { if (i in object) { var value = object[i]; if (predicate.call(thisArg, value, i, object)) { return returnIndex ? i : value; } } } return returnIndex ? -1 : undefined; } return { get from() { return from; }, get fill() { return fill; }, get find() { return find; }, get findIndex() { return findIndex; } }; }); System.register("traceur@0.0.52/src/runtime/polyfills/ArrayIterator", [], function() { "use strict"; var $__8; var __moduleName = "traceur@0.0.52/src/runtime/polyfills/ArrayIterator"; var $__6 = System.get("traceur@0.0.52/src/runtime/polyfills/utils"), toObject = $__6.toObject, toUint32 = $__6.toUint32; var ARRAY_ITERATOR_KIND_KEYS = 1; var ARRAY_ITERATOR_KIND_VALUES = 2; var ARRAY_ITERATOR_KIND_ENTRIES = 3; var ArrayIterator = function ArrayIterator() {}; ($traceurRuntime.createClass)(ArrayIterator, ($__8 = {}, Object.defineProperty($__8, "next", { value: function() { var iterator = toObject(this); var array = iterator.iteratorObject_; if (!array) { throw new TypeError('Object is not an ArrayIterator'); } var index = iterator.arrayIteratorNextIndex_; var itemKind = iterator.arrayIterationKind_; var length = toUint32(array.length); if (index >= length) { iterator.arrayIteratorNextIndex_ = Infinity; return createIteratorResultObject(undefined, true); } iterator.arrayIteratorNextIndex_ = index + 1; if (itemKind == ARRAY_ITERATOR_KIND_VALUES) return createIteratorResultObject(array[index], false); if (itemKind == ARRAY_ITERATOR_KIND_ENTRIES) return createIteratorResultObject([index, array[index]], false); return createIteratorResultObject(index, false); }, configurable: true, enumerable: true, writable: true }), Object.defineProperty($__8, Symbol.iterator, { value: function() { return this; }, configurable: true, enumerable: true, writable: true }), $__8), {}); function createArrayIterator(array, kind) { var object = toObject(array); var iterator = new ArrayIterator; iterator.iteratorObject_ = object; iterator.arrayIteratorNextIndex_ = 0; iterator.arrayIterationKind_ = kind; return iterator; } function createIteratorResultObject(value, done) { return { value: value, done: done }; } function entries() { return createArrayIterator(this, ARRAY_ITERATOR_KIND_ENTRIES); } function keys() { return createArrayIterator(this, ARRAY_ITERATOR_KIND_KEYS); } function values() { return createArrayIterator(this, ARRAY_ITERATOR_KIND_VALUES); } return { get entries() { return entries; }, get keys() { return keys; }, get values() { return values; } }; }); System.register("traceur@0.0.52/src/runtime/polyfills/Map", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/runtime/polyfills/Map"; var isObject = System.get("traceur@0.0.52/src/runtime/polyfills/utils").isObject; var getOwnHashObject = $traceurRuntime.getOwnHashObject; var $hasOwnProperty = Object.prototype.hasOwnProperty; var deletedSentinel = {}; function lookupIndex(map, key) { if (isObject(key)) { var hashObject = getOwnHashObject(key); return hashObject && map.objectIndex_[hashObject.hash]; } if (typeof key === 'string') return map.stringIndex_[key]; return map.primitiveIndex_[key]; } function initMap(map) { map.entries_ = []; map.objectIndex_ = Object.create(null); map.stringIndex_ = Object.create(null); map.primitiveIndex_ = Object.create(null); map.deletedCount_ = 0; } var Map = function Map() { var iterable = arguments[0]; if (!isObject(this)) throw new TypeError('Map called on incompatible type'); if ($hasOwnProperty.call(this, 'entries_')) { throw new TypeError('Map can not be reentrantly initialised'); } initMap(this); if (iterable !== null && iterable !== undefined) { for (var $__11 = iterable[Symbol.iterator](), $__12; !($__12 = $__11.next()).done; ) { var $__13 = $traceurRuntime.assertObject($__12.value), key = $__13[0], value = $__13[1]; { this.set(key, value); } } } }; ($traceurRuntime.createClass)(Map, { get size() { return this.entries_.length / 2 - this.deletedCount_; }, get: function(key) { var index = lookupIndex(this, key); if (index !== undefined) return this.entries_[index + 1]; }, set: function(key, value) { var objectMode = isObject(key); var stringMode = typeof key === 'string'; var index = lookupIndex(this, key); if (index !== undefined) { this.entries_[index + 1] = value; } else { index = this.entries_.length; this.entries_[index] = key; this.entries_[index + 1] = value; if (objectMode) { var hashObject = getOwnHashObject(key); var hash = hashObject.hash; this.objectIndex_[hash] = index; } else if (stringMode) { this.stringIndex_[key] = index; } else { this.primitiveIndex_[key] = index; } } return this; }, has: function(key) { return lookupIndex(this, key) !== undefined; }, delete: function(key) { var objectMode = isObject(key); var stringMode = typeof key === 'string'; var index; var hash; if (objectMode) { var hashObject = getOwnHashObject(key); if (hashObject) { index = this.objectIndex_[hash = hashObject.hash]; delete this.objectIndex_[hash]; } } else if (stringMode) { index = this.stringIndex_[key]; delete this.stringIndex_[key]; } else { index = this.primitiveIndex_[key]; delete this.primitiveIndex_[key]; } if (index !== undefined) { this.entries_[index] = deletedSentinel; this.entries_[index + 1] = undefined; this.deletedCount_++; } }, clear: function() { initMap(this); }, forEach: function(callbackFn) { var thisArg = arguments[1]; for (var i = 0, len = this.entries_.length; i < len; i += 2) { var key = this.entries_[i]; var value = this.entries_[i + 1]; if (key === deletedSentinel) continue; callbackFn.call(thisArg, value, key, this); } }, entries: $traceurRuntime.initGeneratorFunction(function $__14() { var i, len, key, value; return $traceurRuntime.createGeneratorInstance(function($ctx) { while (true) switch ($ctx.state) { case 0: i = 0, len = this.entries_.length; $ctx.state = 12; break; case 12: $ctx.state = (i < len) ? 8 : -2; break; case 4: i += 2; $ctx.state = 12; break; case 8: key = this.entries_[i]; value = this.entries_[i + 1]; $ctx.state = 9; break; case 9: $ctx.state = (key === deletedSentinel) ? 4 : 6; break; case 6: $ctx.state = 2; return [key, value]; case 2: $ctx.maybeThrow(); $ctx.state = 4; break; default: return $ctx.end(); } }, $__14, this); }), keys: $traceurRuntime.initGeneratorFunction(function $__15() { var i, len, key, value; return $traceurRuntime.createGeneratorInstance(function($ctx) { while (true) switch ($ctx.state) { case 0: i = 0, len = this.entries_.length; $ctx.state = 12; break; case 12: $ctx.state = (i < len) ? 8 : -2; break; case 4: i += 2; $ctx.state = 12; break; case 8: key = this.entries_[i]; value = this.entries_[i + 1]; $ctx.state = 9; break; case 9: $ctx.state = (key === deletedSentinel) ? 4 : 6; break; case 6: $ctx.state = 2; return key; case 2: $ctx.maybeThrow(); $ctx.state = 4; break; default: return $ctx.end(); } }, $__15, this); }), values: $traceurRuntime.initGeneratorFunction(function $__16() { var i, len, key, value; return $traceurRuntime.createGeneratorInstance(function($ctx) { while (true) switch ($ctx.state) { case 0: i = 0, len = this.entries_.length; $ctx.state = 12; break; case 12: $ctx.state = (i < len) ? 8 : -2; break; case 4: i += 2; $ctx.state = 12; break; case 8: key = this.entries_[i]; value = this.entries_[i + 1]; $ctx.state = 9; break; case 9: $ctx.state = (key === deletedSentinel) ? 4 : 6; break; case 6: $ctx.state = 2; return value; case 2: $ctx.maybeThrow(); $ctx.state = 4; break; default: return $ctx.end(); } }, $__16, this); }) }, {}); Object.defineProperty(Map.prototype, Symbol.iterator, { configurable: true, writable: true, value: Map.prototype.entries }); return {get Map() { return Map; }}; }); System.register("traceur@0.0.52/src/runtime/polyfills/Number", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/runtime/polyfills/Number"; var $__17 = System.get("traceur@0.0.52/src/runtime/polyfills/utils"), isNumber = $__17.isNumber, toInteger = $__17.toInteger; var $abs = Math.abs; var $isFinite = isFinite; var $isNaN = isNaN; var MAX_SAFE_INTEGER = Math.pow(2, 53) - 1; var MIN_SAFE_INTEGER = -Math.pow(2, 53) + 1; var EPSILON = Math.pow(2, -52); function NumberIsFinite(number) { return isNumber(number) && $isFinite(number); } ; function isInteger(number) { return NumberIsFinite(number) && toInteger(number) === number; } function NumberIsNaN(number) { return isNumber(number) && $isNaN(number); } ; function isSafeInteger(number) { if (NumberIsFinite(number)) { var integral = toInteger(number); if (integral === number) return $abs(integral) <= MAX_SAFE_INTEGER; } return false; } return { get MAX_SAFE_INTEGER() { return MAX_SAFE_INTEGER; }, get MIN_SAFE_INTEGER() { return MIN_SAFE_INTEGER; }, get EPSILON() { return EPSILON; }, get isFinite() { return NumberIsFinite; }, get isInteger() { return isInteger; }, get isNaN() { return NumberIsNaN; }, get isSafeInteger() { return isSafeInteger; } }; }); System.register("traceur@0.0.52/src/runtime/polyfills/Object", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/runtime/polyfills/Object"; var $__18 = $traceurRuntime.assertObject($traceurRuntime), defineProperty = $__18.defineProperty, getOwnPropertyDescriptor = $__18.getOwnPropertyDescriptor, getOwnPropertyNames = $__18.getOwnPropertyNames, keys = $__18.keys, privateNames = $__18.privateNames; function is(left, right) { if (left === right) return left !== 0 || 1 / left === 1 / right; return left !== left && right !== right; } function assign(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; var props = keys(source); var p, length = props.length; for (p = 0; p < length; p++) { var name = props[p]; if (privateNames[name]) continue; target[name] = source[name]; } } return target; } function mixin(target, source) { var props = getOwnPropertyNames(source); var p, descriptor, length = props.length; for (p = 0; p < length; p++) { var name = props[p]; if (privateNames[name]) continue; descriptor = getOwnPropertyDescriptor(source, props[p]); defineProperty(target, props[p], descriptor); } return target; } return { get is() { return is; }, get assign() { return assign; }, get mixin() { return mixin; } }; }); System.register("traceur@0.0.52/node_modules/rsvp/lib/rsvp/asap", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/node_modules/rsvp/lib/rsvp/asap"; var length = 0; function asap(callback, arg) { queue[length] = callback; queue[length + 1] = arg; length += 2; if (length === 2) { scheduleFlush(); } } var $__default = asap; var browserGlobal = (typeof window !== 'undefined') ? window : {}; var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver; var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined'; function useNextTick() { return function() { process.nextTick(flush); }; } function useMutationObserver() { var iterations = 0; var observer = new BrowserMutationObserver(flush); var node = document.createTextNode(''); observer.observe(node, {characterData: true}); return function() { node.data = (iterations = ++iterations % 2); }; } function useMessageChannel() { var channel = new MessageChannel(); channel.port1.onmessage = flush; return function() { channel.port2.postMessage(0); }; } function useSetTimeout() { return function() { setTimeout(flush, 1); }; } var queue = new Array(1000); function flush() { for (var i = 0; i < length; i += 2) { var callback = queue[i]; var arg = queue[i + 1]; callback(arg); queue[i] = undefined; queue[i + 1] = undefined; } length = 0; } var scheduleFlush; if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') { scheduleFlush = useNextTick(); } else if (BrowserMutationObserver) { scheduleFlush = useMutationObserver(); } else if (isWorker) { scheduleFlush = useMessageChannel(); } else { scheduleFlush = useSetTimeout(); } return {get default() { return $__default; }}; }); System.register("traceur@0.0.52/src/runtime/polyfills/Promise", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/runtime/polyfills/Promise"; var async = System.get("traceur@0.0.52/node_modules/rsvp/lib/rsvp/asap").default; var promiseRaw = {}; function isPromise(x) { return x && typeof x === 'object' && x.status_ !== undefined; } function idResolveHandler(x) { return x; } function idRejectHandler(x) { throw x; } function chain(promise) { var onResolve = arguments[1] !== (void 0) ? arguments[1] : idResolveHandler; var onReject = arguments[2] !== (void 0) ? arguments[2] : idRejectHandler; var deferred = getDeferred(promise.constructor); switch (promise.status_) { case undefined: throw TypeError; case 0: promise.onResolve_.push(onResolve, deferred); promise.onReject_.push(onReject, deferred); break; case +1: promiseEnqueue(promise.value_, [onResolve, deferred]); break; case -1: promiseEnqueue(promise.value_, [onReject, deferred]); break; } return deferred.promise; } function getDeferred(C) { if (this === $Promise) { var promise = promiseInit(new $Promise(promiseRaw)); return { promise: promise, resolve: (function(x) { promiseResolve(promise, x); }), reject: (function(r) { promiseReject(promise, r); }) }; } else { var result = {}; result.promise = new C((function(resolve, reject) { result.resolve = resolve; result.reject = reject; })); return result; } } function promiseSet(promise, status, value, onResolve, onReject) { promise.status_ = status; promise.value_ = value; promise.onResolve_ = onResolve; promise.onReject_ = onReject; return promise; } function promiseInit(promise) { return promiseSet(promise, 0, undefined, [], []); } var Promise = function Promise(resolver) { if (resolver === promiseRaw) return; if (typeof resolver !== 'function') throw new TypeError; var promise = promiseInit(this); try { resolver((function(x) { promiseResolve(promise, x); }), (function(r) { promiseReject(promise, r); })); } catch (e) { promiseReject(promise, e); } }; ($traceurRuntime.createClass)(Promise, { catch: function(onReject) { return this.then(undefined, onReject); }, then: function(onResolve, onReject) { if (typeof onResolve !== 'function') onResolve = idResolveHandler; if (typeof onReject !== 'function') onReject = idRejectHandler; var that = this; var constructor = this.constructor; return chain(this, function(x) { x = promiseCoerce(constructor, x); return x === that ? onReject(new TypeError) : isPromise(x) ? x.then(onResolve, onReject) : onResolve(x); }, onReject); } }, { resolve: function(x) { if (this === $Promise) { return promiseSet(new $Promise(promiseRaw), +1, x); } else { return new this(function(resolve, reject) { resolve(x); }); } }, reject: function(r) { if (this === $Promise) { return promiseSet(new $Promise(promiseRaw), -1, r); } else { return new this((function(resolve, reject) { reject(r); })); } }, cast: function(x) { if (x instanceof this) return x; if (isPromise(x)) { var result = getDeferred(this); chain(x, result.resolve, result.reject); return result.promise; } return this.resolve(x); }, all: function(values) { var deferred = getDeferred(this); var resolutions = []; try { var count = values.length; if (count === 0) { deferred.resolve(resolutions); } else { for (var i = 0; i < values.length; i++) { this.resolve(values[i]).then(function(i, x) { resolutions[i] = x; if (--count === 0) deferred.resolve(resolutions); }.bind(undefined, i), (function(r) { deferred.reject(r); })); } } } catch (e) { deferred.reject(e); } return deferred.promise; }, race: function(values) { var deferred = getDeferred(this); try { for (var i = 0; i < values.length; i++) { this.resolve(values[i]).then((function(x) { deferred.resolve(x); }), (function(r) { deferred.reject(r); })); } } catch (e) { deferred.reject(e); } return deferred.promise; } }); var $Promise = Promise; var $PromiseReject = $Promise.reject; function promiseResolve(promise, x) { promiseDone(promise, +1, x, promise.onResolve_); } function promiseReject(promise, r) { promiseDone(promise, -1, r, promise.onReject_); } function promiseDone(promise, status, value, reactions) { if (promise.status_ !== 0) return; promiseEnqueue(value, reactions); promiseSet(promise, status, value); } function promiseEnqueue(value, tasks) { async((function() { for (var i = 0; i < tasks.length; i += 2) { promiseHandle(value, tasks[i], tasks[i + 1]); } })); } function promiseHandle(value, handler, deferred) { try { var result = handler(value); if (result === deferred.promise) throw new TypeError; else if (isPromise(result)) chain(result, deferred.resolve, deferred.reject); else deferred.resolve(result); } catch (e) { try { deferred.reject(e); } catch (e) {} } } var thenableSymbol = '@@thenable'; function isObject(x) { return x && (typeof x === 'object' || typeof x === 'function'); } function promiseCoerce(constructor, x) { if (!isPromise(x) && isObject(x)) { var then; try { then = x.then; } catch (r) { var promise = $PromiseReject.call(constructor, r); x[thenableSymbol] = promise; return promise; } if (typeof then === 'function') { var p = x[thenableSymbol]; if (p) { return p; } else { var deferred = getDeferred(constructor); x[thenableSymbol] = deferred.promise; try { then.call(x, deferred.resolve, deferred.reject); } catch (r) { deferred.reject(r); } return deferred.promise; } } } return x; } return {get Promise() { return Promise; }}; }); System.register("traceur@0.0.52/src/runtime/polyfills/Set", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/runtime/polyfills/Set"; var isObject = System.get("traceur@0.0.52/src/runtime/polyfills/utils").isObject; var Map = System.get("traceur@0.0.52/src/runtime/polyfills/Map").Map; var getOwnHashObject = $traceurRuntime.getOwnHashObject; var $hasOwnProperty = Object.prototype.hasOwnProperty; function initSet(set) { set.map_ = new Map(); } var Set = function Set() { var iterable = arguments[0]; if (!isObject(this)) throw new TypeError('Set called on incompatible type'); if ($hasOwnProperty.call(this, 'map_')) { throw new TypeError('Set can not be reentrantly initialised'); } initSet(this); if (iterable !== null && iterable !== undefined) { for (var $__25 = iterable[Symbol.iterator](), $__26; !($__26 = $__25.next()).done; ) { var item = $__26.value; { this.add(item); } } } }; ($traceurRuntime.createClass)(Set, { get size() { return this.map_.size; }, has: function(key) { return this.map_.has(key); }, add: function(key) { return this.map_.set(key, key); }, delete: function(key) { return this.map_.delete(key); }, clear: function() { return this.map_.clear(); }, forEach: function(callbackFn) { var thisArg = arguments[1]; var $__23 = this; return this.map_.forEach((function(value, key) { callbackFn.call(thisArg, key, key, $__23); })); }, values: $traceurRuntime.initGeneratorFunction(function $__27() { var $__28, $__29; return $traceurRuntime.createGeneratorInstance(function($ctx) { while (true) switch ($ctx.state) { case 0: $__28 = this.map_.keys()[Symbol.iterator](); $ctx.sent = void 0; $ctx.action = 'next'; $ctx.state = 12; break; case 12: $__29 = $__28[$ctx.action]($ctx.sentIgnoreThrow); $ctx.state = 9; break; case 9: $ctx.state = ($__29.done) ? 3 : 2; break; case 3: $ctx.sent = $__29.value; $ctx.state = -2; break; case 2: $ctx.state = 12; return $__29.value; default: return $ctx.end(); } }, $__27, this); }), entries: $traceurRuntime.initGeneratorFunction(function $__30() { var $__31, $__32; return $traceurRuntime.createGeneratorInstance(function($ctx) { while (true) switch ($ctx.state) { case 0: $__31 = this.map_.entries()[Symbol.iterator](); $ctx.sent = void 0; $ctx.action = 'next'; $ctx.state = 12; break; case 12: $__32 = $__31[$ctx.action]($ctx.sentIgnoreThrow); $ctx.state = 9; break; case 9: $ctx.state = ($__32.done) ? 3 : 2; break; case 3: $ctx.sent = $__32.value; $ctx.state = -2; break; case 2: $ctx.state = 12; return $__32.value; default: return $ctx.end(); } }, $__30, this); }) }, {}); Object.defineProperty(Set.prototype, Symbol.iterator, { configurable: true, writable: true, value: Set.prototype.values }); Object.defineProperty(Set.prototype, 'keys', { configurable: true, writable: true, value: Set.prototype.values }); return {get Set() { return Set; }}; }); System.register("traceur@0.0.52/src/runtime/polyfills/String", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/runtime/polyfills/String"; var $toString = Object.prototype.toString; var $indexOf = String.prototype.indexOf; var $lastIndexOf = String.prototype.lastIndexOf; function startsWith(search) { var string = String(this); if (this == null || $toString.call(search) == '[object RegExp]') { throw TypeError(); } var stringLength = string.length; var searchString = String(search); var searchLength = searchString.length; var position = arguments.length > 1 ? arguments[1] : undefined; var pos = position ? Number(position) : 0; if (isNaN(pos)) { pos = 0; } var start = Math.min(Math.max(pos, 0), stringLength); return $indexOf.call(string, searchString, pos) == start; } function endsWith(search) { var string = String(this); if (this == null || $toString.call(search) == '[object RegExp]') { throw TypeError(); } var stringLength = string.length; var searchString = String(search); var searchLength = searchString.length; var pos = stringLength; if (arguments.length > 1) { var position = arguments[1]; if (position !== undefined) { pos = position ? Number(position) : 0; if (isNaN(pos)) { pos = 0; } } } var end = Math.min(Math.max(pos, 0), stringLength); var start = end - searchLength; if (start < 0) { return false; } return $lastIndexOf.call(string, searchString, start) == start; } function contains(search) { if (this == null) { throw TypeError(); } var string = String(this); var stringLength = string.length; var searchString = String(search); var searchLength = searchString.length; var position = arguments.length > 1 ? arguments[1] : undefined; var pos = position ? Number(position) : 0; if (isNaN(pos)) { pos = 0; } var start = Math.min(Math.max(pos, 0), stringLength); return $indexOf.call(string, searchString, pos) != -1; } function repeat(count) { if (this == null) { throw TypeError(); } var string = String(this); var n = count ? Number(count) : 0; if (isNaN(n)) { n = 0; } if (n < 0 || n == Infinity) { throw RangeError(); } if (n == 0) { return ''; } var result = ''; while (n--) { result += string; } return result; } function codePointAt(position) { if (this == null) { throw TypeError(); } var string = String(this); var size = string.length; var index = position ? Number(position) : 0; if (isNaN(index)) { index = 0; } if (index < 0 || index >= size) { return undefined; } var first = string.charCodeAt(index); var second; if (first >= 0xD800 && first <= 0xDBFF && size > index + 1) { second = string.charCodeAt(index + 1); if (second >= 0xDC00 && second <= 0xDFFF) { return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000; } } return first; } function raw(callsite) { var raw = callsite.raw; var len = raw.length >>> 0; if (len === 0) return ''; var s = ''; var i = 0; while (true) { s += raw[i]; if (i + 1 === len) return s; s += arguments[++i]; } } function fromCodePoint() { var codeUnits = []; var floor = Math.floor; var highSurrogate; var lowSurrogate; var index = -1; var length = arguments.length; if (!length) { return ''; } while (++index < length) { var codePoint = Number(arguments[index]); if (!isFinite(codePoint) || codePoint < 0 || codePoint > 0x10FFFF || floor(codePoint) != codePoint) { throw RangeError('Invalid code point: ' + codePoint); } if (codePoint <= 0xFFFF) { codeUnits.push(codePoint); } else { codePoint -= 0x10000; highSurrogate = (codePoint >> 10) + 0xD800; lowSurrogate = (codePoint % 0x400) + 0xDC00; codeUnits.push(highSurrogate, lowSurrogate); } } return String.fromCharCode.apply(null, codeUnits); } return { get startsWith() { return startsWith; }, get endsWith() { return endsWith; }, get contains() { return contains; }, get repeat() { return repeat; }, get codePointAt() { return codePointAt; }, get raw() { return raw; }, get fromCodePoint() { return fromCodePoint; } }; }); System.register("traceur@0.0.52/src/runtime/polyfills/polyfills", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/runtime/polyfills/polyfills"; var Map = System.get("traceur@0.0.52/src/runtime/polyfills/Map").Map; var Set = System.get("traceur@0.0.52/src/runtime/polyfills/Set").Set; var Promise = System.get("traceur@0.0.52/src/runtime/polyfills/Promise").Promise; var $__36 = System.get("traceur@0.0.52/src/runtime/polyfills/String"), codePointAt = $__36.codePointAt, contains = $__36.contains, endsWith = $__36.endsWith, fromCodePoint = $__36.fromCodePoint, repeat = $__36.repeat, raw = $__36.raw, startsWith = $__36.startsWith; var $__37 = System.get("traceur@0.0.52/src/runtime/polyfills/Array"), fill = $__37.fill, find = $__37.find, findIndex = $__37.findIndex, from = $__37.from; var $__38 = System.get("traceur@0.0.52/src/runtime/polyfills/ArrayIterator"), entries = $__38.entries, keys = $__38.keys, values = $__38.values; var $__39 = System.get("traceur@0.0.52/src/runtime/polyfills/Object"), assign = $__39.assign, is = $__39.is, mixin = $__39.mixin; var $__40 = System.get("traceur@0.0.52/src/runtime/polyfills/Number"), MAX_SAFE_INTEGER = $__40.MAX_SAFE_INTEGER, MIN_SAFE_INTEGER = $__40.MIN_SAFE_INTEGER, EPSILON = $__40.EPSILON, isFinite = $__40.isFinite, isInteger = $__40.isInteger, isNaN = $__40.isNaN, isSafeInteger = $__40.isSafeInteger; var getPrototypeOf = $traceurRuntime.assertObject(Object).getPrototypeOf; function maybeDefine(object, name, descr) { if (!(name in object)) { Object.defineProperty(object, name, descr); } } function maybeDefineMethod(object, name, value) { maybeDefine(object, name, { value: value, configurable: true, enumerable: false, writable: true }); } function maybeDefineConst(object, name, value) { maybeDefine(object, name, { value: value, configurable: false, enumerable: false, writable: false }); } function maybeAddFunctions(object, functions) { for (var i = 0; i < functions.length; i += 2) { var name = functions[i]; var value = functions[i + 1]; maybeDefineMethod(object, name, value); } } function maybeAddConsts(object, consts) { for (var i = 0; i < consts.length; i += 2) { var name = consts[i]; var value = consts[i + 1]; maybeDefineConst(object, name, value); } } function maybeAddIterator(object, func, Symbol) { if (!Symbol || !Symbol.iterator || object[Symbol.iterator]) return; if (object['@@iterator']) func = object['@@iterator']; Object.defineProperty(object, Symbol.iterator, { value: func, configurable: true, enumerable: false, writable: true }); } function polyfillPromise(global) { if (!global.Promise) global.Promise = Promise; } function polyfillCollections(global, Symbol) { if (!global.Map) global.Map = Map; var mapPrototype = global.Map.prototype; if (mapPrototype.entries) { maybeAddIterator(mapPrototype, mapPrototype.entries, Symbol); maybeAddIterator(getPrototypeOf(new global.Map().entries()), function() { return this; }, Symbol); } if (!global.Set) global.Set = Set; var setPrototype = global.Set.prototype; if (setPrototype.values) { maybeAddIterator(setPrototype, setPrototype.values, Symbol); maybeAddIterator(getPrototypeOf(new global.Set().values()), function() { return this; }, Symbol); } } function polyfillString(String) { maybeAddFunctions(String.prototype, ['codePointAt', codePointAt, 'contains', contains, 'endsWith', endsWith, 'startsWith', startsWith, 'repeat', repeat]); maybeAddFunctions(String, ['fromCodePoint', fromCodePoint, 'raw', raw]); } function polyfillArray(Array, Symbol) { maybeAddFunctions(Array.prototype, ['entries', entries, 'keys', keys, 'values', values, 'fill', fill, 'find', find, 'findIndex', findIndex]); maybeAddFunctions(Array, ['from', from]); maybeAddIterator(Array.prototype, values, Symbol); maybeAddIterator(getPrototypeOf([].values()), function() { return this; }, Symbol); } function polyfillObject(Object) { maybeAddFunctions(Object, ['assign', assign, 'is', is, 'mixin', mixin]); } function polyfillNumber(Number) { maybeAddConsts(Number, ['MAX_SAFE_INTEGER', MAX_SAFE_INTEGER, 'MIN_SAFE_INTEGER', MIN_SAFE_INTEGER, 'EPSILON', EPSILON]); maybeAddFunctions(Number, ['isFinite', isFinite, 'isInteger', isInteger, 'isNaN', isNaN, 'isSafeInteger', isSafeInteger]); } function polyfill(global) { polyfillPromise(global); polyfillCollections(global, global.Symbol); polyfillString(global.String); polyfillArray(global.Array, global.Symbol); polyfillObject(global.Object); polyfillNumber(global.Number); } polyfill(this); var setupGlobals = $traceurRuntime.setupGlobals; $traceurRuntime.setupGlobals = function(global) { setupGlobals(global); polyfill(global); }; return {}; }); System.register("traceur@0.0.52/src/runtime/polyfill-import", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/runtime/polyfill-import"; System.get("traceur@0.0.52/src/runtime/polyfills/polyfills"); return {}; }); System.get("traceur@0.0.52/src/runtime/polyfill-import" + ''); System.register("traceur@0.0.52/src/Options", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/Options"; function enumerableOnlyObject(obj) { var result = Object.create(null); Object.keys(obj).forEach(function(key) { Object.defineProperty(result, key, { enumerable: true, value: obj[key] }); }); return result; } var optionsV01 = enumerableOnlyObject({ arrayComprehension: true, arrowFunctions: true, classes: true, computedPropertyNames: true, defaultParameters: true, destructuring: true, forOf: true, generatorComprehension: true, generators: true, modules: 'register', numericLiterals: true, propertyMethods: true, propertyNameShorthand: true, restParameters: true, spread: true, templateLiterals: true, asyncFunctions: false, blockBinding: false, symbols: false, types: false, annotations: false, commentCallback: false, debug: false, freeVariableChecker: false, sourceMaps: false, typeAssertions: false, validate: false, referrer: '', typeAssertionModule: null, moduleName: false, outputLanguage: 'es5', filename: undefined }); var versionLockedOptions = optionsV01; var parseOptions = Object.create(null); var transformOptions = Object.create(null); var defaultValues = Object.create(null); var experimentalOptions = Object.create(null); var moduleOptions = ['amd', 'commonjs', 'instantiate', 'inline', 'register']; var Options = function Options() { var options = arguments[0] !== (void 0) ? arguments[0] : Object.create(null); this.setDefaults(); this.setFromObject(versionLockedOptions); this.setFromObject(options); Object.defineProperties(this, {modules_: { value: versionLockedOptions.modules, writable: true, enumerable: false }}); }; ($traceurRuntime.createClass)(Options, { set experimental(v) { var $__42 = this; v = coerceOptionValue(v); Object.keys(experimentalOptions).forEach((function(name) { $__42[name] = v; })); }, get experimental() { var $__42 = this; var value; Object.keys(experimentalOptions).every((function(name) { var currentValue = $__42[name]; if (value === undefined) { value = currentValue; return true; } if (currentValue !== value) { value = null; return false; } return true; })); return value; }, get modules() { return this.modules_; }, set modules(value) { if (typeof value === 'boolean' && !value) value = 'register'; if (moduleOptions.indexOf(value) === -1) { throw new Error('Invalid \'modules\' option \'' + value + '\', not in ' + moduleOptions.join(', ')); } this.modules_ = value; }, reset: function() { var allOff = arguments[0]; var $__42 = this; var useDefault = allOff === undefined; Object.keys(this).forEach((function(name) { $__42[name] = useDefault && defaultValues[name]; })); this.setDefaults(); }, setDefaults: function() { this.modules = 'register'; this.moduleName = false; this.outputLanguage = 'es5'; this.filename = undefined; }, setFromObject: function(object) { var $__42 = this; Object.keys(object).forEach((function(name) { $__42[name] = object[name]; })); this.modules = object.modules || this.modules; return this; } }, {}); ; var options = new Options(); var descriptions = { experimental: 'Turns on all experimental features', sourceMaps: 'generate source map and write to .map' }; var CommandOptions = function CommandOptions() { $traceurRuntime.defaultSuperCall(this, $CommandOptions.prototype, arguments); }; var $CommandOptions = CommandOptions; ($traceurRuntime.createClass)(CommandOptions, { parseCommand: function(s) { var re = /--([^=]+)(?:=(.+))?/; var m = re.exec(s); if (m) this.setOption(m[1], m[2] || true); }, setOption: function(name, value) { name = toCamelCase(name); value = coerceOptionValue(value); if (name in this) { this[name] = value; } else { throw Error('Unknown option: ' + name); } } }, { fromString: function(s) { return $CommandOptions.fromArgv(s.split(/\s+/)); }, fromArgv: function(args) { var options = new $CommandOptions(); args.forEach((function(arg) { return options.parseCommand(arg); })); return options; } }, Options); function coerceOptionValue(v) { switch (v) { case 'false': return false; case 'true': case true: return true; default: return !!v && String(v); } } function addOptions(flags, commandOptions) { flags.option('--referrer ', 'Bracket output code with System.referrerName=', (function(name) { commandOptions.setOption('referrer', name); System.map = System.semverMap(name); return name; })); flags.option('--type-assertion-module ', 'Absolute path to the type assertion module.', (function(path) { commandOptions.setOption('type-assertion-module', path); return path; })); flags.option('--modules <' + moduleOptions.join(', ') + '>', 'select the output format for modules', (function(moduleFormat) { commandOptions.modules = moduleFormat; })); flags.option('--moduleName ', '__moduleName value, + sign to use filename, or empty to omit; default +', (function(moduleName) { if (moduleName === '+') moduleName = true; commandOptions.moduleName = moduleName; })); flags.option('--outputLanguage ', 'compilation target language', (function(outputLanguage) { if (outputLanguage === 'es6' || outputLanguage === 'es5') commandOptions.outputLanguage = outputLanguage; else throw new Error('outputLanguage must be one of es5, es6'); })); flags.option('--experimental ', 'Turns on all experimental features', (function() { commandOptions.experimental = true; })); Object.keys(commandOptions).forEach(function(name) { var dashedName = toDashCase(name); if (flags.optionFor('--' + name) || flags.optionFor('--' + dashedName)) { return; } else if ((name in parseOptions) && (name in transformOptions)) { flags.option('--' + dashedName + ' [true|false|parse]', descriptions[name]); flags.on(dashedName, (function(value) { return commandOptions.setOption(dashedName, value); })); } else if (commandOptions[name] !== null) { flags.option('--' + dashedName, descriptions[name]); flags.on(dashedName, (function() { return commandOptions.setOption(dashedName, true); })); } else { throw new Error('Unexpected null commandOption ' + name); } }); commandOptions.setDefaults(); } function toCamelCase(s) { return s.replace(/-\w/g, function(ch) { return ch[1].toUpperCase(); }); } function toDashCase(s) { return s.replace(/[A-Z]/g, function(ch) { return '-' + ch.toLowerCase(); }); } var EXPERIMENTAL = 0; var ON_BY_DEFAULT = 1; function addFeatureOption(name, kind) { if (kind === EXPERIMENTAL) experimentalOptions[name] = true; Object.defineProperty(parseOptions, name, { get: function() { return !!options[name]; }, enumerable: true, configurable: true }); Object.defineProperty(transformOptions, name, { get: function() { var v = options[name]; if (v === 'parse') return false; return v; }, enumerable: true, configurable: true }); var defaultValue = options[name] || kind === ON_BY_DEFAULT; options[name] = defaultValue; defaultValues[name] = defaultValue; } function addBoolOption(name) { defaultValues[name] = false; options[name] = false; } addFeatureOption('arrayComprehension', ON_BY_DEFAULT); addFeatureOption('arrowFunctions', ON_BY_DEFAULT); addFeatureOption('classes', ON_BY_DEFAULT); addFeatureOption('computedPropertyNames', ON_BY_DEFAULT); addFeatureOption('defaultParameters', ON_BY_DEFAULT); addFeatureOption('destructuring', ON_BY_DEFAULT); addFeatureOption('forOf', ON_BY_DEFAULT); addFeatureOption('generatorComprehension', ON_BY_DEFAULT); addFeatureOption('generators', ON_BY_DEFAULT); addFeatureOption('modules', 'SPECIAL'); addFeatureOption('numericLiterals', ON_BY_DEFAULT); addFeatureOption('propertyMethods', ON_BY_DEFAULT); addFeatureOption('propertyNameShorthand', ON_BY_DEFAULT); addFeatureOption('restParameters', ON_BY_DEFAULT); addFeatureOption('spread', ON_BY_DEFAULT); addFeatureOption('templateLiterals', ON_BY_DEFAULT); addFeatureOption('asyncFunctions', EXPERIMENTAL); addFeatureOption('blockBinding', EXPERIMENTAL); addFeatureOption('symbols', EXPERIMENTAL); addFeatureOption('types', EXPERIMENTAL); addFeatureOption('annotations', EXPERIMENTAL); addBoolOption('commentCallback'); addBoolOption('debug'); addBoolOption('freeVariableChecker'); addBoolOption('sourceMaps'); addBoolOption('typeAssertions'); addBoolOption('validate'); defaultValues.referrer = ''; options.referrer = null; defaultValues.typeAssertionModule = null; options.typeAssertionModule = null; return { get optionsV01() { return optionsV01; }, get versionLockedOptions() { return versionLockedOptions; }, get parseOptions() { return parseOptions; }, get transformOptions() { return transformOptions; }, get Options() { return Options; }, get options() { return options; }, get CommandOptions() { return CommandOptions; }, get addOptions() { return addOptions; } }; }); System.register("traceur@0.0.52/src/syntax/TokenType", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/syntax/TokenType"; var AMPERSAND = '&'; var AMPERSAND_EQUAL = '&='; var AND = '&&'; var ARROW = '=>'; var AT = '@'; var BACK_QUOTE = '`'; var BANG = '!'; var BAR = '|'; var BAR_EQUAL = '|='; var BREAK = 'break'; var CARET = '^'; var CARET_EQUAL = '^='; var CASE = 'case'; var CATCH = 'catch'; var CLASS = 'class'; var CLOSE_ANGLE = '>'; var CLOSE_CURLY = '}'; var CLOSE_PAREN = ')'; var CLOSE_SQUARE = ']'; var COLON = ':'; var COMMA = ','; var CONST = 'const'; var CONTINUE = 'continue'; var DEBUGGER = 'debugger'; var DEFAULT = 'default'; var DELETE = 'delete'; var DO = 'do'; var DOT_DOT_DOT = '...'; var ELSE = 'else'; var END_OF_FILE = 'End of File'; var ENUM = 'enum'; var EQUAL = '='; var EQUAL_EQUAL = '=='; var EQUAL_EQUAL_EQUAL = '==='; var ERROR = 'error'; var EXPORT = 'export'; var EXTENDS = 'extends'; var FALSE = 'false'; var FINALLY = 'finally'; var FOR = 'for'; var FUNCTION = 'function'; var GREATER_EQUAL = '>='; var IDENTIFIER = 'identifier'; var IF = 'if'; var IMPLEMENTS = 'implements'; var IMPORT = 'import'; var IN = 'in'; var INSTANCEOF = 'instanceof'; var INTERFACE = 'interface'; var LEFT_SHIFT = '<<'; var LEFT_SHIFT_EQUAL = '<<='; var LESS_EQUAL = '<='; var LET = 'let'; var MINUS = '-'; var MINUS_EQUAL = '-='; var MINUS_MINUS = '--'; var NEW = 'new'; var NO_SUBSTITUTION_TEMPLATE = 'no substitution template'; var NOT_EQUAL = '!='; var NOT_EQUAL_EQUAL = '!=='; var NULL = 'null'; var NUMBER = 'number literal'; var OPEN_ANGLE = '<'; var OPEN_CURLY = '{'; var OPEN_PAREN = '('; var OPEN_SQUARE = '['; var OR = '||'; var PACKAGE = 'package'; var PERCENT = '%'; var PERCENT_EQUAL = '%='; var PERIOD = '.'; var PLUS = '+'; var PLUS_EQUAL = '+='; var PLUS_PLUS = '++'; var PRIVATE = 'private'; var PROTECTED = 'protected'; var PUBLIC = 'public'; var QUESTION = '?'; var REGULAR_EXPRESSION = 'regular expression literal'; var RETURN = 'return'; var RIGHT_SHIFT = '>>'; var RIGHT_SHIFT_EQUAL = '>>='; var SEMI_COLON = ';'; var SLASH = '/'; var SLASH_EQUAL = '/='; var STAR = '*'; var STAR_EQUAL = '*='; var STATIC = 'static'; var STRING = 'string literal'; var SUPER = 'super'; var SWITCH = 'switch'; var TEMPLATE_HEAD = 'template head'; var TEMPLATE_MIDDLE = 'template middle'; var TEMPLATE_TAIL = 'template tail'; var THIS = 'this'; var THROW = 'throw'; var TILDE = '~'; var TRUE = 'true'; var TRY = 'try'; var TYPEOF = 'typeof'; var UNSIGNED_RIGHT_SHIFT = '>>>'; var UNSIGNED_RIGHT_SHIFT_EQUAL = '>>>='; var VAR = 'var'; var VOID = 'void'; var WHILE = 'while'; var WITH = 'with'; var YIELD = 'yield'; return { get AMPERSAND() { return AMPERSAND; }, get AMPERSAND_EQUAL() { return AMPERSAND_EQUAL; }, get AND() { return AND; }, get ARROW() { return ARROW; }, get AT() { return AT; }, get BACK_QUOTE() { return BACK_QUOTE; }, get BANG() { return BANG; }, get BAR() { return BAR; }, get BAR_EQUAL() { return BAR_EQUAL; }, get BREAK() { return BREAK; }, get CARET() { return CARET; }, get CARET_EQUAL() { return CARET_EQUAL; }, get CASE() { return CASE; }, get CATCH() { return CATCH; }, get CLASS() { return CLASS; }, get CLOSE_ANGLE() { return CLOSE_ANGLE; }, get CLOSE_CURLY() { return CLOSE_CURLY; }, get CLOSE_PAREN() { return CLOSE_PAREN; }, get CLOSE_SQUARE() { return CLOSE_SQUARE; }, get COLON() { return COLON; }, get COMMA() { return COMMA; }, get CONST() { return CONST; }, get CONTINUE() { return CONTINUE; }, get DEBUGGER() { return DEBUGGER; }, get DEFAULT() { return DEFAULT; }, get DELETE() { return DELETE; }, get DO() { return DO; }, get DOT_DOT_DOT() { return DOT_DOT_DOT; }, get ELSE() { return ELSE; }, get END_OF_FILE() { return END_OF_FILE; }, get ENUM() { return ENUM; }, get EQUAL() { return EQUAL; }, get EQUAL_EQUAL() { return EQUAL_EQUAL; }, get EQUAL_EQUAL_EQUAL() { return EQUAL_EQUAL_EQUAL; }, get ERROR() { return ERROR; }, get EXPORT() { return EXPORT; }, get EXTENDS() { return EXTENDS; }, get FALSE() { return FALSE; }, get FINALLY() { return FINALLY; }, get FOR() { return FOR; }, get FUNCTION() { return FUNCTION; }, get GREATER_EQUAL() { return GREATER_EQUAL; }, get IDENTIFIER() { return IDENTIFIER; }, get IF() { return IF; }, get IMPLEMENTS() { return IMPLEMENTS; }, get IMPORT() { return IMPORT; }, get IN() { return IN; }, get INSTANCEOF() { return INSTANCEOF; }, get INTERFACE() { return INTERFACE; }, get LEFT_SHIFT() { return LEFT_SHIFT; }, get LEFT_SHIFT_EQUAL() { return LEFT_SHIFT_EQUAL; }, get LESS_EQUAL() { return LESS_EQUAL; }, get LET() { return LET; }, get MINUS() { return MINUS; }, get MINUS_EQUAL() { return MINUS_EQUAL; }, get MINUS_MINUS() { return MINUS_MINUS; }, get NEW() { return NEW; }, get NO_SUBSTITUTION_TEMPLATE() { return NO_SUBSTITUTION_TEMPLATE; }, get NOT_EQUAL() { return NOT_EQUAL; }, get NOT_EQUAL_EQUAL() { return NOT_EQUAL_EQUAL; }, get NULL() { return NULL; }, get NUMBER() { return NUMBER; }, get OPEN_ANGLE() { return OPEN_ANGLE; }, get OPEN_CURLY() { return OPEN_CURLY; }, get OPEN_PAREN() { return OPEN_PAREN; }, get OPEN_SQUARE() { return OPEN_SQUARE; }, get OR() { return OR; }, get PACKAGE() { return PACKAGE; }, get PERCENT() { return PERCENT; }, get PERCENT_EQUAL() { return PERCENT_EQUAL; }, get PERIOD() { return PERIOD; }, get PLUS() { return PLUS; }, get PLUS_EQUAL() { return PLUS_EQUAL; }, get PLUS_PLUS() { return PLUS_PLUS; }, get PRIVATE() { return PRIVATE; }, get PROTECTED() { return PROTECTED; }, get PUBLIC() { return PUBLIC; }, get QUESTION() { return QUESTION; }, get REGULAR_EXPRESSION() { return REGULAR_EXPRESSION; }, get RETURN() { return RETURN; }, get RIGHT_SHIFT() { return RIGHT_SHIFT; }, get RIGHT_SHIFT_EQUAL() { return RIGHT_SHIFT_EQUAL; }, get SEMI_COLON() { return SEMI_COLON; }, get SLASH() { return SLASH; }, get SLASH_EQUAL() { return SLASH_EQUAL; }, get STAR() { return STAR; }, get STAR_EQUAL() { return STAR_EQUAL; }, get STATIC() { return STATIC; }, get STRING() { return STRING; }, get SUPER() { return SUPER; }, get SWITCH() { return SWITCH; }, get TEMPLATE_HEAD() { return TEMPLATE_HEAD; }, get TEMPLATE_MIDDLE() { return TEMPLATE_MIDDLE; }, get TEMPLATE_TAIL() { return TEMPLATE_TAIL; }, get THIS() { return THIS; }, get THROW() { return THROW; }, get TILDE() { return TILDE; }, get TRUE() { return TRUE; }, get TRY() { return TRY; }, get TYPEOF() { return TYPEOF; }, get UNSIGNED_RIGHT_SHIFT() { return UNSIGNED_RIGHT_SHIFT; }, get UNSIGNED_RIGHT_SHIFT_EQUAL() { return UNSIGNED_RIGHT_SHIFT_EQUAL; }, get VAR() { return VAR; }, get VOID() { return VOID; }, get WHILE() { return WHILE; }, get WITH() { return WITH; }, get YIELD() { return YIELD; } }; }); System.register("traceur@0.0.52/src/syntax/trees/ParseTreeType", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/syntax/trees/ParseTreeType"; var ANNOTATION = 'ANNOTATION'; var ANON_BLOCK = 'ANON_BLOCK'; var ARGUMENT_LIST = 'ARGUMENT_LIST'; var ARRAY_COMPREHENSION = 'ARRAY_COMPREHENSION'; var ARRAY_LITERAL_EXPRESSION = 'ARRAY_LITERAL_EXPRESSION'; var ARRAY_PATTERN = 'ARRAY_PATTERN'; var ARROW_FUNCTION_EXPRESSION = 'ARROW_FUNCTION_EXPRESSION'; var ASSIGNMENT_ELEMENT = 'ASSIGNMENT_ELEMENT'; var AWAIT_EXPRESSION = 'AWAIT_EXPRESSION'; var BINARY_EXPRESSION = 'BINARY_EXPRESSION'; var BINDING_ELEMENT = 'BINDING_ELEMENT'; var BINDING_IDENTIFIER = 'BINDING_IDENTIFIER'; var BLOCK = 'BLOCK'; var BREAK_STATEMENT = 'BREAK_STATEMENT'; var CALL_EXPRESSION = 'CALL_EXPRESSION'; var CASE_CLAUSE = 'CASE_CLAUSE'; var CATCH = 'CATCH'; var CLASS_DECLARATION = 'CLASS_DECLARATION'; var CLASS_EXPRESSION = 'CLASS_EXPRESSION'; var COMMA_EXPRESSION = 'COMMA_EXPRESSION'; var COMPREHENSION_FOR = 'COMPREHENSION_FOR'; var COMPREHENSION_IF = 'COMPREHENSION_IF'; var COMPUTED_PROPERTY_NAME = 'COMPUTED_PROPERTY_NAME'; var CONDITIONAL_EXPRESSION = 'CONDITIONAL_EXPRESSION'; var CONTINUE_STATEMENT = 'CONTINUE_STATEMENT'; var COVER_FORMALS = 'COVER_FORMALS'; var COVER_INITIALIZED_NAME = 'COVER_INITIALIZED_NAME'; var DEBUGGER_STATEMENT = 'DEBUGGER_STATEMENT'; var DEFAULT_CLAUSE = 'DEFAULT_CLAUSE'; var DO_WHILE_STATEMENT = 'DO_WHILE_STATEMENT'; var EMPTY_STATEMENT = 'EMPTY_STATEMENT'; var EXPORT_DECLARATION = 'EXPORT_DECLARATION'; var EXPORT_DEFAULT = 'EXPORT_DEFAULT'; var EXPORT_SPECIFIER = 'EXPORT_SPECIFIER'; var EXPORT_SPECIFIER_SET = 'EXPORT_SPECIFIER_SET'; var EXPORT_STAR = 'EXPORT_STAR'; var EXPRESSION_STATEMENT = 'EXPRESSION_STATEMENT'; var FINALLY = 'FINALLY'; var FOR_IN_STATEMENT = 'FOR_IN_STATEMENT'; var FOR_OF_STATEMENT = 'FOR_OF_STATEMENT'; var FOR_STATEMENT = 'FOR_STATEMENT'; var FORMAL_PARAMETER = 'FORMAL_PARAMETER'; var FORMAL_PARAMETER_LIST = 'FORMAL_PARAMETER_LIST'; var FUNCTION_BODY = 'FUNCTION_BODY'; var FUNCTION_DECLARATION = 'FUNCTION_DECLARATION'; var FUNCTION_EXPRESSION = 'FUNCTION_EXPRESSION'; var GENERATOR_COMPREHENSION = 'GENERATOR_COMPREHENSION'; var GET_ACCESSOR = 'GET_ACCESSOR'; var IDENTIFIER_EXPRESSION = 'IDENTIFIER_EXPRESSION'; var IF_STATEMENT = 'IF_STATEMENT'; var IMPORT_DECLARATION = 'IMPORT_DECLARATION'; var IMPORT_SPECIFIER = 'IMPORT_SPECIFIER'; var IMPORT_SPECIFIER_SET = 'IMPORT_SPECIFIER_SET'; var IMPORTED_BINDING = 'IMPORTED_BINDING'; var LABELLED_STATEMENT = 'LABELLED_STATEMENT'; var LITERAL_EXPRESSION = 'LITERAL_EXPRESSION'; var LITERAL_PROPERTY_NAME = 'LITERAL_PROPERTY_NAME'; var MEMBER_EXPRESSION = 'MEMBER_EXPRESSION'; var MEMBER_LOOKUP_EXPRESSION = 'MEMBER_LOOKUP_EXPRESSION'; var MODULE = 'MODULE'; var MODULE_DECLARATION = 'MODULE_DECLARATION'; var MODULE_SPECIFIER = 'MODULE_SPECIFIER'; var NAMED_EXPORT = 'NAMED_EXPORT'; var NEW_EXPRESSION = 'NEW_EXPRESSION'; var OBJECT_LITERAL_EXPRESSION = 'OBJECT_LITERAL_EXPRESSION'; var OBJECT_PATTERN = 'OBJECT_PATTERN'; var OBJECT_PATTERN_FIELD = 'OBJECT_PATTERN_FIELD'; var PAREN_EXPRESSION = 'PAREN_EXPRESSION'; var POSTFIX_EXPRESSION = 'POSTFIX_EXPRESSION'; var PREDEFINED_TYPE = 'PREDEFINED_TYPE'; var PROPERTY_METHOD_ASSIGNMENT = 'PROPERTY_METHOD_ASSIGNMENT'; var PROPERTY_NAME_ASSIGNMENT = 'PROPERTY_NAME_ASSIGNMENT'; var PROPERTY_NAME_SHORTHAND = 'PROPERTY_NAME_SHORTHAND'; var REST_PARAMETER = 'REST_PARAMETER'; var RETURN_STATEMENT = 'RETURN_STATEMENT'; var SCRIPT = 'SCRIPT'; var SET_ACCESSOR = 'SET_ACCESSOR'; var SPREAD_EXPRESSION = 'SPREAD_EXPRESSION'; var SPREAD_PATTERN_ELEMENT = 'SPREAD_PATTERN_ELEMENT'; var STATE_MACHINE = 'STATE_MACHINE'; var SUPER_EXPRESSION = 'SUPER_EXPRESSION'; var SWITCH_STATEMENT = 'SWITCH_STATEMENT'; var SYNTAX_ERROR_TREE = 'SYNTAX_ERROR_TREE'; var TEMPLATE_LITERAL_EXPRESSION = 'TEMPLATE_LITERAL_EXPRESSION'; var TEMPLATE_LITERAL_PORTION = 'TEMPLATE_LITERAL_PORTION'; var TEMPLATE_SUBSTITUTION = 'TEMPLATE_SUBSTITUTION'; var THIS_EXPRESSION = 'THIS_EXPRESSION'; var THROW_STATEMENT = 'THROW_STATEMENT'; var TRY_STATEMENT = 'TRY_STATEMENT'; var TYPE_NAME = 'TYPE_NAME'; var UNARY_EXPRESSION = 'UNARY_EXPRESSION'; var VARIABLE_DECLARATION = 'VARIABLE_DECLARATION'; var VARIABLE_DECLARATION_LIST = 'VARIABLE_DECLARATION_LIST'; var VARIABLE_STATEMENT = 'VARIABLE_STATEMENT'; var WHILE_STATEMENT = 'WHILE_STATEMENT'; var WITH_STATEMENT = 'WITH_STATEMENT'; var YIELD_EXPRESSION = 'YIELD_EXPRESSION'; return { get ANNOTATION() { return ANNOTATION; }, get ANON_BLOCK() { return ANON_BLOCK; }, get ARGUMENT_LIST() { return ARGUMENT_LIST; }, get ARRAY_COMPREHENSION() { return ARRAY_COMPREHENSION; }, get ARRAY_LITERAL_EXPRESSION() { return ARRAY_LITERAL_EXPRESSION; }, get ARRAY_PATTERN() { return ARRAY_PATTERN; }, get ARROW_FUNCTION_EXPRESSION() { return ARROW_FUNCTION_EXPRESSION; }, get ASSIGNMENT_ELEMENT() { return ASSIGNMENT_ELEMENT; }, get AWAIT_EXPRESSION() { return AWAIT_EXPRESSION; }, get BINARY_EXPRESSION() { return BINARY_EXPRESSION; }, get BINDING_ELEMENT() { return BINDING_ELEMENT; }, get BINDING_IDENTIFIER() { return BINDING_IDENTIFIER; }, get BLOCK() { return BLOCK; }, get BREAK_STATEMENT() { return BREAK_STATEMENT; }, get CALL_EXPRESSION() { return CALL_EXPRESSION; }, get CASE_CLAUSE() { return CASE_CLAUSE; }, get CATCH() { return CATCH; }, get CLASS_DECLARATION() { return CLASS_DECLARATION; }, get CLASS_EXPRESSION() { return CLASS_EXPRESSION; }, get COMMA_EXPRESSION() { return COMMA_EXPRESSION; }, get COMPREHENSION_FOR() { return COMPREHENSION_FOR; }, get COMPREHENSION_IF() { return COMPREHENSION_IF; }, get COMPUTED_PROPERTY_NAME() { return COMPUTED_PROPERTY_NAME; }, get CONDITIONAL_EXPRESSION() { return CONDITIONAL_EXPRESSION; }, get CONTINUE_STATEMENT() { return CONTINUE_STATEMENT; }, get COVER_FORMALS() { return COVER_FORMALS; }, get COVER_INITIALIZED_NAME() { return COVER_INITIALIZED_NAME; }, get DEBUGGER_STATEMENT() { return DEBUGGER_STATEMENT; }, get DEFAULT_CLAUSE() { return DEFAULT_CLAUSE; }, get DO_WHILE_STATEMENT() { return DO_WHILE_STATEMENT; }, get EMPTY_STATEMENT() { return EMPTY_STATEMENT; }, get EXPORT_DECLARATION() { return EXPORT_DECLARATION; }, get EXPORT_DEFAULT() { return EXPORT_DEFAULT; }, get EXPORT_SPECIFIER() { return EXPORT_SPECIFIER; }, get EXPORT_SPECIFIER_SET() { return EXPORT_SPECIFIER_SET; }, get EXPORT_STAR() { return EXPORT_STAR; }, get EXPRESSION_STATEMENT() { return EXPRESSION_STATEMENT; }, get FINALLY() { return FINALLY; }, get FOR_IN_STATEMENT() { return FOR_IN_STATEMENT; }, get FOR_OF_STATEMENT() { return FOR_OF_STATEMENT; }, get FOR_STATEMENT() { return FOR_STATEMENT; }, get FORMAL_PARAMETER() { return FORMAL_PARAMETER; }, get FORMAL_PARAMETER_LIST() { return FORMAL_PARAMETER_LIST; }, get FUNCTION_BODY() { return FUNCTION_BODY; }, get FUNCTION_DECLARATION() { return FUNCTION_DECLARATION; }, get FUNCTION_EXPRESSION() { return FUNCTION_EXPRESSION; }, get GENERATOR_COMPREHENSION() { return GENERATOR_COMPREHENSION; }, get GET_ACCESSOR() { return GET_ACCESSOR; }, get IDENTIFIER_EXPRESSION() { return IDENTIFIER_EXPRESSION; }, get IF_STATEMENT() { return IF_STATEMENT; }, get IMPORT_DECLARATION() { return IMPORT_DECLARATION; }, get IMPORT_SPECIFIER() { return IMPORT_SPECIFIER; }, get IMPORT_SPECIFIER_SET() { return IMPORT_SPECIFIER_SET; }, get IMPORTED_BINDING() { return IMPORTED_BINDING; }, get LABELLED_STATEMENT() { return LABELLED_STATEMENT; }, get LITERAL_EXPRESSION() { return LITERAL_EXPRESSION; }, get LITERAL_PROPERTY_NAME() { return LITERAL_PROPERTY_NAME; }, get MEMBER_EXPRESSION() { return MEMBER_EXPRESSION; }, get MEMBER_LOOKUP_EXPRESSION() { return MEMBER_LOOKUP_EXPRESSION; }, get MODULE() { return MODULE; }, get MODULE_DECLARATION() { return MODULE_DECLARATION; }, get MODULE_SPECIFIER() { return MODULE_SPECIFIER; }, get NAMED_EXPORT() { return NAMED_EXPORT; }, get NEW_EXPRESSION() { return NEW_EXPRESSION; }, get OBJECT_LITERAL_EXPRESSION() { return OBJECT_LITERAL_EXPRESSION; }, get OBJECT_PATTERN() { return OBJECT_PATTERN; }, get OBJECT_PATTERN_FIELD() { return OBJECT_PATTERN_FIELD; }, get PAREN_EXPRESSION() { return PAREN_EXPRESSION; }, get POSTFIX_EXPRESSION() { return POSTFIX_EXPRESSION; }, get PREDEFINED_TYPE() { return PREDEFINED_TYPE; }, get PROPERTY_METHOD_ASSIGNMENT() { return PROPERTY_METHOD_ASSIGNMENT; }, get PROPERTY_NAME_ASSIGNMENT() { return PROPERTY_NAME_ASSIGNMENT; }, get PROPERTY_NAME_SHORTHAND() { return PROPERTY_NAME_SHORTHAND; }, get REST_PARAMETER() { return REST_PARAMETER; }, get RETURN_STATEMENT() { return RETURN_STATEMENT; }, get SCRIPT() { return SCRIPT; }, get SET_ACCESSOR() { return SET_ACCESSOR; }, get SPREAD_EXPRESSION() { return SPREAD_EXPRESSION; }, get SPREAD_PATTERN_ELEMENT() { return SPREAD_PATTERN_ELEMENT; }, get STATE_MACHINE() { return STATE_MACHINE; }, get SUPER_EXPRESSION() { return SUPER_EXPRESSION; }, get SWITCH_STATEMENT() { return SWITCH_STATEMENT; }, get SYNTAX_ERROR_TREE() { return SYNTAX_ERROR_TREE; }, get TEMPLATE_LITERAL_EXPRESSION() { return TEMPLATE_LITERAL_EXPRESSION; }, get TEMPLATE_LITERAL_PORTION() { return TEMPLATE_LITERAL_PORTION; }, get TEMPLATE_SUBSTITUTION() { return TEMPLATE_SUBSTITUTION; }, get THIS_EXPRESSION() { return THIS_EXPRESSION; }, get THROW_STATEMENT() { return THROW_STATEMENT; }, get TRY_STATEMENT() { return TRY_STATEMENT; }, get TYPE_NAME() { return TYPE_NAME; }, get UNARY_EXPRESSION() { return UNARY_EXPRESSION; }, get VARIABLE_DECLARATION() { return VARIABLE_DECLARATION; }, get VARIABLE_DECLARATION_LIST() { return VARIABLE_DECLARATION_LIST; }, get VARIABLE_STATEMENT() { return VARIABLE_STATEMENT; }, get WHILE_STATEMENT() { return WHILE_STATEMENT; }, get WITH_STATEMENT() { return WITH_STATEMENT; }, get YIELD_EXPRESSION() { return YIELD_EXPRESSION; } }; }); System.register("traceur@0.0.52/src/syntax/ParseTreeVisitor", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/syntax/ParseTreeVisitor"; var ParseTreeVisitor = function ParseTreeVisitor() {}; ($traceurRuntime.createClass)(ParseTreeVisitor, { visitAny: function(tree) { tree && tree.visit(this); }, visit: function(tree) { this.visitAny(tree); }, visitList: function(list) { if (list) { for (var i = 0; i < list.length; i++) { this.visitAny(list[i]); } } }, visitStateMachine: function(tree) { throw Error('State machines should not live outside of the GeneratorTransformer.'); }, visitAnnotation: function(tree) { this.visitAny(tree.name); this.visitAny(tree.args); }, visitAnonBlock: function(tree) { this.visitList(tree.statements); }, visitArgumentList: function(tree) { this.visitList(tree.args); }, visitArrayComprehension: function(tree) { this.visitList(tree.comprehensionList); this.visitAny(tree.expression); }, visitArrayLiteralExpression: function(tree) { this.visitList(tree.elements); }, visitArrayPattern: function(tree) { this.visitList(tree.elements); }, visitArrowFunctionExpression: function(tree) { this.visitAny(tree.parameterList); this.visitAny(tree.body); }, visitAssignmentElement: function(tree) { this.visitAny(tree.assignment); this.visitAny(tree.initializer); }, visitAwaitExpression: function(tree) { this.visitAny(tree.expression); }, visitBinaryExpression: function(tree) { this.visitAny(tree.left); this.visitAny(tree.right); }, visitBindingElement: function(tree) { this.visitAny(tree.binding); this.visitAny(tree.initializer); }, visitBindingIdentifier: function(tree) {}, visitBlock: function(tree) { this.visitList(tree.statements); }, visitBreakStatement: function(tree) {}, visitCallExpression: function(tree) { this.visitAny(tree.operand); this.visitAny(tree.args); }, visitCaseClause: function(tree) { this.visitAny(tree.expression); this.visitList(tree.statements); }, visitCatch: function(tree) { this.visitAny(tree.binding); this.visitAny(tree.catchBody); }, visitClassDeclaration: function(tree) { this.visitAny(tree.name); this.visitAny(tree.superClass); this.visitList(tree.elements); this.visitList(tree.annotations); }, visitClassExpression: function(tree) { this.visitAny(tree.name); this.visitAny(tree.superClass); this.visitList(tree.elements); this.visitList(tree.annotations); }, visitCommaExpression: function(tree) { this.visitList(tree.expressions); }, visitComprehensionFor: function(tree) { this.visitAny(tree.left); this.visitAny(tree.iterator); }, visitComprehensionIf: function(tree) { this.visitAny(tree.expression); }, visitComputedPropertyName: function(tree) { this.visitAny(tree.expression); }, visitConditionalExpression: function(tree) { this.visitAny(tree.condition); this.visitAny(tree.left); this.visitAny(tree.right); }, visitContinueStatement: function(tree) {}, visitCoverFormals: function(tree) { this.visitList(tree.expressions); }, visitCoverInitializedName: function(tree) { this.visitAny(tree.initializer); }, visitDebuggerStatement: function(tree) {}, visitDefaultClause: function(tree) { this.visitList(tree.statements); }, visitDoWhileStatement: function(tree) { this.visitAny(tree.body); this.visitAny(tree.condition); }, visitEmptyStatement: function(tree) {}, visitExportDeclaration: function(tree) { this.visitAny(tree.declaration); this.visitList(tree.annotations); }, visitExportDefault: function(tree) { this.visitAny(tree.expression); }, visitExportSpecifier: function(tree) {}, visitExportSpecifierSet: function(tree) { this.visitList(tree.specifiers); }, visitExportStar: function(tree) {}, visitExpressionStatement: function(tree) { this.visitAny(tree.expression); }, visitFinally: function(tree) { this.visitAny(tree.block); }, visitForInStatement: function(tree) { this.visitAny(tree.initializer); this.visitAny(tree.collection); this.visitAny(tree.body); }, visitForOfStatement: function(tree) { this.visitAny(tree.initializer); this.visitAny(tree.collection); this.visitAny(tree.body); }, visitForStatement: function(tree) { this.visitAny(tree.initializer); this.visitAny(tree.condition); this.visitAny(tree.increment); this.visitAny(tree.body); }, visitFormalParameter: function(tree) { this.visitAny(tree.parameter); this.visitAny(tree.typeAnnotation); this.visitList(tree.annotations); }, visitFormalParameterList: function(tree) { this.visitList(tree.parameters); }, visitFunctionBody: function(tree) { this.visitList(tree.statements); }, visitFunctionDeclaration: function(tree) { this.visitAny(tree.name); this.visitAny(tree.parameterList); this.visitAny(tree.typeAnnotation); this.visitList(tree.annotations); this.visitAny(tree.body); }, visitFunctionExpression: function(tree) { this.visitAny(tree.name); this.visitAny(tree.parameterList); this.visitAny(tree.typeAnnotation); this.visitList(tree.annotations); this.visitAny(tree.body); }, visitGeneratorComprehension: function(tree) { this.visitList(tree.comprehensionList); this.visitAny(tree.expression); }, visitGetAccessor: function(tree) { this.visitAny(tree.name); this.visitAny(tree.typeAnnotation); this.visitList(tree.annotations); this.visitAny(tree.body); }, visitIdentifierExpression: function(tree) {}, visitIfStatement: function(tree) { this.visitAny(tree.condition); this.visitAny(tree.ifClause); this.visitAny(tree.elseClause); }, visitImportedBinding: function(tree) { this.visitAny(tree.binding); }, visitImportDeclaration: function(tree) { this.visitAny(tree.importClause); this.visitAny(tree.moduleSpecifier); }, visitImportSpecifier: function(tree) {}, visitImportSpecifierSet: function(tree) { this.visitList(tree.specifiers); }, visitLabelledStatement: function(tree) { this.visitAny(tree.statement); }, visitLiteralExpression: function(tree) {}, visitLiteralPropertyName: function(tree) {}, visitMemberExpression: function(tree) { this.visitAny(tree.operand); }, visitMemberLookupExpression: function(tree) { this.visitAny(tree.operand); this.visitAny(tree.memberExpression); }, visitModule: function(tree) { this.visitList(tree.scriptItemList); }, visitModuleDeclaration: function(tree) { this.visitAny(tree.expression); }, visitModuleSpecifier: function(tree) {}, visitNamedExport: function(tree) { this.visitAny(tree.moduleSpecifier); this.visitAny(tree.specifierSet); }, visitNewExpression: function(tree) { this.visitAny(tree.operand); this.visitAny(tree.args); }, visitObjectLiteralExpression: function(tree) { this.visitList(tree.propertyNameAndValues); }, visitObjectPattern: function(tree) { this.visitList(tree.fields); }, visitObjectPatternField: function(tree) { this.visitAny(tree.name); this.visitAny(tree.element); }, visitParenExpression: function(tree) { this.visitAny(tree.expression); }, visitPostfixExpression: function(tree) { this.visitAny(tree.operand); }, visitPredefinedType: function(tree) {}, visitScript: function(tree) { this.visitList(tree.scriptItemList); }, visitPropertyMethodAssignment: function(tree) { this.visitAny(tree.name); this.visitAny(tree.parameterList); this.visitAny(tree.typeAnnotation); this.visitList(tree.annotations); this.visitAny(tree.body); }, visitPropertyNameAssignment: function(tree) { this.visitAny(tree.name); this.visitAny(tree.value); }, visitPropertyNameShorthand: function(tree) {}, visitRestParameter: function(tree) { this.visitAny(tree.identifier); }, visitReturnStatement: function(tree) { this.visitAny(tree.expression); }, visitSetAccessor: function(tree) { this.visitAny(tree.name); this.visitAny(tree.parameterList); this.visitList(tree.annotations); this.visitAny(tree.body); }, visitSpreadExpression: function(tree) { this.visitAny(tree.expression); }, visitSpreadPatternElement: function(tree) { this.visitAny(tree.lvalue); }, visitSuperExpression: function(tree) {}, visitSwitchStatement: function(tree) { this.visitAny(tree.expression); this.visitList(tree.caseClauses); }, visitSyntaxErrorTree: function(tree) {}, visitTemplateLiteralExpression: function(tree) { this.visitAny(tree.operand); this.visitList(tree.elements); }, visitTemplateLiteralPortion: function(tree) {}, visitTemplateSubstitution: function(tree) { this.visitAny(tree.expression); }, visitThisExpression: function(tree) {}, visitThrowStatement: function(tree) { this.visitAny(tree.value); }, visitTryStatement: function(tree) { this.visitAny(tree.body); this.visitAny(tree.catchBlock); this.visitAny(tree.finallyBlock); }, visitTypeName: function(tree) { this.visitAny(tree.moduleName); }, visitUnaryExpression: function(tree) { this.visitAny(tree.operand); }, visitVariableDeclaration: function(tree) { this.visitAny(tree.lvalue); this.visitAny(tree.typeAnnotation); this.visitAny(tree.initializer); }, visitVariableDeclarationList: function(tree) { this.visitList(tree.declarations); }, visitVariableStatement: function(tree) { this.visitAny(tree.declarations); }, visitWhileStatement: function(tree) { this.visitAny(tree.condition); this.visitAny(tree.body); }, visitWithStatement: function(tree) { this.visitAny(tree.expression); this.visitAny(tree.body); }, visitYieldExpression: function(tree) { this.visitAny(tree.expression); } }, {}); return {get ParseTreeVisitor() { return ParseTreeVisitor; }}; }); System.register("traceur@0.0.52/src/syntax/Token", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/syntax/Token"; var $__45 = System.get("traceur@0.0.52/src/syntax/TokenType"), AMPERSAND_EQUAL = $__45.AMPERSAND_EQUAL, BAR_EQUAL = $__45.BAR_EQUAL, CARET_EQUAL = $__45.CARET_EQUAL, EQUAL = $__45.EQUAL, LEFT_SHIFT_EQUAL = $__45.LEFT_SHIFT_EQUAL, MINUS_EQUAL = $__45.MINUS_EQUAL, PERCENT_EQUAL = $__45.PERCENT_EQUAL, PLUS_EQUAL = $__45.PLUS_EQUAL, RIGHT_SHIFT_EQUAL = $__45.RIGHT_SHIFT_EQUAL, SLASH_EQUAL = $__45.SLASH_EQUAL, STAR_EQUAL = $__45.STAR_EQUAL, UNSIGNED_RIGHT_SHIFT_EQUAL = $__45.UNSIGNED_RIGHT_SHIFT_EQUAL; var Token = function Token(type, location) { this.type = type; this.location = location; }; ($traceurRuntime.createClass)(Token, { toString: function() { return this.type; }, isAssignmentOperator: function() { return isAssignmentOperator(this.type); }, isKeyword: function() { return false; }, isStrictKeyword: function() { return false; } }, {}); function isAssignmentOperator(type) { switch (type) { case AMPERSAND_EQUAL: case BAR_EQUAL: case CARET_EQUAL: case EQUAL: case LEFT_SHIFT_EQUAL: case MINUS_EQUAL: case PERCENT_EQUAL: case PLUS_EQUAL: case RIGHT_SHIFT_EQUAL: case SLASH_EQUAL: case STAR_EQUAL: case UNSIGNED_RIGHT_SHIFT_EQUAL: return true; } return false; } return { get Token() { return Token; }, get isAssignmentOperator() { return isAssignmentOperator; } }; }); System.register("traceur@0.0.52/src/syntax/IdentifierToken", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/syntax/IdentifierToken"; var Token = System.get("traceur@0.0.52/src/syntax/Token").Token; var IDENTIFIER = System.get("traceur@0.0.52/src/syntax/TokenType").IDENTIFIER; var IdentifierToken = function IdentifierToken(location, value) { this.location = location; this.value = value; }; ($traceurRuntime.createClass)(IdentifierToken, { toString: function() { return this.value; }, get type() { return IDENTIFIER; } }, {}, Token); return {get IdentifierToken() { return IdentifierToken; }}; }); System.register("traceur@0.0.52/src/util/JSON", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/util/JSON"; function transform(v) { var replacer = arguments[1] !== (void 0) ? arguments[1] : (function(k, v) { return v; }); return transform_(replacer('', v), replacer); } function transform_(v, replacer) { var rv, tv; if (Array.isArray(v)) { var len = v.length; rv = Array(len); for (var i = 0; i < len; i++) { tv = transform_(replacer(String(i), v[i]), replacer); rv[i] = tv === undefined ? null : tv; } return rv; } if (v instanceof Object) { rv = {}; Object.keys(v).forEach((function(k) { tv = transform_(replacer(k, v[k]), replacer); if (tv !== undefined) { rv[k] = tv; } })); return rv; } return v; } return {get transform() { return transform; }}; }); System.register("traceur@0.0.52/src/syntax/PredefinedName", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/syntax/PredefinedName"; var $ARGUMENTS = '$arguments'; var ANY = 'any'; var APPLY = 'apply'; var ARGUMENTS = 'arguments'; var ARRAY = 'Array'; var AS = 'as'; var ASYNC = 'async'; var AWAIT = 'await'; var BIND = 'bind'; var CALL = 'call'; var CONFIGURABLE = 'configurable'; var CONSTRUCTOR = 'constructor'; var CREATE = 'create'; var CURRENT = 'current'; var DEFINE_PROPERTY = 'defineProperty'; var ENUMERABLE = 'enumerable'; var FREEZE = 'freeze'; var FROM = 'from'; var FUNCTION = 'Function'; var GET = 'get'; var HAS = 'has'; var LENGTH = 'length'; var MODULE = 'module'; var NEW = 'new'; var OBJECT = 'Object'; var OBJECT_NAME = 'Object'; var OF = 'of'; var PREVENT_EXTENSIONS = 'preventExtensions'; var PROTOTYPE = 'prototype'; var PUSH = 'push'; var SET = 'set'; var SLICE = 'slice'; var THIS = 'this'; var TRACEUR_RUNTIME = '$traceurRuntime'; var UNDEFINED = 'undefined'; var WRITABLE = 'writable'; return { get $ARGUMENTS() { return $ARGUMENTS; }, get ANY() { return ANY; }, get APPLY() { return APPLY; }, get ARGUMENTS() { return ARGUMENTS; }, get ARRAY() { return ARRAY; }, get AS() { return AS; }, get ASYNC() { return ASYNC; }, get AWAIT() { return AWAIT; }, get BIND() { return BIND; }, get CALL() { return CALL; }, get CONFIGURABLE() { return CONFIGURABLE; }, get CONSTRUCTOR() { return CONSTRUCTOR; }, get CREATE() { return CREATE; }, get CURRENT() { return CURRENT; }, get DEFINE_PROPERTY() { return DEFINE_PROPERTY; }, get ENUMERABLE() { return ENUMERABLE; }, get FREEZE() { return FREEZE; }, get FROM() { return FROM; }, get FUNCTION() { return FUNCTION; }, get GET() { return GET; }, get HAS() { return HAS; }, get LENGTH() { return LENGTH; }, get MODULE() { return MODULE; }, get NEW() { return NEW; }, get OBJECT() { return OBJECT; }, get OBJECT_NAME() { return OBJECT_NAME; }, get OF() { return OF; }, get PREVENT_EXTENSIONS() { return PREVENT_EXTENSIONS; }, get PROTOTYPE() { return PROTOTYPE; }, get PUSH() { return PUSH; }, get SET() { return SET; }, get SLICE() { return SLICE; }, get THIS() { return THIS; }, get TRACEUR_RUNTIME() { return TRACEUR_RUNTIME; }, get UNDEFINED() { return UNDEFINED; }, get WRITABLE() { return WRITABLE; } }; }); System.register("traceur@0.0.52/src/syntax/trees/ParseTree", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/syntax/trees/ParseTree"; var ParseTreeType = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"); var $__50 = System.get("traceur@0.0.52/src/syntax/TokenType"), IDENTIFIER = $__50.IDENTIFIER, STAR = $__50.STAR, STRING = $__50.STRING, VAR = $__50.VAR; var Token = System.get("traceur@0.0.52/src/syntax/Token").Token; var utilJSON = System.get("traceur@0.0.52/src/util/JSON"); var ASYNC = System.get("traceur@0.0.52/src/syntax/PredefinedName").ASYNC; var $__53 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), ARRAY_COMPREHENSION = $__53.ARRAY_COMPREHENSION, ARRAY_LITERAL_EXPRESSION = $__53.ARRAY_LITERAL_EXPRESSION, ARRAY_PATTERN = $__53.ARRAY_PATTERN, ARROW_FUNCTION_EXPRESSION = $__53.ARROW_FUNCTION_EXPRESSION, AWAIT_EXPRESSION = $__53.AWAIT_EXPRESSION, BINARY_EXPRESSION = $__53.BINARY_EXPRESSION, BLOCK = $__53.BLOCK, BREAK_STATEMENT = $__53.BREAK_STATEMENT, CALL_EXPRESSION = $__53.CALL_EXPRESSION, CLASS_DECLARATION = $__53.CLASS_DECLARATION, CLASS_EXPRESSION = $__53.CLASS_EXPRESSION, COMMA_EXPRESSION = $__53.COMMA_EXPRESSION, CONDITIONAL_EXPRESSION = $__53.CONDITIONAL_EXPRESSION, CONTINUE_STATEMENT = $__53.CONTINUE_STATEMENT, DEBUGGER_STATEMENT = $__53.DEBUGGER_STATEMENT, DO_WHILE_STATEMENT = $__53.DO_WHILE_STATEMENT, EMPTY_STATEMENT = $__53.EMPTY_STATEMENT, EXPORT_DECLARATION = $__53.EXPORT_DECLARATION, EXPRESSION_STATEMENT = $__53.EXPRESSION_STATEMENT, FOR_IN_STATEMENT = $__53.FOR_IN_STATEMENT, FOR_OF_STATEMENT = $__53.FOR_OF_STATEMENT, FOR_STATEMENT = $__53.FOR_STATEMENT, FORMAL_PARAMETER = $__53.FORMAL_PARAMETER, FUNCTION_DECLARATION = $__53.FUNCTION_DECLARATION, FUNCTION_EXPRESSION = $__53.FUNCTION_EXPRESSION, GENERATOR_COMPREHENSION = $__53.GENERATOR_COMPREHENSION, IDENTIFIER_EXPRESSION = $__53.IDENTIFIER_EXPRESSION, IF_STATEMENT = $__53.IF_STATEMENT, IMPORT_DECLARATION = $__53.IMPORT_DECLARATION, LABELLED_STATEMENT = $__53.LABELLED_STATEMENT, LITERAL_EXPRESSION = $__53.LITERAL_EXPRESSION, MEMBER_EXPRESSION = $__53.MEMBER_EXPRESSION, MEMBER_LOOKUP_EXPRESSION = $__53.MEMBER_LOOKUP_EXPRESSION, MODULE_DECLARATION = $__53.MODULE_DECLARATION, NEW_EXPRESSION = $__53.NEW_EXPRESSION, OBJECT_LITERAL_EXPRESSION = $__53.OBJECT_LITERAL_EXPRESSION, OBJECT_PATTERN = $__53.OBJECT_PATTERN, PAREN_EXPRESSION = $__53.PAREN_EXPRESSION, POSTFIX_EXPRESSION = $__53.POSTFIX_EXPRESSION, REST_PARAMETER = $__53.REST_PARAMETER, RETURN_STATEMENT = $__53.RETURN_STATEMENT, SPREAD_EXPRESSION = $__53.SPREAD_EXPRESSION, SPREAD_PATTERN_ELEMENT = $__53.SPREAD_PATTERN_ELEMENT, SUPER_EXPRESSION = $__53.SUPER_EXPRESSION, SWITCH_STATEMENT = $__53.SWITCH_STATEMENT, TEMPLATE_LITERAL_EXPRESSION = $__53.TEMPLATE_LITERAL_EXPRESSION, THIS_EXPRESSION = $__53.THIS_EXPRESSION, THROW_STATEMENT = $__53.THROW_STATEMENT, TRY_STATEMENT = $__53.TRY_STATEMENT, UNARY_EXPRESSION = $__53.UNARY_EXPRESSION, VARIABLE_DECLARATION = $__53.VARIABLE_DECLARATION, VARIABLE_STATEMENT = $__53.VARIABLE_STATEMENT, WHILE_STATEMENT = $__53.WHILE_STATEMENT, WITH_STATEMENT = $__53.WITH_STATEMENT, YIELD_EXPRESSION = $__53.YIELD_EXPRESSION; ; var ParseTree = function ParseTree(type, location) { throw new Error("Don't use for now. 'super' is currently very slow."); this.type = type; this.location = location; }; var $ParseTree = ParseTree; ($traceurRuntime.createClass)(ParseTree, { isPattern: function() { switch (this.type) { case ARRAY_PATTERN: case OBJECT_PATTERN: return true; default: return false; } }, isLeftHandSideExpression: function() { switch (this.type) { case THIS_EXPRESSION: case CLASS_EXPRESSION: case SUPER_EXPRESSION: case IDENTIFIER_EXPRESSION: case LITERAL_EXPRESSION: case ARRAY_LITERAL_EXPRESSION: case OBJECT_LITERAL_EXPRESSION: case NEW_EXPRESSION: case MEMBER_EXPRESSION: case MEMBER_LOOKUP_EXPRESSION: case CALL_EXPRESSION: case FUNCTION_EXPRESSION: case TEMPLATE_LITERAL_EXPRESSION: return true; case PAREN_EXPRESSION: return this.expression.isLeftHandSideExpression(); default: return false; } }, isAssignmentExpression: function() { switch (this.type) { case ARRAY_COMPREHENSION: case ARRAY_LITERAL_EXPRESSION: case ARROW_FUNCTION_EXPRESSION: case AWAIT_EXPRESSION: case BINARY_EXPRESSION: case CALL_EXPRESSION: case CLASS_EXPRESSION: case CONDITIONAL_EXPRESSION: case FUNCTION_EXPRESSION: case GENERATOR_COMPREHENSION: case IDENTIFIER_EXPRESSION: case LITERAL_EXPRESSION: case MEMBER_EXPRESSION: case MEMBER_LOOKUP_EXPRESSION: case NEW_EXPRESSION: case OBJECT_LITERAL_EXPRESSION: case PAREN_EXPRESSION: case POSTFIX_EXPRESSION: case TEMPLATE_LITERAL_EXPRESSION: case SUPER_EXPRESSION: case THIS_EXPRESSION: case UNARY_EXPRESSION: case YIELD_EXPRESSION: return true; default: return false; } }, isMemberExpression: function() { switch (this.type) { case THIS_EXPRESSION: case CLASS_EXPRESSION: case SUPER_EXPRESSION: case IDENTIFIER_EXPRESSION: case LITERAL_EXPRESSION: case ARRAY_LITERAL_EXPRESSION: case OBJECT_LITERAL_EXPRESSION: case PAREN_EXPRESSION: case TEMPLATE_LITERAL_EXPRESSION: case FUNCTION_EXPRESSION: case MEMBER_LOOKUP_EXPRESSION: case MEMBER_EXPRESSION: case CALL_EXPRESSION: return true; case NEW_EXPRESSION: return this.args != null; } return false; }, isExpression: function() { return this.isAssignmentExpression() || this.type == COMMA_EXPRESSION; }, isAssignmentOrSpread: function() { return this.isAssignmentExpression() || this.type == SPREAD_EXPRESSION; }, isRestParameter: function() { return this.type == REST_PARAMETER || (this.type == FORMAL_PARAMETER && this.parameter.isRestParameter()); }, isSpreadPatternElement: function() { return this.type == SPREAD_PATTERN_ELEMENT; }, isStatementListItem: function() { return this.isStatement() || this.isDeclaration(); }, isStatement: function() { switch (this.type) { case BLOCK: case VARIABLE_STATEMENT: case EMPTY_STATEMENT: case EXPRESSION_STATEMENT: case IF_STATEMENT: case CONTINUE_STATEMENT: case BREAK_STATEMENT: case RETURN_STATEMENT: case WITH_STATEMENT: case LABELLED_STATEMENT: case THROW_STATEMENT: case TRY_STATEMENT: case DEBUGGER_STATEMENT: return true; } return this.isBreakableStatement(); }, isDeclaration: function() { switch (this.type) { case FUNCTION_DECLARATION: case CLASS_DECLARATION: return true; } return this.isLexicalDeclaration(); }, isLexicalDeclaration: function() { switch (this.type) { case VARIABLE_STATEMENT: return this.declarations.declarationType !== VAR; } return false; }, isBreakableStatement: function() { switch (this.type) { case SWITCH_STATEMENT: return true; } return this.isIterationStatement(); }, isIterationStatement: function() { switch (this.type) { case DO_WHILE_STATEMENT: case FOR_IN_STATEMENT: case FOR_OF_STATEMENT: case FOR_STATEMENT: case WHILE_STATEMENT: return true; } return false; }, isScriptElement: function() { switch (this.type) { case CLASS_DECLARATION: case EXPORT_DECLARATION: case FUNCTION_DECLARATION: case IMPORT_DECLARATION: case MODULE_DECLARATION: case VARIABLE_DECLARATION: return true; } return this.isStatement(); }, isGenerator: function() { return this.functionKind !== null && this.functionKind.type === STAR; }, isAsyncFunction: function() { return this.functionKind !== null && this.functionKind.type === IDENTIFIER && this.functionKind.value === ASYNC; }, getDirectivePrologueStringToken_: function() { var tree = this; if (tree.type !== EXPRESSION_STATEMENT || !(tree = tree.expression)) return null; if (tree.type !== LITERAL_EXPRESSION || !(tree = tree.literalToken)) return null; if (tree.type !== STRING) return null; return tree; }, isDirectivePrologue: function() { return this.getDirectivePrologueStringToken_() !== null; }, isUseStrictDirective: function() { var token = this.getDirectivePrologueStringToken_(); if (!token) return false; var v = token.value; return v === '"use strict"' || v === "'use strict'"; }, toJSON: function() { return utilJSON.transform(this, $ParseTree.replacer); }, stringify: function() { var indent = arguments[0] !== (void 0) ? arguments[0] : 2; return JSON.stringify(this, $ParseTree.replacer, indent); } }, { stripLocation: function(key, value) { if (key === 'location') { return undefined; } return value; }, replacer: function(k, v) { if (v instanceof $ParseTree || v instanceof Token) { var rv = {type: v.type}; Object.keys(v).forEach(function(name) { if (name !== 'location') rv[name] = v[name]; }); return rv; } return v; } }); return { get ParseTreeType() { return ParseTreeType; }, get ParseTree() { return ParseTree; } }; }); System.register("traceur@0.0.52/src/syntax/trees/ParseTrees", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/syntax/trees/ParseTrees"; var ParseTree = System.get("traceur@0.0.52/src/syntax/trees/ParseTree").ParseTree; var ParseTreeType = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"); var ANNOTATION = ParseTreeType.ANNOTATION; var Annotation = function Annotation(location, name, args) { this.location = location; this.name = name; this.args = args; }; ($traceurRuntime.createClass)(Annotation, { transform: function(transformer) { return transformer.transformAnnotation(this); }, visit: function(visitor) { visitor.visitAnnotation(this); }, get type() { return ANNOTATION; } }, {}, ParseTree); var ANON_BLOCK = ParseTreeType.ANON_BLOCK; var AnonBlock = function AnonBlock(location, statements) { this.location = location; this.statements = statements; }; ($traceurRuntime.createClass)(AnonBlock, { transform: function(transformer) { return transformer.transformAnonBlock(this); }, visit: function(visitor) { visitor.visitAnonBlock(this); }, get type() { return ANON_BLOCK; } }, {}, ParseTree); var ARGUMENT_LIST = ParseTreeType.ARGUMENT_LIST; var ArgumentList = function ArgumentList(location, args) { this.location = location; this.args = args; }; ($traceurRuntime.createClass)(ArgumentList, { transform: function(transformer) { return transformer.transformArgumentList(this); }, visit: function(visitor) { visitor.visitArgumentList(this); }, get type() { return ARGUMENT_LIST; } }, {}, ParseTree); var ARRAY_COMPREHENSION = ParseTreeType.ARRAY_COMPREHENSION; var ArrayComprehension = function ArrayComprehension(location, comprehensionList, expression) { this.location = location; this.comprehensionList = comprehensionList; this.expression = expression; }; ($traceurRuntime.createClass)(ArrayComprehension, { transform: function(transformer) { return transformer.transformArrayComprehension(this); }, visit: function(visitor) { visitor.visitArrayComprehension(this); }, get type() { return ARRAY_COMPREHENSION; } }, {}, ParseTree); var ARRAY_LITERAL_EXPRESSION = ParseTreeType.ARRAY_LITERAL_EXPRESSION; var ArrayLiteralExpression = function ArrayLiteralExpression(location, elements) { this.location = location; this.elements = elements; }; ($traceurRuntime.createClass)(ArrayLiteralExpression, { transform: function(transformer) { return transformer.transformArrayLiteralExpression(this); }, visit: function(visitor) { visitor.visitArrayLiteralExpression(this); }, get type() { return ARRAY_LITERAL_EXPRESSION; } }, {}, ParseTree); var ARRAY_PATTERN = ParseTreeType.ARRAY_PATTERN; var ArrayPattern = function ArrayPattern(location, elements) { this.location = location; this.elements = elements; }; ($traceurRuntime.createClass)(ArrayPattern, { transform: function(transformer) { return transformer.transformArrayPattern(this); }, visit: function(visitor) { visitor.visitArrayPattern(this); }, get type() { return ARRAY_PATTERN; } }, {}, ParseTree); var ARROW_FUNCTION_EXPRESSION = ParseTreeType.ARROW_FUNCTION_EXPRESSION; var ArrowFunctionExpression = function ArrowFunctionExpression(location, functionKind, parameterList, body) { this.location = location; this.functionKind = functionKind; this.parameterList = parameterList; this.body = body; }; ($traceurRuntime.createClass)(ArrowFunctionExpression, { transform: function(transformer) { return transformer.transformArrowFunctionExpression(this); }, visit: function(visitor) { visitor.visitArrowFunctionExpression(this); }, get type() { return ARROW_FUNCTION_EXPRESSION; } }, {}, ParseTree); var ASSIGNMENT_ELEMENT = ParseTreeType.ASSIGNMENT_ELEMENT; var AssignmentElement = function AssignmentElement(location, assignment, initializer) { this.location = location; this.assignment = assignment; this.initializer = initializer; }; ($traceurRuntime.createClass)(AssignmentElement, { transform: function(transformer) { return transformer.transformAssignmentElement(this); }, visit: function(visitor) { visitor.visitAssignmentElement(this); }, get type() { return ASSIGNMENT_ELEMENT; } }, {}, ParseTree); var AWAIT_EXPRESSION = ParseTreeType.AWAIT_EXPRESSION; var AwaitExpression = function AwaitExpression(location, expression) { this.location = location; this.expression = expression; }; ($traceurRuntime.createClass)(AwaitExpression, { transform: function(transformer) { return transformer.transformAwaitExpression(this); }, visit: function(visitor) { visitor.visitAwaitExpression(this); }, get type() { return AWAIT_EXPRESSION; } }, {}, ParseTree); var BINARY_EXPRESSION = ParseTreeType.BINARY_EXPRESSION; var BinaryExpression = function BinaryExpression(location, left, operator, right) { this.location = location; this.left = left; this.operator = operator; this.right = right; }; ($traceurRuntime.createClass)(BinaryExpression, { transform: function(transformer) { return transformer.transformBinaryExpression(this); }, visit: function(visitor) { visitor.visitBinaryExpression(this); }, get type() { return BINARY_EXPRESSION; } }, {}, ParseTree); var BINDING_ELEMENT = ParseTreeType.BINDING_ELEMENT; var BindingElement = function BindingElement(location, binding, initializer) { this.location = location; this.binding = binding; this.initializer = initializer; }; ($traceurRuntime.createClass)(BindingElement, { transform: function(transformer) { return transformer.transformBindingElement(this); }, visit: function(visitor) { visitor.visitBindingElement(this); }, get type() { return BINDING_ELEMENT; } }, {}, ParseTree); var BINDING_IDENTIFIER = ParseTreeType.BINDING_IDENTIFIER; var BindingIdentifier = function BindingIdentifier(location, identifierToken) { this.location = location; this.identifierToken = identifierToken; }; ($traceurRuntime.createClass)(BindingIdentifier, { transform: function(transformer) { return transformer.transformBindingIdentifier(this); }, visit: function(visitor) { visitor.visitBindingIdentifier(this); }, get type() { return BINDING_IDENTIFIER; } }, {}, ParseTree); var BLOCK = ParseTreeType.BLOCK; var Block = function Block(location, statements) { this.location = location; this.statements = statements; }; ($traceurRuntime.createClass)(Block, { transform: function(transformer) { return transformer.transformBlock(this); }, visit: function(visitor) { visitor.visitBlock(this); }, get type() { return BLOCK; } }, {}, ParseTree); var BREAK_STATEMENT = ParseTreeType.BREAK_STATEMENT; var BreakStatement = function BreakStatement(location, name) { this.location = location; this.name = name; }; ($traceurRuntime.createClass)(BreakStatement, { transform: function(transformer) { return transformer.transformBreakStatement(this); }, visit: function(visitor) { visitor.visitBreakStatement(this); }, get type() { return BREAK_STATEMENT; } }, {}, ParseTree); var CALL_EXPRESSION = ParseTreeType.CALL_EXPRESSION; var CallExpression = function CallExpression(location, operand, args) { this.location = location; this.operand = operand; this.args = args; }; ($traceurRuntime.createClass)(CallExpression, { transform: function(transformer) { return transformer.transformCallExpression(this); }, visit: function(visitor) { visitor.visitCallExpression(this); }, get type() { return CALL_EXPRESSION; } }, {}, ParseTree); var CASE_CLAUSE = ParseTreeType.CASE_CLAUSE; var CaseClause = function CaseClause(location, expression, statements) { this.location = location; this.expression = expression; this.statements = statements; }; ($traceurRuntime.createClass)(CaseClause, { transform: function(transformer) { return transformer.transformCaseClause(this); }, visit: function(visitor) { visitor.visitCaseClause(this); }, get type() { return CASE_CLAUSE; } }, {}, ParseTree); var CATCH = ParseTreeType.CATCH; var Catch = function Catch(location, binding, catchBody) { this.location = location; this.binding = binding; this.catchBody = catchBody; }; ($traceurRuntime.createClass)(Catch, { transform: function(transformer) { return transformer.transformCatch(this); }, visit: function(visitor) { visitor.visitCatch(this); }, get type() { return CATCH; } }, {}, ParseTree); var CLASS_DECLARATION = ParseTreeType.CLASS_DECLARATION; var ClassDeclaration = function ClassDeclaration(location, name, superClass, elements, annotations) { this.location = location; this.name = name; this.superClass = superClass; this.elements = elements; this.annotations = annotations; }; ($traceurRuntime.createClass)(ClassDeclaration, { transform: function(transformer) { return transformer.transformClassDeclaration(this); }, visit: function(visitor) { visitor.visitClassDeclaration(this); }, get type() { return CLASS_DECLARATION; } }, {}, ParseTree); var CLASS_EXPRESSION = ParseTreeType.CLASS_EXPRESSION; var ClassExpression = function ClassExpression(location, name, superClass, elements, annotations) { this.location = location; this.name = name; this.superClass = superClass; this.elements = elements; this.annotations = annotations; }; ($traceurRuntime.createClass)(ClassExpression, { transform: function(transformer) { return transformer.transformClassExpression(this); }, visit: function(visitor) { visitor.visitClassExpression(this); }, get type() { return CLASS_EXPRESSION; } }, {}, ParseTree); var COMMA_EXPRESSION = ParseTreeType.COMMA_EXPRESSION; var CommaExpression = function CommaExpression(location, expressions) { this.location = location; this.expressions = expressions; }; ($traceurRuntime.createClass)(CommaExpression, { transform: function(transformer) { return transformer.transformCommaExpression(this); }, visit: function(visitor) { visitor.visitCommaExpression(this); }, get type() { return COMMA_EXPRESSION; } }, {}, ParseTree); var COMPREHENSION_FOR = ParseTreeType.COMPREHENSION_FOR; var ComprehensionFor = function ComprehensionFor(location, left, iterator) { this.location = location; this.left = left; this.iterator = iterator; }; ($traceurRuntime.createClass)(ComprehensionFor, { transform: function(transformer) { return transformer.transformComprehensionFor(this); }, visit: function(visitor) { visitor.visitComprehensionFor(this); }, get type() { return COMPREHENSION_FOR; } }, {}, ParseTree); var COMPREHENSION_IF = ParseTreeType.COMPREHENSION_IF; var ComprehensionIf = function ComprehensionIf(location, expression) { this.location = location; this.expression = expression; }; ($traceurRuntime.createClass)(ComprehensionIf, { transform: function(transformer) { return transformer.transformComprehensionIf(this); }, visit: function(visitor) { visitor.visitComprehensionIf(this); }, get type() { return COMPREHENSION_IF; } }, {}, ParseTree); var COMPUTED_PROPERTY_NAME = ParseTreeType.COMPUTED_PROPERTY_NAME; var ComputedPropertyName = function ComputedPropertyName(location, expression) { this.location = location; this.expression = expression; }; ($traceurRuntime.createClass)(ComputedPropertyName, { transform: function(transformer) { return transformer.transformComputedPropertyName(this); }, visit: function(visitor) { visitor.visitComputedPropertyName(this); }, get type() { return COMPUTED_PROPERTY_NAME; } }, {}, ParseTree); var CONDITIONAL_EXPRESSION = ParseTreeType.CONDITIONAL_EXPRESSION; var ConditionalExpression = function ConditionalExpression(location, condition, left, right) { this.location = location; this.condition = condition; this.left = left; this.right = right; }; ($traceurRuntime.createClass)(ConditionalExpression, { transform: function(transformer) { return transformer.transformConditionalExpression(this); }, visit: function(visitor) { visitor.visitConditionalExpression(this); }, get type() { return CONDITIONAL_EXPRESSION; } }, {}, ParseTree); var CONTINUE_STATEMENT = ParseTreeType.CONTINUE_STATEMENT; var ContinueStatement = function ContinueStatement(location, name) { this.location = location; this.name = name; }; ($traceurRuntime.createClass)(ContinueStatement, { transform: function(transformer) { return transformer.transformContinueStatement(this); }, visit: function(visitor) { visitor.visitContinueStatement(this); }, get type() { return CONTINUE_STATEMENT; } }, {}, ParseTree); var COVER_FORMALS = ParseTreeType.COVER_FORMALS; var CoverFormals = function CoverFormals(location, expressions) { this.location = location; this.expressions = expressions; }; ($traceurRuntime.createClass)(CoverFormals, { transform: function(transformer) { return transformer.transformCoverFormals(this); }, visit: function(visitor) { visitor.visitCoverFormals(this); }, get type() { return COVER_FORMALS; } }, {}, ParseTree); var COVER_INITIALIZED_NAME = ParseTreeType.COVER_INITIALIZED_NAME; var CoverInitializedName = function CoverInitializedName(location, name, equalToken, initializer) { this.location = location; this.name = name; this.equalToken = equalToken; this.initializer = initializer; }; ($traceurRuntime.createClass)(CoverInitializedName, { transform: function(transformer) { return transformer.transformCoverInitializedName(this); }, visit: function(visitor) { visitor.visitCoverInitializedName(this); }, get type() { return COVER_INITIALIZED_NAME; } }, {}, ParseTree); var DEBUGGER_STATEMENT = ParseTreeType.DEBUGGER_STATEMENT; var DebuggerStatement = function DebuggerStatement(location) { this.location = location; }; ($traceurRuntime.createClass)(DebuggerStatement, { transform: function(transformer) { return transformer.transformDebuggerStatement(this); }, visit: function(visitor) { visitor.visitDebuggerStatement(this); }, get type() { return DEBUGGER_STATEMENT; } }, {}, ParseTree); var DEFAULT_CLAUSE = ParseTreeType.DEFAULT_CLAUSE; var DefaultClause = function DefaultClause(location, statements) { this.location = location; this.statements = statements; }; ($traceurRuntime.createClass)(DefaultClause, { transform: function(transformer) { return transformer.transformDefaultClause(this); }, visit: function(visitor) { visitor.visitDefaultClause(this); }, get type() { return DEFAULT_CLAUSE; } }, {}, ParseTree); var DO_WHILE_STATEMENT = ParseTreeType.DO_WHILE_STATEMENT; var DoWhileStatement = function DoWhileStatement(location, body, condition) { this.location = location; this.body = body; this.condition = condition; }; ($traceurRuntime.createClass)(DoWhileStatement, { transform: function(transformer) { return transformer.transformDoWhileStatement(this); }, visit: function(visitor) { visitor.visitDoWhileStatement(this); }, get type() { return DO_WHILE_STATEMENT; } }, {}, ParseTree); var EMPTY_STATEMENT = ParseTreeType.EMPTY_STATEMENT; var EmptyStatement = function EmptyStatement(location) { this.location = location; }; ($traceurRuntime.createClass)(EmptyStatement, { transform: function(transformer) { return transformer.transformEmptyStatement(this); }, visit: function(visitor) { visitor.visitEmptyStatement(this); }, get type() { return EMPTY_STATEMENT; } }, {}, ParseTree); var EXPORT_DECLARATION = ParseTreeType.EXPORT_DECLARATION; var ExportDeclaration = function ExportDeclaration(location, declaration, annotations) { this.location = location; this.declaration = declaration; this.annotations = annotations; }; ($traceurRuntime.createClass)(ExportDeclaration, { transform: function(transformer) { return transformer.transformExportDeclaration(this); }, visit: function(visitor) { visitor.visitExportDeclaration(this); }, get type() { return EXPORT_DECLARATION; } }, {}, ParseTree); var EXPORT_DEFAULT = ParseTreeType.EXPORT_DEFAULT; var ExportDefault = function ExportDefault(location, expression) { this.location = location; this.expression = expression; }; ($traceurRuntime.createClass)(ExportDefault, { transform: function(transformer) { return transformer.transformExportDefault(this); }, visit: function(visitor) { visitor.visitExportDefault(this); }, get type() { return EXPORT_DEFAULT; } }, {}, ParseTree); var EXPORT_SPECIFIER = ParseTreeType.EXPORT_SPECIFIER; var ExportSpecifier = function ExportSpecifier(location, lhs, rhs) { this.location = location; this.lhs = lhs; this.rhs = rhs; }; ($traceurRuntime.createClass)(ExportSpecifier, { transform: function(transformer) { return transformer.transformExportSpecifier(this); }, visit: function(visitor) { visitor.visitExportSpecifier(this); }, get type() { return EXPORT_SPECIFIER; } }, {}, ParseTree); var EXPORT_SPECIFIER_SET = ParseTreeType.EXPORT_SPECIFIER_SET; var ExportSpecifierSet = function ExportSpecifierSet(location, specifiers) { this.location = location; this.specifiers = specifiers; }; ($traceurRuntime.createClass)(ExportSpecifierSet, { transform: function(transformer) { return transformer.transformExportSpecifierSet(this); }, visit: function(visitor) { visitor.visitExportSpecifierSet(this); }, get type() { return EXPORT_SPECIFIER_SET; } }, {}, ParseTree); var EXPORT_STAR = ParseTreeType.EXPORT_STAR; var ExportStar = function ExportStar(location) { this.location = location; }; ($traceurRuntime.createClass)(ExportStar, { transform: function(transformer) { return transformer.transformExportStar(this); }, visit: function(visitor) { visitor.visitExportStar(this); }, get type() { return EXPORT_STAR; } }, {}, ParseTree); var EXPRESSION_STATEMENT = ParseTreeType.EXPRESSION_STATEMENT; var ExpressionStatement = function ExpressionStatement(location, expression) { this.location = location; this.expression = expression; }; ($traceurRuntime.createClass)(ExpressionStatement, { transform: function(transformer) { return transformer.transformExpressionStatement(this); }, visit: function(visitor) { visitor.visitExpressionStatement(this); }, get type() { return EXPRESSION_STATEMENT; } }, {}, ParseTree); var FINALLY = ParseTreeType.FINALLY; var Finally = function Finally(location, block) { this.location = location; this.block = block; }; ($traceurRuntime.createClass)(Finally, { transform: function(transformer) { return transformer.transformFinally(this); }, visit: function(visitor) { visitor.visitFinally(this); }, get type() { return FINALLY; } }, {}, ParseTree); var FOR_IN_STATEMENT = ParseTreeType.FOR_IN_STATEMENT; var ForInStatement = function ForInStatement(location, initializer, collection, body) { this.location = location; this.initializer = initializer; this.collection = collection; this.body = body; }; ($traceurRuntime.createClass)(ForInStatement, { transform: function(transformer) { return transformer.transformForInStatement(this); }, visit: function(visitor) { visitor.visitForInStatement(this); }, get type() { return FOR_IN_STATEMENT; } }, {}, ParseTree); var FOR_OF_STATEMENT = ParseTreeType.FOR_OF_STATEMENT; var ForOfStatement = function ForOfStatement(location, initializer, collection, body) { this.location = location; this.initializer = initializer; this.collection = collection; this.body = body; }; ($traceurRuntime.createClass)(ForOfStatement, { transform: function(transformer) { return transformer.transformForOfStatement(this); }, visit: function(visitor) { visitor.visitForOfStatement(this); }, get type() { return FOR_OF_STATEMENT; } }, {}, ParseTree); var FOR_STATEMENT = ParseTreeType.FOR_STATEMENT; var ForStatement = function ForStatement(location, initializer, condition, increment, body) { this.location = location; this.initializer = initializer; this.condition = condition; this.increment = increment; this.body = body; }; ($traceurRuntime.createClass)(ForStatement, { transform: function(transformer) { return transformer.transformForStatement(this); }, visit: function(visitor) { visitor.visitForStatement(this); }, get type() { return FOR_STATEMENT; } }, {}, ParseTree); var FORMAL_PARAMETER = ParseTreeType.FORMAL_PARAMETER; var FormalParameter = function FormalParameter(location, parameter, typeAnnotation, annotations) { this.location = location; this.parameter = parameter; this.typeAnnotation = typeAnnotation; this.annotations = annotations; }; ($traceurRuntime.createClass)(FormalParameter, { transform: function(transformer) { return transformer.transformFormalParameter(this); }, visit: function(visitor) { visitor.visitFormalParameter(this); }, get type() { return FORMAL_PARAMETER; } }, {}, ParseTree); var FORMAL_PARAMETER_LIST = ParseTreeType.FORMAL_PARAMETER_LIST; var FormalParameterList = function FormalParameterList(location, parameters) { this.location = location; this.parameters = parameters; }; ($traceurRuntime.createClass)(FormalParameterList, { transform: function(transformer) { return transformer.transformFormalParameterList(this); }, visit: function(visitor) { visitor.visitFormalParameterList(this); }, get type() { return FORMAL_PARAMETER_LIST; } }, {}, ParseTree); var FUNCTION_BODY = ParseTreeType.FUNCTION_BODY; var FunctionBody = function FunctionBody(location, statements) { this.location = location; this.statements = statements; }; ($traceurRuntime.createClass)(FunctionBody, { transform: function(transformer) { return transformer.transformFunctionBody(this); }, visit: function(visitor) { visitor.visitFunctionBody(this); }, get type() { return FUNCTION_BODY; } }, {}, ParseTree); var FUNCTION_DECLARATION = ParseTreeType.FUNCTION_DECLARATION; var FunctionDeclaration = function FunctionDeclaration(location, name, functionKind, parameterList, typeAnnotation, annotations, body) { this.location = location; this.name = name; this.functionKind = functionKind; this.parameterList = parameterList; this.typeAnnotation = typeAnnotation; this.annotations = annotations; this.body = body; }; ($traceurRuntime.createClass)(FunctionDeclaration, { transform: function(transformer) { return transformer.transformFunctionDeclaration(this); }, visit: function(visitor) { visitor.visitFunctionDeclaration(this); }, get type() { return FUNCTION_DECLARATION; } }, {}, ParseTree); var FUNCTION_EXPRESSION = ParseTreeType.FUNCTION_EXPRESSION; var FunctionExpression = function FunctionExpression(location, name, functionKind, parameterList, typeAnnotation, annotations, body) { this.location = location; this.name = name; this.functionKind = functionKind; this.parameterList = parameterList; this.typeAnnotation = typeAnnotation; this.annotations = annotations; this.body = body; }; ($traceurRuntime.createClass)(FunctionExpression, { transform: function(transformer) { return transformer.transformFunctionExpression(this); }, visit: function(visitor) { visitor.visitFunctionExpression(this); }, get type() { return FUNCTION_EXPRESSION; } }, {}, ParseTree); var GENERATOR_COMPREHENSION = ParseTreeType.GENERATOR_COMPREHENSION; var GeneratorComprehension = function GeneratorComprehension(location, comprehensionList, expression) { this.location = location; this.comprehensionList = comprehensionList; this.expression = expression; }; ($traceurRuntime.createClass)(GeneratorComprehension, { transform: function(transformer) { return transformer.transformGeneratorComprehension(this); }, visit: function(visitor) { visitor.visitGeneratorComprehension(this); }, get type() { return GENERATOR_COMPREHENSION; } }, {}, ParseTree); var GET_ACCESSOR = ParseTreeType.GET_ACCESSOR; var GetAccessor = function GetAccessor(location, isStatic, name, typeAnnotation, annotations, body) { this.location = location; this.isStatic = isStatic; this.name = name; this.typeAnnotation = typeAnnotation; this.annotations = annotations; this.body = body; }; ($traceurRuntime.createClass)(GetAccessor, { transform: function(transformer) { return transformer.transformGetAccessor(this); }, visit: function(visitor) { visitor.visitGetAccessor(this); }, get type() { return GET_ACCESSOR; } }, {}, ParseTree); var IDENTIFIER_EXPRESSION = ParseTreeType.IDENTIFIER_EXPRESSION; var IdentifierExpression = function IdentifierExpression(location, identifierToken) { this.location = location; this.identifierToken = identifierToken; }; ($traceurRuntime.createClass)(IdentifierExpression, { transform: function(transformer) { return transformer.transformIdentifierExpression(this); }, visit: function(visitor) { visitor.visitIdentifierExpression(this); }, get type() { return IDENTIFIER_EXPRESSION; } }, {}, ParseTree); var IF_STATEMENT = ParseTreeType.IF_STATEMENT; var IfStatement = function IfStatement(location, condition, ifClause, elseClause) { this.location = location; this.condition = condition; this.ifClause = ifClause; this.elseClause = elseClause; }; ($traceurRuntime.createClass)(IfStatement, { transform: function(transformer) { return transformer.transformIfStatement(this); }, visit: function(visitor) { visitor.visitIfStatement(this); }, get type() { return IF_STATEMENT; } }, {}, ParseTree); var IMPORTED_BINDING = ParseTreeType.IMPORTED_BINDING; var ImportedBinding = function ImportedBinding(location, binding) { this.location = location; this.binding = binding; }; ($traceurRuntime.createClass)(ImportedBinding, { transform: function(transformer) { return transformer.transformImportedBinding(this); }, visit: function(visitor) { visitor.visitImportedBinding(this); }, get type() { return IMPORTED_BINDING; } }, {}, ParseTree); var IMPORT_DECLARATION = ParseTreeType.IMPORT_DECLARATION; var ImportDeclaration = function ImportDeclaration(location, importClause, moduleSpecifier) { this.location = location; this.importClause = importClause; this.moduleSpecifier = moduleSpecifier; }; ($traceurRuntime.createClass)(ImportDeclaration, { transform: function(transformer) { return transformer.transformImportDeclaration(this); }, visit: function(visitor) { visitor.visitImportDeclaration(this); }, get type() { return IMPORT_DECLARATION; } }, {}, ParseTree); var IMPORT_SPECIFIER = ParseTreeType.IMPORT_SPECIFIER; var ImportSpecifier = function ImportSpecifier(location, lhs, rhs) { this.location = location; this.lhs = lhs; this.rhs = rhs; }; ($traceurRuntime.createClass)(ImportSpecifier, { transform: function(transformer) { return transformer.transformImportSpecifier(this); }, visit: function(visitor) { visitor.visitImportSpecifier(this); }, get type() { return IMPORT_SPECIFIER; } }, {}, ParseTree); var IMPORT_SPECIFIER_SET = ParseTreeType.IMPORT_SPECIFIER_SET; var ImportSpecifierSet = function ImportSpecifierSet(location, specifiers) { this.location = location; this.specifiers = specifiers; }; ($traceurRuntime.createClass)(ImportSpecifierSet, { transform: function(transformer) { return transformer.transformImportSpecifierSet(this); }, visit: function(visitor) { visitor.visitImportSpecifierSet(this); }, get type() { return IMPORT_SPECIFIER_SET; } }, {}, ParseTree); var LABELLED_STATEMENT = ParseTreeType.LABELLED_STATEMENT; var LabelledStatement = function LabelledStatement(location, name, statement) { this.location = location; this.name = name; this.statement = statement; }; ($traceurRuntime.createClass)(LabelledStatement, { transform: function(transformer) { return transformer.transformLabelledStatement(this); }, visit: function(visitor) { visitor.visitLabelledStatement(this); }, get type() { return LABELLED_STATEMENT; } }, {}, ParseTree); var LITERAL_EXPRESSION = ParseTreeType.LITERAL_EXPRESSION; var LiteralExpression = function LiteralExpression(location, literalToken) { this.location = location; this.literalToken = literalToken; }; ($traceurRuntime.createClass)(LiteralExpression, { transform: function(transformer) { return transformer.transformLiteralExpression(this); }, visit: function(visitor) { visitor.visitLiteralExpression(this); }, get type() { return LITERAL_EXPRESSION; } }, {}, ParseTree); var LITERAL_PROPERTY_NAME = ParseTreeType.LITERAL_PROPERTY_NAME; var LiteralPropertyName = function LiteralPropertyName(location, literalToken) { this.location = location; this.literalToken = literalToken; }; ($traceurRuntime.createClass)(LiteralPropertyName, { transform: function(transformer) { return transformer.transformLiteralPropertyName(this); }, visit: function(visitor) { visitor.visitLiteralPropertyName(this); }, get type() { return LITERAL_PROPERTY_NAME; } }, {}, ParseTree); var MEMBER_EXPRESSION = ParseTreeType.MEMBER_EXPRESSION; var MemberExpression = function MemberExpression(location, operand, memberName) { this.location = location; this.operand = operand; this.memberName = memberName; }; ($traceurRuntime.createClass)(MemberExpression, { transform: function(transformer) { return transformer.transformMemberExpression(this); }, visit: function(visitor) { visitor.visitMemberExpression(this); }, get type() { return MEMBER_EXPRESSION; } }, {}, ParseTree); var MEMBER_LOOKUP_EXPRESSION = ParseTreeType.MEMBER_LOOKUP_EXPRESSION; var MemberLookupExpression = function MemberLookupExpression(location, operand, memberExpression) { this.location = location; this.operand = operand; this.memberExpression = memberExpression; }; ($traceurRuntime.createClass)(MemberLookupExpression, { transform: function(transformer) { return transformer.transformMemberLookupExpression(this); }, visit: function(visitor) { visitor.visitMemberLookupExpression(this); }, get type() { return MEMBER_LOOKUP_EXPRESSION; } }, {}, ParseTree); var MODULE = ParseTreeType.MODULE; var Module = function Module(location, scriptItemList, moduleName) { this.location = location; this.scriptItemList = scriptItemList; this.moduleName = moduleName; }; ($traceurRuntime.createClass)(Module, { transform: function(transformer) { return transformer.transformModule(this); }, visit: function(visitor) { visitor.visitModule(this); }, get type() { return MODULE; } }, {}, ParseTree); var MODULE_DECLARATION = ParseTreeType.MODULE_DECLARATION; var ModuleDeclaration = function ModuleDeclaration(location, identifier, expression) { this.location = location; this.identifier = identifier; this.expression = expression; }; ($traceurRuntime.createClass)(ModuleDeclaration, { transform: function(transformer) { return transformer.transformModuleDeclaration(this); }, visit: function(visitor) { visitor.visitModuleDeclaration(this); }, get type() { return MODULE_DECLARATION; } }, {}, ParseTree); var MODULE_SPECIFIER = ParseTreeType.MODULE_SPECIFIER; var ModuleSpecifier = function ModuleSpecifier(location, token) { this.location = location; this.token = token; }; ($traceurRuntime.createClass)(ModuleSpecifier, { transform: function(transformer) { return transformer.transformModuleSpecifier(this); }, visit: function(visitor) { visitor.visitModuleSpecifier(this); }, get type() { return MODULE_SPECIFIER; } }, {}, ParseTree); var NAMED_EXPORT = ParseTreeType.NAMED_EXPORT; var NamedExport = function NamedExport(location, moduleSpecifier, specifierSet) { this.location = location; this.moduleSpecifier = moduleSpecifier; this.specifierSet = specifierSet; }; ($traceurRuntime.createClass)(NamedExport, { transform: function(transformer) { return transformer.transformNamedExport(this); }, visit: function(visitor) { visitor.visitNamedExport(this); }, get type() { return NAMED_EXPORT; } }, {}, ParseTree); var NEW_EXPRESSION = ParseTreeType.NEW_EXPRESSION; var NewExpression = function NewExpression(location, operand, args) { this.location = location; this.operand = operand; this.args = args; }; ($traceurRuntime.createClass)(NewExpression, { transform: function(transformer) { return transformer.transformNewExpression(this); }, visit: function(visitor) { visitor.visitNewExpression(this); }, get type() { return NEW_EXPRESSION; } }, {}, ParseTree); var OBJECT_LITERAL_EXPRESSION = ParseTreeType.OBJECT_LITERAL_EXPRESSION; var ObjectLiteralExpression = function ObjectLiteralExpression(location, propertyNameAndValues) { this.location = location; this.propertyNameAndValues = propertyNameAndValues; }; ($traceurRuntime.createClass)(ObjectLiteralExpression, { transform: function(transformer) { return transformer.transformObjectLiteralExpression(this); }, visit: function(visitor) { visitor.visitObjectLiteralExpression(this); }, get type() { return OBJECT_LITERAL_EXPRESSION; } }, {}, ParseTree); var OBJECT_PATTERN = ParseTreeType.OBJECT_PATTERN; var ObjectPattern = function ObjectPattern(location, fields) { this.location = location; this.fields = fields; }; ($traceurRuntime.createClass)(ObjectPattern, { transform: function(transformer) { return transformer.transformObjectPattern(this); }, visit: function(visitor) { visitor.visitObjectPattern(this); }, get type() { return OBJECT_PATTERN; } }, {}, ParseTree); var OBJECT_PATTERN_FIELD = ParseTreeType.OBJECT_PATTERN_FIELD; var ObjectPatternField = function ObjectPatternField(location, name, element) { this.location = location; this.name = name; this.element = element; }; ($traceurRuntime.createClass)(ObjectPatternField, { transform: function(transformer) { return transformer.transformObjectPatternField(this); }, visit: function(visitor) { visitor.visitObjectPatternField(this); }, get type() { return OBJECT_PATTERN_FIELD; } }, {}, ParseTree); var PAREN_EXPRESSION = ParseTreeType.PAREN_EXPRESSION; var ParenExpression = function ParenExpression(location, expression) { this.location = location; this.expression = expression; }; ($traceurRuntime.createClass)(ParenExpression, { transform: function(transformer) { return transformer.transformParenExpression(this); }, visit: function(visitor) { visitor.visitParenExpression(this); }, get type() { return PAREN_EXPRESSION; } }, {}, ParseTree); var POSTFIX_EXPRESSION = ParseTreeType.POSTFIX_EXPRESSION; var PostfixExpression = function PostfixExpression(location, operand, operator) { this.location = location; this.operand = operand; this.operator = operator; }; ($traceurRuntime.createClass)(PostfixExpression, { transform: function(transformer) { return transformer.transformPostfixExpression(this); }, visit: function(visitor) { visitor.visitPostfixExpression(this); }, get type() { return POSTFIX_EXPRESSION; } }, {}, ParseTree); var PREDEFINED_TYPE = ParseTreeType.PREDEFINED_TYPE; var PredefinedType = function PredefinedType(location, typeToken) { this.location = location; this.typeToken = typeToken; }; ($traceurRuntime.createClass)(PredefinedType, { transform: function(transformer) { return transformer.transformPredefinedType(this); }, visit: function(visitor) { visitor.visitPredefinedType(this); }, get type() { return PREDEFINED_TYPE; } }, {}, ParseTree); var SCRIPT = ParseTreeType.SCRIPT; var Script = function Script(location, scriptItemList, moduleName) { this.location = location; this.scriptItemList = scriptItemList; this.moduleName = moduleName; }; ($traceurRuntime.createClass)(Script, { transform: function(transformer) { return transformer.transformScript(this); }, visit: function(visitor) { visitor.visitScript(this); }, get type() { return SCRIPT; } }, {}, ParseTree); var PROPERTY_METHOD_ASSIGNMENT = ParseTreeType.PROPERTY_METHOD_ASSIGNMENT; var PropertyMethodAssignment = function PropertyMethodAssignment(location, isStatic, functionKind, name, parameterList, typeAnnotation, annotations, body) { this.location = location; this.isStatic = isStatic; this.functionKind = functionKind; this.name = name; this.parameterList = parameterList; this.typeAnnotation = typeAnnotation; this.annotations = annotations; this.body = body; }; ($traceurRuntime.createClass)(PropertyMethodAssignment, { transform: function(transformer) { return transformer.transformPropertyMethodAssignment(this); }, visit: function(visitor) { visitor.visitPropertyMethodAssignment(this); }, get type() { return PROPERTY_METHOD_ASSIGNMENT; } }, {}, ParseTree); var PROPERTY_NAME_ASSIGNMENT = ParseTreeType.PROPERTY_NAME_ASSIGNMENT; var PropertyNameAssignment = function PropertyNameAssignment(location, name, value) { this.location = location; this.name = name; this.value = value; }; ($traceurRuntime.createClass)(PropertyNameAssignment, { transform: function(transformer) { return transformer.transformPropertyNameAssignment(this); }, visit: function(visitor) { visitor.visitPropertyNameAssignment(this); }, get type() { return PROPERTY_NAME_ASSIGNMENT; } }, {}, ParseTree); var PROPERTY_NAME_SHORTHAND = ParseTreeType.PROPERTY_NAME_SHORTHAND; var PropertyNameShorthand = function PropertyNameShorthand(location, name) { this.location = location; this.name = name; }; ($traceurRuntime.createClass)(PropertyNameShorthand, { transform: function(transformer) { return transformer.transformPropertyNameShorthand(this); }, visit: function(visitor) { visitor.visitPropertyNameShorthand(this); }, get type() { return PROPERTY_NAME_SHORTHAND; } }, {}, ParseTree); var REST_PARAMETER = ParseTreeType.REST_PARAMETER; var RestParameter = function RestParameter(location, identifier) { this.location = location; this.identifier = identifier; }; ($traceurRuntime.createClass)(RestParameter, { transform: function(transformer) { return transformer.transformRestParameter(this); }, visit: function(visitor) { visitor.visitRestParameter(this); }, get type() { return REST_PARAMETER; } }, {}, ParseTree); var RETURN_STATEMENT = ParseTreeType.RETURN_STATEMENT; var ReturnStatement = function ReturnStatement(location, expression) { this.location = location; this.expression = expression; }; ($traceurRuntime.createClass)(ReturnStatement, { transform: function(transformer) { return transformer.transformReturnStatement(this); }, visit: function(visitor) { visitor.visitReturnStatement(this); }, get type() { return RETURN_STATEMENT; } }, {}, ParseTree); var SET_ACCESSOR = ParseTreeType.SET_ACCESSOR; var SetAccessor = function SetAccessor(location, isStatic, name, parameterList, annotations, body) { this.location = location; this.isStatic = isStatic; this.name = name; this.parameterList = parameterList; this.annotations = annotations; this.body = body; }; ($traceurRuntime.createClass)(SetAccessor, { transform: function(transformer) { return transformer.transformSetAccessor(this); }, visit: function(visitor) { visitor.visitSetAccessor(this); }, get type() { return SET_ACCESSOR; } }, {}, ParseTree); var SPREAD_EXPRESSION = ParseTreeType.SPREAD_EXPRESSION; var SpreadExpression = function SpreadExpression(location, expression) { this.location = location; this.expression = expression; }; ($traceurRuntime.createClass)(SpreadExpression, { transform: function(transformer) { return transformer.transformSpreadExpression(this); }, visit: function(visitor) { visitor.visitSpreadExpression(this); }, get type() { return SPREAD_EXPRESSION; } }, {}, ParseTree); var SPREAD_PATTERN_ELEMENT = ParseTreeType.SPREAD_PATTERN_ELEMENT; var SpreadPatternElement = function SpreadPatternElement(location, lvalue) { this.location = location; this.lvalue = lvalue; }; ($traceurRuntime.createClass)(SpreadPatternElement, { transform: function(transformer) { return transformer.transformSpreadPatternElement(this); }, visit: function(visitor) { visitor.visitSpreadPatternElement(this); }, get type() { return SPREAD_PATTERN_ELEMENT; } }, {}, ParseTree); var SUPER_EXPRESSION = ParseTreeType.SUPER_EXPRESSION; var SuperExpression = function SuperExpression(location) { this.location = location; }; ($traceurRuntime.createClass)(SuperExpression, { transform: function(transformer) { return transformer.transformSuperExpression(this); }, visit: function(visitor) { visitor.visitSuperExpression(this); }, get type() { return SUPER_EXPRESSION; } }, {}, ParseTree); var SWITCH_STATEMENT = ParseTreeType.SWITCH_STATEMENT; var SwitchStatement = function SwitchStatement(location, expression, caseClauses) { this.location = location; this.expression = expression; this.caseClauses = caseClauses; }; ($traceurRuntime.createClass)(SwitchStatement, { transform: function(transformer) { return transformer.transformSwitchStatement(this); }, visit: function(visitor) { visitor.visitSwitchStatement(this); }, get type() { return SWITCH_STATEMENT; } }, {}, ParseTree); var SYNTAX_ERROR_TREE = ParseTreeType.SYNTAX_ERROR_TREE; var SyntaxErrorTree = function SyntaxErrorTree(location, nextToken, message) { this.location = location; this.nextToken = nextToken; this.message = message; }; ($traceurRuntime.createClass)(SyntaxErrorTree, { transform: function(transformer) { return transformer.transformSyntaxErrorTree(this); }, visit: function(visitor) { visitor.visitSyntaxErrorTree(this); }, get type() { return SYNTAX_ERROR_TREE; } }, {}, ParseTree); var TEMPLATE_LITERAL_EXPRESSION = ParseTreeType.TEMPLATE_LITERAL_EXPRESSION; var TemplateLiteralExpression = function TemplateLiteralExpression(location, operand, elements) { this.location = location; this.operand = operand; this.elements = elements; }; ($traceurRuntime.createClass)(TemplateLiteralExpression, { transform: function(transformer) { return transformer.transformTemplateLiteralExpression(this); }, visit: function(visitor) { visitor.visitTemplateLiteralExpression(this); }, get type() { return TEMPLATE_LITERAL_EXPRESSION; } }, {}, ParseTree); var TEMPLATE_LITERAL_PORTION = ParseTreeType.TEMPLATE_LITERAL_PORTION; var TemplateLiteralPortion = function TemplateLiteralPortion(location, value) { this.location = location; this.value = value; }; ($traceurRuntime.createClass)(TemplateLiteralPortion, { transform: function(transformer) { return transformer.transformTemplateLiteralPortion(this); }, visit: function(visitor) { visitor.visitTemplateLiteralPortion(this); }, get type() { return TEMPLATE_LITERAL_PORTION; } }, {}, ParseTree); var TEMPLATE_SUBSTITUTION = ParseTreeType.TEMPLATE_SUBSTITUTION; var TemplateSubstitution = function TemplateSubstitution(location, expression) { this.location = location; this.expression = expression; }; ($traceurRuntime.createClass)(TemplateSubstitution, { transform: function(transformer) { return transformer.transformTemplateSubstitution(this); }, visit: function(visitor) { visitor.visitTemplateSubstitution(this); }, get type() { return TEMPLATE_SUBSTITUTION; } }, {}, ParseTree); var THIS_EXPRESSION = ParseTreeType.THIS_EXPRESSION; var ThisExpression = function ThisExpression(location) { this.location = location; }; ($traceurRuntime.createClass)(ThisExpression, { transform: function(transformer) { return transformer.transformThisExpression(this); }, visit: function(visitor) { visitor.visitThisExpression(this); }, get type() { return THIS_EXPRESSION; } }, {}, ParseTree); var THROW_STATEMENT = ParseTreeType.THROW_STATEMENT; var ThrowStatement = function ThrowStatement(location, value) { this.location = location; this.value = value; }; ($traceurRuntime.createClass)(ThrowStatement, { transform: function(transformer) { return transformer.transformThrowStatement(this); }, visit: function(visitor) { visitor.visitThrowStatement(this); }, get type() { return THROW_STATEMENT; } }, {}, ParseTree); var TRY_STATEMENT = ParseTreeType.TRY_STATEMENT; var TryStatement = function TryStatement(location, body, catchBlock, finallyBlock) { this.location = location; this.body = body; this.catchBlock = catchBlock; this.finallyBlock = finallyBlock; }; ($traceurRuntime.createClass)(TryStatement, { transform: function(transformer) { return transformer.transformTryStatement(this); }, visit: function(visitor) { visitor.visitTryStatement(this); }, get type() { return TRY_STATEMENT; } }, {}, ParseTree); var TYPE_NAME = ParseTreeType.TYPE_NAME; var TypeName = function TypeName(location, moduleName, name) { this.location = location; this.moduleName = moduleName; this.name = name; }; ($traceurRuntime.createClass)(TypeName, { transform: function(transformer) { return transformer.transformTypeName(this); }, visit: function(visitor) { visitor.visitTypeName(this); }, get type() { return TYPE_NAME; } }, {}, ParseTree); var UNARY_EXPRESSION = ParseTreeType.UNARY_EXPRESSION; var UnaryExpression = function UnaryExpression(location, operator, operand) { this.location = location; this.operator = operator; this.operand = operand; }; ($traceurRuntime.createClass)(UnaryExpression, { transform: function(transformer) { return transformer.transformUnaryExpression(this); }, visit: function(visitor) { visitor.visitUnaryExpression(this); }, get type() { return UNARY_EXPRESSION; } }, {}, ParseTree); var VARIABLE_DECLARATION = ParseTreeType.VARIABLE_DECLARATION; var VariableDeclaration = function VariableDeclaration(location, lvalue, typeAnnotation, initializer) { this.location = location; this.lvalue = lvalue; this.typeAnnotation = typeAnnotation; this.initializer = initializer; }; ($traceurRuntime.createClass)(VariableDeclaration, { transform: function(transformer) { return transformer.transformVariableDeclaration(this); }, visit: function(visitor) { visitor.visitVariableDeclaration(this); }, get type() { return VARIABLE_DECLARATION; } }, {}, ParseTree); var VARIABLE_DECLARATION_LIST = ParseTreeType.VARIABLE_DECLARATION_LIST; var VariableDeclarationList = function VariableDeclarationList(location, declarationType, declarations) { this.location = location; this.declarationType = declarationType; this.declarations = declarations; }; ($traceurRuntime.createClass)(VariableDeclarationList, { transform: function(transformer) { return transformer.transformVariableDeclarationList(this); }, visit: function(visitor) { visitor.visitVariableDeclarationList(this); }, get type() { return VARIABLE_DECLARATION_LIST; } }, {}, ParseTree); var VARIABLE_STATEMENT = ParseTreeType.VARIABLE_STATEMENT; var VariableStatement = function VariableStatement(location, declarations) { this.location = location; this.declarations = declarations; }; ($traceurRuntime.createClass)(VariableStatement, { transform: function(transformer) { return transformer.transformVariableStatement(this); }, visit: function(visitor) { visitor.visitVariableStatement(this); }, get type() { return VARIABLE_STATEMENT; } }, {}, ParseTree); var WHILE_STATEMENT = ParseTreeType.WHILE_STATEMENT; var WhileStatement = function WhileStatement(location, condition, body) { this.location = location; this.condition = condition; this.body = body; }; ($traceurRuntime.createClass)(WhileStatement, { transform: function(transformer) { return transformer.transformWhileStatement(this); }, visit: function(visitor) { visitor.visitWhileStatement(this); }, get type() { return WHILE_STATEMENT; } }, {}, ParseTree); var WITH_STATEMENT = ParseTreeType.WITH_STATEMENT; var WithStatement = function WithStatement(location, expression, body) { this.location = location; this.expression = expression; this.body = body; }; ($traceurRuntime.createClass)(WithStatement, { transform: function(transformer) { return transformer.transformWithStatement(this); }, visit: function(visitor) { visitor.visitWithStatement(this); }, get type() { return WITH_STATEMENT; } }, {}, ParseTree); var YIELD_EXPRESSION = ParseTreeType.YIELD_EXPRESSION; var YieldExpression = function YieldExpression(location, expression, isYieldFor) { this.location = location; this.expression = expression; this.isYieldFor = isYieldFor; }; ($traceurRuntime.createClass)(YieldExpression, { transform: function(transformer) { return transformer.transformYieldExpression(this); }, visit: function(visitor) { visitor.visitYieldExpression(this); }, get type() { return YIELD_EXPRESSION; } }, {}, ParseTree); return { get Annotation() { return Annotation; }, get AnonBlock() { return AnonBlock; }, get ArgumentList() { return ArgumentList; }, get ArrayComprehension() { return ArrayComprehension; }, get ArrayLiteralExpression() { return ArrayLiteralExpression; }, get ArrayPattern() { return ArrayPattern; }, get ArrowFunctionExpression() { return ArrowFunctionExpression; }, get AssignmentElement() { return AssignmentElement; }, get AwaitExpression() { return AwaitExpression; }, get BinaryExpression() { return BinaryExpression; }, get BindingElement() { return BindingElement; }, get BindingIdentifier() { return BindingIdentifier; }, get Block() { return Block; }, get BreakStatement() { return BreakStatement; }, get CallExpression() { return CallExpression; }, get CaseClause() { return CaseClause; }, get Catch() { return Catch; }, get ClassDeclaration() { return ClassDeclaration; }, get ClassExpression() { return ClassExpression; }, get CommaExpression() { return CommaExpression; }, get ComprehensionFor() { return ComprehensionFor; }, get ComprehensionIf() { return ComprehensionIf; }, get ComputedPropertyName() { return ComputedPropertyName; }, get ConditionalExpression() { return ConditionalExpression; }, get ContinueStatement() { return ContinueStatement; }, get CoverFormals() { return CoverFormals; }, get CoverInitializedName() { return CoverInitializedName; }, get DebuggerStatement() { return DebuggerStatement; }, get DefaultClause() { return DefaultClause; }, get DoWhileStatement() { return DoWhileStatement; }, get EmptyStatement() { return EmptyStatement; }, get ExportDeclaration() { return ExportDeclaration; }, get ExportDefault() { return ExportDefault; }, get ExportSpecifier() { return ExportSpecifier; }, get ExportSpecifierSet() { return ExportSpecifierSet; }, get ExportStar() { return ExportStar; }, get ExpressionStatement() { return ExpressionStatement; }, get Finally() { return Finally; }, get ForInStatement() { return ForInStatement; }, get ForOfStatement() { return ForOfStatement; }, get ForStatement() { return ForStatement; }, get FormalParameter() { return FormalParameter; }, get FormalParameterList() { return FormalParameterList; }, get FunctionBody() { return FunctionBody; }, get FunctionDeclaration() { return FunctionDeclaration; }, get FunctionExpression() { return FunctionExpression; }, get GeneratorComprehension() { return GeneratorComprehension; }, get GetAccessor() { return GetAccessor; }, get IdentifierExpression() { return IdentifierExpression; }, get IfStatement() { return IfStatement; }, get ImportedBinding() { return ImportedBinding; }, get ImportDeclaration() { return ImportDeclaration; }, get ImportSpecifier() { return ImportSpecifier; }, get ImportSpecifierSet() { return ImportSpecifierSet; }, get LabelledStatement() { return LabelledStatement; }, get LiteralExpression() { return LiteralExpression; }, get LiteralPropertyName() { return LiteralPropertyName; }, get MemberExpression() { return MemberExpression; }, get MemberLookupExpression() { return MemberLookupExpression; }, get Module() { return Module; }, get ModuleDeclaration() { return ModuleDeclaration; }, get ModuleSpecifier() { return ModuleSpecifier; }, get NamedExport() { return NamedExport; }, get NewExpression() { return NewExpression; }, get ObjectLiteralExpression() { return ObjectLiteralExpression; }, get ObjectPattern() { return ObjectPattern; }, get ObjectPatternField() { return ObjectPatternField; }, get ParenExpression() { return ParenExpression; }, get PostfixExpression() { return PostfixExpression; }, get PredefinedType() { return PredefinedType; }, get Script() { return Script; }, get PropertyMethodAssignment() { return PropertyMethodAssignment; }, get PropertyNameAssignment() { return PropertyNameAssignment; }, get PropertyNameShorthand() { return PropertyNameShorthand; }, get RestParameter() { return RestParameter; }, get ReturnStatement() { return ReturnStatement; }, get SetAccessor() { return SetAccessor; }, get SpreadExpression() { return SpreadExpression; }, get SpreadPatternElement() { return SpreadPatternElement; }, get SuperExpression() { return SuperExpression; }, get SwitchStatement() { return SwitchStatement; }, get SyntaxErrorTree() { return SyntaxErrorTree; }, get TemplateLiteralExpression() { return TemplateLiteralExpression; }, get TemplateLiteralPortion() { return TemplateLiteralPortion; }, get TemplateSubstitution() { return TemplateSubstitution; }, get ThisExpression() { return ThisExpression; }, get ThrowStatement() { return ThrowStatement; }, get TryStatement() { return TryStatement; }, get TypeName() { return TypeName; }, get UnaryExpression() { return UnaryExpression; }, get VariableDeclaration() { return VariableDeclaration; }, get VariableDeclarationList() { return VariableDeclarationList; }, get VariableStatement() { return VariableStatement; }, get WhileStatement() { return WhileStatement; }, get WithStatement() { return WithStatement; }, get YieldExpression() { return YieldExpression; } }; }); System.register("traceur@0.0.52/src/semantics/getVariableName", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/semantics/getVariableName"; var $__57 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), BindingIdentifier = $__57.BindingIdentifier, IdentifierExpression = $__57.IdentifierExpression; var IdentifierToken = System.get("traceur@0.0.52/src/syntax/IdentifierToken").IdentifierToken; function getVariableName(name) { if (name instanceof IdentifierExpression) { name = name.identifierToken; } else if (name instanceof BindingIdentifier) { name = name.identifierToken; } if (name instanceof IdentifierToken) { name = name.value; } return name; } return {get getVariableName() { return getVariableName; }}; }); System.register("traceur@0.0.52/src/semantics/util", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/semantics/util"; var $__59 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), IDENTIFIER_EXPRESSION = $__59.IDENTIFIER_EXPRESSION, LITERAL_EXPRESSION = $__59.LITERAL_EXPRESSION, PAREN_EXPRESSION = $__59.PAREN_EXPRESSION, UNARY_EXPRESSION = $__59.UNARY_EXPRESSION; var UNDEFINED = System.get("traceur@0.0.52/src/syntax/PredefinedName").UNDEFINED; var VOID = System.get("traceur@0.0.52/src/syntax/TokenType").VOID; function hasUseStrict(list) { for (var i = 0; i < list.length; i++) { if (!list[i].isDirectivePrologue()) return false; if (list[i].isUseStrictDirective()) return true; } return false; } function isUndefined(tree) { if (tree.type === PAREN_EXPRESSION) return isUndefined(tree.expression); return tree.type === IDENTIFIER_EXPRESSION && tree.identifierToken.value === UNDEFINED; } function isVoidExpression(tree) { if (tree.type === PAREN_EXPRESSION) return isVoidExpression(tree.expression); return tree.type === UNARY_EXPRESSION && tree.operator.type === VOID && isLiteralExpression(tree.operand); } function isLiteralExpression(tree) { if (tree.type === PAREN_EXPRESSION) return isLiteralExpression(tree.expression); return tree.type === LITERAL_EXPRESSION; } return { get hasUseStrict() { return hasUseStrict; }, get isUndefined() { return isUndefined; }, get isVoidExpression() { return isVoidExpression; }, get isLiteralExpression() { return isLiteralExpression; } }; }); System.register("traceur@0.0.52/src/semantics/isTreeStrict", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/semantics/isTreeStrict"; var $__62 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), ARROW_FUNCTION_EXPRESSION = $__62.ARROW_FUNCTION_EXPRESSION, CLASS_DECLARATION = $__62.CLASS_DECLARATION, CLASS_EXPRESSION = $__62.CLASS_EXPRESSION, FUNCTION_BODY = $__62.FUNCTION_BODY, FUNCTION_DECLARATION = $__62.FUNCTION_DECLARATION, FUNCTION_EXPRESSION = $__62.FUNCTION_EXPRESSION, GET_ACCESSOR = $__62.GET_ACCESSOR, MODULE = $__62.MODULE, PROPERTY_METHOD_ASSIGNMENT = $__62.PROPERTY_METHOD_ASSIGNMENT, SCRIPT = $__62.SCRIPT, SET_ACCESSOR = $__62.SET_ACCESSOR; var hasUseStrict = System.get("traceur@0.0.52/src/semantics/util").hasUseStrict; function isTreeStrict(tree) { switch (tree.type) { case CLASS_DECLARATION: case CLASS_EXPRESSION: case MODULE: return true; case FUNCTION_BODY: return hasUseStrict(tree.statements); case FUNCTION_EXPRESSION: case FUNCTION_DECLARATION: case PROPERTY_METHOD_ASSIGNMENT: return isTreeStrict(tree.body); case ARROW_FUNCTION_EXPRESSION: if (tree.body.type === FUNCTION_BODY) { return isTreeStrict(tree.body); } return false; case GET_ACCESSOR: case SET_ACCESSOR: return isTreeStrict(tree.body); case SCRIPT: return hasUseStrict(tree.scriptItemList); default: return false; } } return {get isTreeStrict() { return isTreeStrict; }}; }); System.register("traceur@0.0.52/src/semantics/Scope", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/semantics/Scope"; var $__64 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), BLOCK = $__64.BLOCK, CATCH = $__64.CATCH; var VAR = System.get("traceur@0.0.52/src/syntax/TokenType").VAR; var getVariableName = System.get("traceur@0.0.52/src/semantics/getVariableName").getVariableName; var isTreeStrict = System.get("traceur@0.0.52/src/semantics/isTreeStrict").isTreeStrict; function reportDuplicateVar(reporter, tree, name) { reporter.reportError(tree.location && tree.location.start, ("Duplicate declaration, " + name)); } var Scope = function Scope(parent, tree) { this.parent = parent; this.tree = tree; this.variableDeclarations = Object.create(null); this.lexicalDeclarations = Object.create(null); this.strictMode = parent && parent.strictMode || isTreeStrict(tree); }; ($traceurRuntime.createClass)(Scope, { addBinding: function(tree, type, reporter) { if (type === VAR) { this.addVar(tree, reporter); } else { this.addDeclaration(tree, type, reporter); } }, addVar: function(tree, reporter) { var name = getVariableName(tree); if (this.lexicalDeclarations[name]) { reportDuplicateVar(reporter, tree, name); return; } this.variableDeclarations[name] = { type: VAR, tree: tree }; if (!this.isVarScope && this.parent) { this.parent.addVar(tree, reporter); } }, addDeclaration: function(tree, type, reporter) { var name = getVariableName(tree); if (this.lexicalDeclarations[name] || this.variableDeclarations[name]) { reportDuplicateVar(reporter, tree, name); return; } this.lexicalDeclarations[name] = { type: type, tree: tree }; }, get isVarScope() { switch (this.tree.type) { case BLOCK: case CATCH: return false; } return true; }, getVarScope: function() { if (this.isVarScope) { return this; } if (this.parent) { return this.parent.getVarScope(); } return null; }, getBinding: function(tree) { var name = getVariableName(tree); return this.getBinding_(name); }, getBinding_: function(name) { var b = this.lexicalDeclarations[name]; if (b) { return b; } b = this.variableDeclarations[name]; if (b && this.isVarScope) { return b; } if (this.parent) { return this.parent.getBinding_(name); } return null; }, getVariableBindingNames: function() { var names = Object.create(null); for (var name in this.variableDeclarations) { names[name] = true; } return names; }, getLexicalBindingNames: function() { var names = Object.create(null); for (var name in this.lexicalDeclarations) { names[name] = true; } return names; } }, {}); return {get Scope() { return Scope; }}; }); System.register("traceur@0.0.52/src/semantics/ScopeVisitor", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/semantics/ScopeVisitor"; var Map = System.get("traceur@0.0.52/src/runtime/polyfills/Map").Map; var ParseTreeVisitor = System.get("traceur@0.0.52/src/syntax/ParseTreeVisitor").ParseTreeVisitor; var VAR = System.get("traceur@0.0.52/src/syntax/TokenType").VAR; var Scope = System.get("traceur@0.0.52/src/semantics/Scope").Scope; var $__73 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), COMPREHENSION_FOR = $__73.COMPREHENSION_FOR, VARIABLE_DECLARATION_LIST = $__73.VARIABLE_DECLARATION_LIST; var ScopeVisitor = function ScopeVisitor() { this.map_ = new Map(); this.scope = null; this.withBlockCounter_ = 0; }; var $ScopeVisitor = ScopeVisitor; ($traceurRuntime.createClass)(ScopeVisitor, { getScopeForTree: function(tree) { return this.map_.get(tree); }, pushScope: function(tree) { var scope = new Scope(this.scope, tree); this.map_.set(tree, scope); return this.scope = scope; }, popScope: function(scope) { if (this.scope !== scope) { throw new Error('ScopeVisitor scope mismatch'); } this.scope = scope.parent; }, visitScript: function(tree) { var scope = this.pushScope(tree); $traceurRuntime.superCall(this, $ScopeVisitor.prototype, "visitScript", [tree]); this.popScope(scope); }, visitModule: function(tree) { var scope = this.pushScope(tree); $traceurRuntime.superCall(this, $ScopeVisitor.prototype, "visitModule", [tree]); this.popScope(scope); }, visitBlock: function(tree) { var scope = this.pushScope(tree); $traceurRuntime.superCall(this, $ScopeVisitor.prototype, "visitBlock", [tree]); this.popScope(scope); }, visitCatch: function(tree) { var scope = this.pushScope(tree); this.visitAny(tree.binding); this.visitList(tree.catchBody.statements); this.popScope(scope); }, visitFunctionBodyForScope: function(tree) { var parameterList = arguments[1] !== (void 0) ? arguments[1] : tree.parameterList; var scope = this.pushScope(tree); this.visitAny(parameterList); this.visitAny(tree.body); this.popScope(scope); }, visitFunctionExpression: function(tree) { this.visitFunctionBodyForScope(tree); }, visitFunctionDeclaration: function(tree) { this.visitAny(tree.name); this.visitFunctionBodyForScope(tree); }, visitArrowFunctionExpression: function(tree) { this.visitFunctionBodyForScope(tree); }, visitGetAccessor: function(tree) { this.visitFunctionBodyForScope(tree, null); }, visitSetAccessor: function(tree) { this.visitFunctionBodyForScope(tree); }, visitPropertyMethodAssignment: function(tree) { this.visitFunctionBodyForScope(tree); }, visitClassDeclaration: function(tree) { this.visitAny(tree.superClass); var scope = this.pushScope(tree); this.visitAny(tree.name); this.visitList(tree.elements); this.popScope(scope); }, visitClassExpression: function(tree) { this.visitAny(tree.superClass); var scope; if (tree.name) { scope = this.pushScope(tree); this.visitAny(tree.name); } this.visitList(tree.elements); if (tree.name) { this.popScope(scope); } }, visitWithStatement: function(tree) { this.visitAny(tree.expression); this.withBlockCounter_++; this.visitAny(tree.body); this.withBlockCounter_--; }, get inWithBlock() { return this.withBlockCounter_ > 0; }, visitLoop_: function(tree, func) { if (tree.initializer.type !== VARIABLE_DECLARATION_LIST || tree.initializer.declarationType === VAR) { func(); return; } var scope = this.pushScope(tree); func(); this.popScope(scope); }, visitForInStatement: function(tree) { var $__74 = this; this.visitLoop_(tree, (function() { return $traceurRuntime.superCall($__74, $ScopeVisitor.prototype, "visitForInStatement", [tree]); })); }, visitForOfStatement: function(tree) { var $__74 = this; this.visitLoop_(tree, (function() { return $traceurRuntime.superCall($__74, $ScopeVisitor.prototype, "visitForOfStatement", [tree]); })); }, visitForStatement: function(tree) { var $__74 = this; if (!tree.initializer) { $traceurRuntime.superCall(this, $ScopeVisitor.prototype, "visitForStatement", [tree]); } else { this.visitLoop_(tree, (function() { return $traceurRuntime.superCall($__74, $ScopeVisitor.prototype, "visitForStatement", [tree]); })); } }, visitComprehension_: function(tree) { var scopes = []; for (var i = 0; i < tree.comprehensionList.length; i++) { var scope = null; if (tree.comprehensionList[i].type === COMPREHENSION_FOR) { scope = this.pushScope(tree.comprehensionList[i]); } scopes.push(scope); this.visitAny(tree.comprehensionList[i]); } this.visitAny(tree.expression); for (var i = scopes.length - 1; i >= 0; i--) { if (scopes[i]) { this.popScope(scopes[i]); } } }, visitArrayComprehension: function(tree) { this.visitComprehension_(tree); }, visitGeneratorComprehension: function(tree) { this.visitComprehension_(tree); } }, {}, ParseTreeVisitor); return {get ScopeVisitor() { return ScopeVisitor; }}; }); System.register("traceur@0.0.52/src/semantics/ScopeChainBuilder", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/semantics/ScopeChainBuilder"; var $__75 = System.get("traceur@0.0.52/src/syntax/TokenType"), CONST = $__75.CONST, LET = $__75.LET, VAR = $__75.VAR; var ScopeVisitor = System.get("traceur@0.0.52/src/semantics/ScopeVisitor").ScopeVisitor; var ScopeChainBuilder = function ScopeChainBuilder(reporter) { $traceurRuntime.superCall(this, $ScopeChainBuilder.prototype, "constructor", []); this.reporter_ = reporter; this.declarationType_ = null; }; var $ScopeChainBuilder = ScopeChainBuilder; ($traceurRuntime.createClass)(ScopeChainBuilder, { visitCatch: function(tree) { var scope = this.pushScope(tree); this.declarationType_ = LET; this.visitAny(tree.binding); this.visitList(tree.catchBody.statements); this.popScope(scope); }, visitImportedBinding: function(tree) { this.declarationType_ = CONST; $traceurRuntime.superCall(this, $ScopeChainBuilder.prototype, "visitImportedBinding", [tree]); }, visitImportSpecifier: function(tree) { this.declarationType_ = CONST; if (tree.rhs) { this.declareVariable(tree.rhs); } else { this.declareVariable(tree.lhs); } }, visitModuleDeclaration: function(tree) { this.declarationType_ = CONST; this.declareVariable(tree.identifier); }, visitVariableDeclarationList: function(tree) { this.declarationType_ = tree.declarationType; $traceurRuntime.superCall(this, $ScopeChainBuilder.prototype, "visitVariableDeclarationList", [tree]); }, visitBindingIdentifier: function(tree) { this.declareVariable(tree); }, visitFunctionExpression: function(tree) { var scope = this.pushScope(tree); if (tree.name) { this.declarationType_ = CONST; this.visitAny(tree.name); } this.visitAny(tree.parameterList); this.visitAny(tree.body); this.popScope(scope); }, visitFormalParameter: function(tree) { this.declarationType_ = VAR; $traceurRuntime.superCall(this, $ScopeChainBuilder.prototype, "visitFormalParameter", [tree]); }, visitFunctionDeclaration: function(tree) { if (this.scope) { if (this.scope.isVarScope) { this.declarationType_ = VAR; this.visitAny(tree.name); } else { if (!this.scope.strictMode) { var varScope = this.scope.getVarScope(); if (varScope) { varScope.addVar(tree.name, this.reporter_); } } this.declarationType_ = LET; this.visitAny(tree.name); } } this.visitFunctionBodyForScope(tree, tree.parameterList, tree.body); }, visitClassDeclaration: function(tree) { this.visitAny(tree.superClass); this.declarationType_ = LET; this.visitAny(tree.name); var scope = this.pushScope(tree); this.declarationType_ = CONST; this.visitAny(tree.name); this.visitList(tree.elements); this.popScope(scope); }, visitClassExpression: function(tree) { this.visitAny(tree.superClass); var scope; if (tree.name) { scope = this.pushScope(tree); this.declarationType_ = CONST; this.visitAny(tree.name); } this.visitList(tree.elements); if (tree.name) { this.popScope(scope); } }, visitComprehensionFor: function(tree) { this.declarationType_ = LET; $traceurRuntime.superCall(this, $ScopeChainBuilder.prototype, "visitComprehensionFor", [tree]); }, declareVariable: function(tree) { this.scope.addBinding(tree, this.declarationType_, this.reporter_); } }, {}, ScopeVisitor); return {get ScopeChainBuilder() { return ScopeChainBuilder; }}; }); System.register("traceur@0.0.52/src/semantics/ConstChecker", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/semantics/ConstChecker"; var IDENTIFIER_EXPRESSION = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType").IDENTIFIER_EXPRESSION; var $__79 = System.get("traceur@0.0.52/src/syntax/TokenType"), CONST = $__79.CONST, MINUS_MINUS = $__79.MINUS_MINUS, PLUS_PLUS = $__79.PLUS_PLUS; var ScopeVisitor = System.get("traceur@0.0.52/src/semantics/ScopeVisitor").ScopeVisitor; var ScopeChainBuilder = System.get("traceur@0.0.52/src/semantics/ScopeChainBuilder").ScopeChainBuilder; var getVariableName = System.get("traceur@0.0.52/src/semantics/getVariableName").getVariableName; var ConstChecker = function ConstChecker(scopeBuilder, reporter) { $traceurRuntime.superCall(this, $ConstChecker.prototype, "constructor", []); this.scopeBuilder_ = scopeBuilder; this.reporter_ = reporter; }; var $ConstChecker = ConstChecker; ($traceurRuntime.createClass)(ConstChecker, { pushScope: function(tree) { return this.scope = this.scopeBuilder_.getScopeForTree(tree); }, visitUnaryExpression: function(tree) { if (tree.operand.type === IDENTIFIER_EXPRESSION && (tree.operator.type === PLUS_PLUS || tree.operator.type === MINUS_MINUS)) { this.validateMutation_(tree.operand); } $traceurRuntime.superCall(this, $ConstChecker.prototype, "visitUnaryExpression", [tree]); }, visitPostfixExpression: function(tree) { if (tree.operand.type === IDENTIFIER_EXPRESSION) { this.validateMutation_(tree.operand); } $traceurRuntime.superCall(this, $ConstChecker.prototype, "visitPostfixExpression", [tree]); }, visitBinaryExpression: function(tree) { if (tree.left.type === IDENTIFIER_EXPRESSION && tree.operator.isAssignmentOperator()) { this.validateMutation_(tree.left); } $traceurRuntime.superCall(this, $ConstChecker.prototype, "visitBinaryExpression", [tree]); }, validateMutation_: function(identifierExpression) { if (this.inWithBlock) { return; } var binding = this.scope.getBinding(identifierExpression); if (binding === null) { return; } var $__84 = $traceurRuntime.assertObject(binding), type = $__84.type, tree = $__84.tree; if (type === CONST) { this.reportError_(identifierExpression.location, (getVariableName(tree) + " is read-only")); } }, reportError_: function(location, message) { this.reporter_.reportError(location.start, message); } }, {}, ScopeVisitor); function validate(tree, reporter) { var builder = new ScopeChainBuilder(reporter); builder.visitAny(tree); var checker = new ConstChecker(builder, reporter); checker.visitAny(tree); } return { get ConstChecker() { return ConstChecker; }, get validate() { return validate; } }; }); System.register("traceur@0.0.52/src/semantics/FreeVariableChecker", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/semantics/FreeVariableChecker"; var $__85 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), FUNCTION_DECLARATION = $__85.FUNCTION_DECLARATION, FUNCTION_EXPRESSION = $__85.FUNCTION_EXPRESSION, GET_ACCESSOR = $__85.GET_ACCESSOR, IDENTIFIER_EXPRESSION = $__85.IDENTIFIER_EXPRESSION, MODULE = $__85.MODULE, PROPERTY_METHOD_ASSIGNMENT = $__85.PROPERTY_METHOD_ASSIGNMENT, SET_ACCESSOR = $__85.SET_ACCESSOR; var TYPEOF = System.get("traceur@0.0.52/src/syntax/TokenType").TYPEOF; var ScopeVisitor = System.get("traceur@0.0.52/src/semantics/ScopeVisitor").ScopeVisitor; var ScopeChainBuilder = System.get("traceur@0.0.52/src/semantics/ScopeChainBuilder").ScopeChainBuilder; var getVariableName = System.get("traceur@0.0.52/src/semantics/getVariableName").getVariableName; function hasArgumentsInScope(scope) { for (; scope; scope = scope.parent) { switch (scope.tree.type) { case FUNCTION_DECLARATION: case FUNCTION_EXPRESSION: case GET_ACCESSOR: case PROPERTY_METHOD_ASSIGNMENT: case SET_ACCESSOR: return true; } } return false; } function inModuleScope(scope) { for (; scope; scope = scope.parent) { if (scope.tree.type === MODULE) { return true; } } return false; } var FreeVariableChecker = function FreeVariableChecker(scopeBuilder, reporter) { var global = arguments[2] !== (void 0) ? arguments[2] : Object.create(null); $traceurRuntime.superCall(this, $FreeVariableChecker.prototype, "constructor", []); this.scopeBuilder_ = scopeBuilder; this.reporter_ = reporter; this.global_ = global; }; var $FreeVariableChecker = FreeVariableChecker; ($traceurRuntime.createClass)(FreeVariableChecker, { pushScope: function(tree) { return this.scope = this.scopeBuilder_.getScopeForTree(tree); }, visitUnaryExpression: function(tree) { if (tree.operator.type === TYPEOF && tree.operand.type === IDENTIFIER_EXPRESSION) { var scope = this.scope; var binding = scope.getBinding(tree.operand); if (!binding) { scope.addVar(tree.operand, this.reporter_); } } else { $traceurRuntime.superCall(this, $FreeVariableChecker.prototype, "visitUnaryExpression", [tree]); } }, visitIdentifierExpression: function(tree) { if (this.inWithBlock) { return; } var scope = this.scope; var binding = scope.getBinding(tree); if (binding) { return; } var name = getVariableName(tree); if (name === 'arguments' && hasArgumentsInScope(scope)) { return; } if (name === '__moduleName' && inModuleScope(scope)) { return; } if (!(name in this.global_)) { this.reporter_.reportError(tree.location.start, (name + " is not defined")); } } }, {}, ScopeVisitor); function validate(tree, reporter) { var global = arguments[2] !== (void 0) ? arguments[2] : Reflect.global; var builder = new ScopeChainBuilder(reporter); builder.visitAny(tree); var checker = new FreeVariableChecker(builder, reporter, global); checker.visitAny(tree); } return {get validate() { return validate; }}; }); System.register("traceur@0.0.52/src/util/assert", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/util/assert"; var options = System.get("traceur@0.0.52/src/Options").options; function assert(b) { if (!b && options.debug) throw Error('Assertion failed'); } return {get assert() { return assert; }}; }); System.register("traceur@0.0.52/src/syntax/LiteralToken", [], function() { "use strict"; var $__95; var __moduleName = "traceur@0.0.52/src/syntax/LiteralToken"; var Token = System.get("traceur@0.0.52/src/syntax/Token").Token; var $__93 = System.get("traceur@0.0.52/src/syntax/TokenType"), NULL = $__93.NULL, NUMBER = $__93.NUMBER, STRING = $__93.STRING; var StringParser = function StringParser(value) { this.value = value; this.index = 0; }; ($traceurRuntime.createClass)(StringParser, ($__95 = {}, Object.defineProperty($__95, Symbol.iterator, { value: function() { return this; }, configurable: true, enumerable: true, writable: true }), Object.defineProperty($__95, "next", { value: function() { if (++this.index >= this.value.length - 1) return { value: undefined, done: true }; return { value: this.value[this.index], done: false }; }, configurable: true, enumerable: true, writable: true }), Object.defineProperty($__95, "parse", { value: function() { if (this.value.indexOf('\\') === -1) return this.value.slice(1, -1); var result = ''; for (var $__96 = this[Symbol.iterator](), $__97; !($__97 = $__96.next()).done; ) { var ch = $__97.value; { result += ch === '\\' ? this.parseEscapeSequence() : ch; } } return result; }, configurable: true, enumerable: true, writable: true }), Object.defineProperty($__95, "parseEscapeSequence", { value: function() { var ch = this.next().value; switch (ch) { case '\n': case '\r': case '\u2028': case '\u2029': return ''; case '0': return '\0'; case 'b': return '\b'; case 'f': return '\f'; case 'n': return '\n'; case 'r': return '\r'; case 't': return '\t'; case 'v': return '\v'; case 'x': return String.fromCharCode(parseInt(this.next().value + this.next().value, 16)); case 'u': return String.fromCharCode(parseInt(this.next().value + this.next().value + this.next().value + this.next().value, 16)); default: if (Number(ch) < 8) throw new Error('Octal literals are not supported'); return ch; } }, configurable: true, enumerable: true, writable: true }), $__95), {}); var LiteralToken = function LiteralToken(type, value, location) { this.type = type; this.location = location; this.value = value; }; ($traceurRuntime.createClass)(LiteralToken, { toString: function() { return this.value; }, get processedValue() { switch (this.type) { case NULL: return null; case NUMBER: var value = this.value; if (value.charCodeAt(0) === 48) { switch (value.charCodeAt(1)) { case 66: case 98: return parseInt(this.value.slice(2), 2); case 79: case 111: return parseInt(this.value.slice(2), 8); } } return Number(this.value); case STRING: var parser = new StringParser(this.value); return parser.parse(); default: throw new Error('Not implemented'); } } }, {}, Token); return {get LiteralToken() { return LiteralToken; }}; }); System.register("traceur@0.0.52/src/codegeneration/ParseTreeFactory", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/ParseTreeFactory"; var IdentifierToken = System.get("traceur@0.0.52/src/syntax/IdentifierToken").IdentifierToken; var LiteralToken = System.get("traceur@0.0.52/src/syntax/LiteralToken").LiteralToken; var $__100 = System.get("traceur@0.0.52/src/syntax/trees/ParseTree"), ParseTree = $__100.ParseTree, ParseTreeType = $__100.ParseTreeType; var $__101 = System.get("traceur@0.0.52/src/syntax/PredefinedName"), CALL = $__101.CALL, CREATE = $__101.CREATE, DEFINE_PROPERTY = $__101.DEFINE_PROPERTY, FREEZE = $__101.FREEZE, OBJECT = $__101.OBJECT, UNDEFINED = $__101.UNDEFINED; var Token = System.get("traceur@0.0.52/src/syntax/Token").Token; var $__103 = System.get("traceur@0.0.52/src/syntax/TokenType"), EQUAL = $__103.EQUAL, FALSE = $__103.FALSE, NULL = $__103.NULL, NUMBER = $__103.NUMBER, STRING = $__103.STRING, TRUE = $__103.TRUE, VOID = $__103.VOID; var assert = System.get("traceur@0.0.52/src/util/assert").assert; var $__105 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), ArgumentList = $__105.ArgumentList, ArrayLiteralExpression = $__105.ArrayLiteralExpression, BinaryExpression = $__105.BinaryExpression, BindingIdentifier = $__105.BindingIdentifier, Block = $__105.Block, BreakStatement = $__105.BreakStatement, CallExpression = $__105.CallExpression, CaseClause = $__105.CaseClause, Catch = $__105.Catch, ClassDeclaration = $__105.ClassDeclaration, CommaExpression = $__105.CommaExpression, ConditionalExpression = $__105.ConditionalExpression, ContinueStatement = $__105.ContinueStatement, DefaultClause = $__105.DefaultClause, DoWhileStatement = $__105.DoWhileStatement, EmptyStatement = $__105.EmptyStatement, ExpressionStatement = $__105.ExpressionStatement, Finally = $__105.Finally, ForInStatement = $__105.ForInStatement, ForOfStatement = $__105.ForOfStatement, ForStatement = $__105.ForStatement, FormalParameterList = $__105.FormalParameterList, FunctionBody = $__105.FunctionBody, FunctionExpression = $__105.FunctionExpression, IdentifierExpression = $__105.IdentifierExpression, IfStatement = $__105.IfStatement, LiteralExpression = $__105.LiteralExpression, LiteralPropertyName = $__105.LiteralPropertyName, MemberExpression = $__105.MemberExpression, MemberLookupExpression = $__105.MemberLookupExpression, NewExpression = $__105.NewExpression, ObjectLiteralExpression = $__105.ObjectLiteralExpression, ParenExpression = $__105.ParenExpression, PostfixExpression = $__105.PostfixExpression, Script = $__105.Script, PropertyNameAssignment = $__105.PropertyNameAssignment, RestParameter = $__105.RestParameter, ReturnStatement = $__105.ReturnStatement, SpreadExpression = $__105.SpreadExpression, SwitchStatement = $__105.SwitchStatement, ThisExpression = $__105.ThisExpression, ThrowStatement = $__105.ThrowStatement, TryStatement = $__105.TryStatement, UnaryExpression = $__105.UnaryExpression, VariableDeclaration = $__105.VariableDeclaration, VariableDeclarationList = $__105.VariableDeclarationList, VariableStatement = $__105.VariableStatement, WhileStatement = $__105.WhileStatement, WithStatement = $__105.WithStatement, YieldExpression = $__105.YieldExpression; var slice = Array.prototype.slice.call.bind(Array.prototype.slice); var map = Array.prototype.map.call.bind(Array.prototype.map); function createOperatorToken(operator) { return new Token(operator, null); } function createIdentifierToken(identifier) { return new IdentifierToken(null, identifier); } function createStringLiteralToken(value) { return new LiteralToken(STRING, JSON.stringify(value), null); } function createBooleanLiteralToken(value) { return new Token(value ? TRUE : FALSE, null); } function createNullLiteralToken() { return new LiteralToken(NULL, 'null', null); } function createNumberLiteralToken(value) { return new LiteralToken(NUMBER, String(value), null); } function createEmptyParameterList() { return new FormalParameterList(null, []); } function createArgumentList(list) { return new ArgumentList(null, list); } function createEmptyArgumentList() { return createArgumentList([]); } function createArrayLiteralExpression(list) { return new ArrayLiteralExpression(null, list); } function createEmptyArrayLiteralExpression() { return createArrayLiteralExpression([]); } function createAssignmentExpression(lhs, rhs) { return new BinaryExpression(null, lhs, createOperatorToken(EQUAL), rhs); } function createBinaryExpression(left, operator, right) { return new BinaryExpression(null, left, operator, right); } function createBindingIdentifier(identifier) { if (typeof identifier === 'string') identifier = createIdentifierToken(identifier); else if (identifier.type === ParseTreeType.BINDING_IDENTIFIER) return identifier; else if (identifier.type === ParseTreeType.IDENTIFIER_EXPRESSION) return new BindingIdentifier(identifier.location, identifier.identifierToken); return new BindingIdentifier(null, identifier); } function createEmptyStatement() { return new EmptyStatement(null); } function createEmptyBlock() { return createBlock([]); } function createBlock(statements) { return new Block(null, statements); } function createFunctionBody(statements) { return new FunctionBody(null, statements); } function createScopedExpression(body, scope) { assert(body.type === 'FUNCTION_BODY'); return createCallCall(createParenExpression(createFunctionExpression(createEmptyParameterList(), body)), scope); } function createImmediatelyInvokedFunctionExpression(body) { assert(body.type === 'FUNCTION_BODY'); return createCallExpression(createParenExpression(createFunctionExpression(createEmptyParameterList(), body))); } function createCallExpression(operand) { var args = arguments[1] !== (void 0) ? arguments[1] : createEmptyArgumentList(); return new CallExpression(null, operand, args); } function createBreakStatement() { var name = arguments[0] !== (void 0) ? arguments[0] : null; return new BreakStatement(null, name); } function createCallCall(func, thisExpression) { return createCallExpression(createMemberExpression(func, CALL), createArgumentList([thisExpression])); } function createCaseClause(expression, statements) { return new CaseClause(null, expression, statements); } function createCatch(identifier, catchBody) { identifier = createBindingIdentifier(identifier); return new Catch(null, identifier, catchBody); } function createClassDeclaration(name, superClass, elements) { return new ClassDeclaration(null, name, superClass, elements, []); } function createCommaExpression(expressions) { return new CommaExpression(null, expressions); } function createConditionalExpression(condition, left, right) { return new ConditionalExpression(null, condition, left, right); } function createContinueStatement() { var name = arguments[0] !== (void 0) ? arguments[0] : null; return new ContinueStatement(null, name); } function createDefaultClause(statements) { return new DefaultClause(null, statements); } function createDoWhileStatement(body, condition) { return new DoWhileStatement(null, body, condition); } function createAssignmentStatement(lhs, rhs) { return createExpressionStatement(createAssignmentExpression(lhs, rhs)); } function createCallStatement(operand) { var args = arguments[1]; return createExpressionStatement(createCallExpression(operand, args)); } function createExpressionStatement(expression) { return new ExpressionStatement(null, expression); } function createFinally(block) { return new Finally(null, block); } function createForOfStatement(initializer, collection, body) { return new ForOfStatement(null, initializer, collection, body); } function createForInStatement(initializer, collection, body) { return new ForInStatement(null, initializer, collection, body); } function createForStatement(variables, condition, increment, body) { return new ForStatement(null, variables, condition, increment, body); } function createFunctionExpression(parameterList, body) { assert(body.type === 'FUNCTION_BODY'); return new FunctionExpression(null, null, false, parameterList, null, [], body); } function createIdentifierExpression(identifier) { if (typeof identifier == 'string') identifier = createIdentifierToken(identifier); else if (identifier instanceof BindingIdentifier) identifier = identifier.identifierToken; return new IdentifierExpression(null, identifier); } function createUndefinedExpression() { return createIdentifierExpression(UNDEFINED); } function createIfStatement(condition, ifClause) { var elseClause = arguments[2] !== (void 0) ? arguments[2] : null; return new IfStatement(null, condition, ifClause, elseClause); } function createStringLiteral(value) { return new LiteralExpression(null, createStringLiteralToken(value)); } function createBooleanLiteral(value) { return new LiteralExpression(null, createBooleanLiteralToken(value)); } function createTrueLiteral() { return createBooleanLiteral(true); } function createFalseLiteral() { return createBooleanLiteral(false); } function createNullLiteral() { return new LiteralExpression(null, createNullLiteralToken()); } function createNumberLiteral(value) { return new LiteralExpression(null, createNumberLiteralToken(value)); } function createMemberExpression(operand, memberName, memberNames) { if (typeof operand == 'string' || operand instanceof IdentifierToken) operand = createIdentifierExpression(operand); if (typeof memberName == 'string') memberName = createIdentifierToken(memberName); if (memberName instanceof LiteralToken) memberName = new LiteralExpression(null, memberName); var tree = memberName instanceof LiteralExpression ? new MemberLookupExpression(null, operand, memberName) : new MemberExpression(null, operand, memberName); for (var i = 2; i < arguments.length; i++) { tree = createMemberExpression(tree, arguments[i]); } return tree; } function createMemberLookupExpression(operand, memberExpression) { return new MemberLookupExpression(null, operand, memberExpression); } function createThisExpression() { return new ThisExpression(null); } function createNewExpression(operand, args) { return new NewExpression(null, operand, args); } function createObjectFreeze(value) { return createCallExpression(createMemberExpression(OBJECT, FREEZE), createArgumentList([value])); } function createObjectCreate(protoExpression, descriptors) { var argumentList = [protoExpression]; if (descriptors) argumentList.push(descriptors); return createCallExpression(createMemberExpression(OBJECT, CREATE), createArgumentList(argumentList)); } function createPropertyDescriptor(descr) { var propertyNameAndValues = Object.keys(descr).map(function(name) { var value = descr[name]; if (!(value instanceof ParseTree)) value = createBooleanLiteral(!!value); return createPropertyNameAssignment(name, value); }); return createObjectLiteralExpression(propertyNameAndValues); } function createDefineProperty(tree, name, descr) { if (typeof name === 'string') name = createStringLiteral(name); return createCallExpression(createMemberExpression(OBJECT, DEFINE_PROPERTY), createArgumentList([tree, name, createPropertyDescriptor(descr)])); } function createObjectLiteralExpression(propertyNameAndValues) { return new ObjectLiteralExpression(null, propertyNameAndValues); } function createParenExpression(expression) { return new ParenExpression(null, expression); } function createPostfixExpression(operand, operator) { return new PostfixExpression(null, operand, operator); } function createScript(scriptItemList) { return new Script(null, scriptItemList); } function createPropertyNameAssignment(identifier, value) { if (typeof identifier == 'string') identifier = createLiteralPropertyName(identifier); return new PropertyNameAssignment(null, identifier, value); } function createLiteralPropertyName(name) { return new LiteralPropertyName(null, createIdentifierToken(name)); } function createRestParameter(identifier) { return new RestParameter(null, createBindingIdentifier(identifier)); } function createReturnStatement(expression) { return new ReturnStatement(null, expression); } function createYieldStatement(expression, isYieldFor) { return createExpressionStatement(new YieldExpression(null, expression, isYieldFor)); } function createSpreadExpression(expression) { return new SpreadExpression(null, expression); } function createSwitchStatement(expression, caseClauses) { return new SwitchStatement(null, expression, caseClauses); } function createThrowStatement(value) { return new ThrowStatement(null, value); } function createTryStatement(body, catchBlock) { var finallyBlock = arguments[2] !== (void 0) ? arguments[2] : null; return new TryStatement(null, body, catchBlock, finallyBlock); } function createUnaryExpression(operator, operand) { return new UnaryExpression(null, operator, operand); } function createUseStrictDirective() { return createExpressionStatement(createStringLiteral('use strict')); } function createVariableDeclarationList(binding, identifierOrDeclarations, initializer) { if (identifierOrDeclarations instanceof Array) { var declarations = identifierOrDeclarations; return new VariableDeclarationList(null, binding, declarations); } var identifier = identifierOrDeclarations; return createVariableDeclarationList(binding, [createVariableDeclaration(identifier, initializer)]); } function createVariableDeclaration(identifier, initializer) { if (!(identifier instanceof ParseTree) || identifier.type !== ParseTreeType.BINDING_IDENTIFIER && identifier.type !== ParseTreeType.OBJECT_PATTERN && identifier.type !== ParseTreeType.ARRAY_PATTERN) { identifier = createBindingIdentifier(identifier); } return new VariableDeclaration(null, identifier, null, initializer); } function createVariableStatement(listOrBinding, identifier, initializer) { if (listOrBinding instanceof VariableDeclarationList) return new VariableStatement(null, listOrBinding); var binding = listOrBinding; var list = createVariableDeclarationList(binding, identifier, initializer); return createVariableStatement(list); } function createVoid0() { return createParenExpression(createUnaryExpression(createOperatorToken(VOID), createNumberLiteral(0))); } function createWhileStatement(condition, body) { return new WhileStatement(null, condition, body); } function createWithStatement(expression, body) { return new WithStatement(null, expression, body); } function createAssignStateStatement(state) { return createAssignmentStatement(createMemberExpression('$ctx', 'state'), createNumberLiteral(state)); } return { get createOperatorToken() { return createOperatorToken; }, get createIdentifierToken() { return createIdentifierToken; }, get createStringLiteralToken() { return createStringLiteralToken; }, get createBooleanLiteralToken() { return createBooleanLiteralToken; }, get createNullLiteralToken() { return createNullLiteralToken; }, get createNumberLiteralToken() { return createNumberLiteralToken; }, get createEmptyParameterList() { return createEmptyParameterList; }, get createArgumentList() { return createArgumentList; }, get createEmptyArgumentList() { return createEmptyArgumentList; }, get createArrayLiteralExpression() { return createArrayLiteralExpression; }, get createEmptyArrayLiteralExpression() { return createEmptyArrayLiteralExpression; }, get createAssignmentExpression() { return createAssignmentExpression; }, get createBinaryExpression() { return createBinaryExpression; }, get createBindingIdentifier() { return createBindingIdentifier; }, get createEmptyStatement() { return createEmptyStatement; }, get createEmptyBlock() { return createEmptyBlock; }, get createBlock() { return createBlock; }, get createFunctionBody() { return createFunctionBody; }, get createScopedExpression() { return createScopedExpression; }, get createImmediatelyInvokedFunctionExpression() { return createImmediatelyInvokedFunctionExpression; }, get createCallExpression() { return createCallExpression; }, get createBreakStatement() { return createBreakStatement; }, get createCaseClause() { return createCaseClause; }, get createCatch() { return createCatch; }, get createClassDeclaration() { return createClassDeclaration; }, get createCommaExpression() { return createCommaExpression; }, get createConditionalExpression() { return createConditionalExpression; }, get createContinueStatement() { return createContinueStatement; }, get createDefaultClause() { return createDefaultClause; }, get createDoWhileStatement() { return createDoWhileStatement; }, get createAssignmentStatement() { return createAssignmentStatement; }, get createCallStatement() { return createCallStatement; }, get createExpressionStatement() { return createExpressionStatement; }, get createFinally() { return createFinally; }, get createForOfStatement() { return createForOfStatement; }, get createForInStatement() { return createForInStatement; }, get createForStatement() { return createForStatement; }, get createFunctionExpression() { return createFunctionExpression; }, get createIdentifierExpression() { return createIdentifierExpression; }, get createUndefinedExpression() { return createUndefinedExpression; }, get createIfStatement() { return createIfStatement; }, get createStringLiteral() { return createStringLiteral; }, get createBooleanLiteral() { return createBooleanLiteral; }, get createTrueLiteral() { return createTrueLiteral; }, get createFalseLiteral() { return createFalseLiteral; }, get createNullLiteral() { return createNullLiteral; }, get createNumberLiteral() { return createNumberLiteral; }, get createMemberExpression() { return createMemberExpression; }, get createMemberLookupExpression() { return createMemberLookupExpression; }, get createThisExpression() { return createThisExpression; }, get createNewExpression() { return createNewExpression; }, get createObjectFreeze() { return createObjectFreeze; }, get createObjectCreate() { return createObjectCreate; }, get createPropertyDescriptor() { return createPropertyDescriptor; }, get createDefineProperty() { return createDefineProperty; }, get createObjectLiteralExpression() { return createObjectLiteralExpression; }, get createParenExpression() { return createParenExpression; }, get createPostfixExpression() { return createPostfixExpression; }, get createScript() { return createScript; }, get createPropertyNameAssignment() { return createPropertyNameAssignment; }, get createReturnStatement() { return createReturnStatement; }, get createYieldStatement() { return createYieldStatement; }, get createSwitchStatement() { return createSwitchStatement; }, get createThrowStatement() { return createThrowStatement; }, get createTryStatement() { return createTryStatement; }, get createUnaryExpression() { return createUnaryExpression; }, get createUseStrictDirective() { return createUseStrictDirective; }, get createVariableDeclarationList() { return createVariableDeclarationList; }, get createVariableDeclaration() { return createVariableDeclaration; }, get createVariableStatement() { return createVariableStatement; }, get createVoid0() { return createVoid0; }, get createWhileStatement() { return createWhileStatement; }, get createWithStatement() { return createWithStatement; }, get createAssignStateStatement() { return createAssignStateStatement; } }; }); System.register("traceur@0.0.52/src/codegeneration/FindVisitor", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/FindVisitor"; var ParseTreeVisitor = System.get("traceur@0.0.52/src/syntax/ParseTreeVisitor").ParseTreeVisitor; var FindVisitor = function FindVisitor(tree) { var keepOnGoing = arguments[1]; this.found_ = false; this.shouldContinue_ = true; this.keepOnGoing_ = keepOnGoing; this.visitAny(tree); }; ($traceurRuntime.createClass)(FindVisitor, { get found() { return this.found_; }, set found(v) { if (v) { this.found_ = true; if (!this.keepOnGoing_) this.shouldContinue_ = false; } }, visitAny: function(tree) { this.shouldContinue_ && tree && tree.visit(this); }, visitList: function(list) { if (list) { for (var i = 0; this.shouldContinue_ && i < list.length; i++) { this.visitAny(list[i]); } } } }, {}, ParseTreeVisitor); return {get FindVisitor() { return FindVisitor; }}; }); System.register("traceur@0.0.52/src/syntax/Keywords", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/syntax/Keywords"; var keywords = ['break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'default', 'delete', 'do', 'else', 'export', 'finally', 'for', 'function', 'if', 'import', 'in', 'instanceof', 'let', 'new', 'return', 'super', 'switch', 'this', 'throw', 'try', 'typeof', 'var', 'void', 'while', 'with', 'enum', 'extends', 'null', 'true', 'false']; var strictKeywords = ['implements', 'interface', 'package', 'private', 'protected', 'public', 'static', 'yield']; var keywordsByName = Object.create(null); var NORMAL_KEYWORD = 1; var STRICT_KEYWORD = 2; keywords.forEach((function(value) { keywordsByName[value] = NORMAL_KEYWORD; })); strictKeywords.forEach((function(value) { keywordsByName[value] = STRICT_KEYWORD; })); function getKeywordType(value) { return keywordsByName[value]; } function isStrictKeyword(value) { return getKeywordType(value) === STRICT_KEYWORD; } return { get NORMAL_KEYWORD() { return NORMAL_KEYWORD; }, get STRICT_KEYWORD() { return STRICT_KEYWORD; }, get getKeywordType() { return getKeywordType; }, get isStrictKeyword() { return isStrictKeyword; } }; }); System.register("traceur@0.0.52/src/staticsemantics/StrictParams", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/staticsemantics/StrictParams"; var ParseTreeVisitor = System.get("traceur@0.0.52/src/syntax/ParseTreeVisitor").ParseTreeVisitor; var isStrictKeyword = System.get("traceur@0.0.52/src/syntax/Keywords").isStrictKeyword; var StrictParams = function StrictParams(errorReporter) { $traceurRuntime.superCall(this, $StrictParams.prototype, "constructor", []); this.errorReporter = errorReporter; }; var $StrictParams = StrictParams; ($traceurRuntime.createClass)(StrictParams, {visitBindingIdentifier: function(tree) { var name = tree.identifierToken.toString(); if (isStrictKeyword(name)) { this.errorReporter.reportError(tree.location.start, (name + " is a reserved identifier")); } }}, {visit: function(tree, errorReporter) { new $StrictParams(errorReporter).visitAny(tree); }}, ParseTreeVisitor); return {get StrictParams() { return StrictParams; }}; }); System.register("traceur@0.0.52/src/util/SourceRange", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/util/SourceRange"; var SourceRange = function SourceRange(start, end) { this.start = start; this.end = end; }; ($traceurRuntime.createClass)(SourceRange, {toString: function() { var str = this.start.source.contents; return str.slice(this.start.offset, this.end.offset); }}, {}); return {get SourceRange() { return SourceRange; }}; }); System.register("traceur@0.0.52/src/util/ErrorReporter", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/util/ErrorReporter"; var ErrorReporter = function ErrorReporter() { this.hadError_ = false; }; ($traceurRuntime.createClass)(ErrorReporter, { reportError: function(location, message) { this.hadError_ = true; this.reportMessageInternal(location, message); }, reportMessageInternal: function(location, message) { if (location) message = (location + ": " + message); console.error(message); }, hadError: function() { return this.hadError_; }, clearError: function() { this.hadError_ = false; } }, {}); function format(location, text) { var args = arguments[2]; var i = 0; text = text.replace(/%./g, function(s) { switch (s) { case '%s': return args && args[i++]; case '%%': return '%'; } return s; }); if (location) text = (location + ": " + text); return text; } ; ErrorReporter.format = format; return { get ErrorReporter() { return ErrorReporter; }, get format() { return format; } }; }); System.register("traceur@0.0.52/src/util/SyntaxErrorReporter", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/util/SyntaxErrorReporter"; var $__113 = System.get("traceur@0.0.52/src/util/ErrorReporter"), ErrorReporter = $__113.ErrorReporter, format = $__113.format; var SyntaxErrorReporter = function SyntaxErrorReporter() { $traceurRuntime.defaultSuperCall(this, $SyntaxErrorReporter.prototype, arguments); }; var $SyntaxErrorReporter = SyntaxErrorReporter; ($traceurRuntime.createClass)(SyntaxErrorReporter, {reportMessageInternal: function(location, message) { var s = format(location, message); throw new SyntaxError(s); }}, {}, ErrorReporter); return {get SyntaxErrorReporter() { return SyntaxErrorReporter; }}; }); System.register("traceur@0.0.52/src/syntax/KeywordToken", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/syntax/KeywordToken"; var STRICT_KEYWORD = System.get("traceur@0.0.52/src/syntax/Keywords").STRICT_KEYWORD; var Token = System.get("traceur@0.0.52/src/syntax/Token").Token; var KeywordToken = function KeywordToken(type, keywordType, location) { this.type = type; this.location = location; this.isStrictKeyword_ = keywordType === STRICT_KEYWORD; }; ($traceurRuntime.createClass)(KeywordToken, { isKeyword: function() { return true; }, isStrictKeyword: function() { return this.isStrictKeyword_; } }, {}, Token); return {get KeywordToken() { return KeywordToken; }}; }); System.register("traceur@0.0.52/src/syntax/unicode-tables", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/syntax/unicode-tables"; var idStartTable = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 442, 443, 443, 444, 447, 448, 451, 452, 659, 660, 660, 661, 687, 688, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 883, 884, 884, 886, 887, 890, 890, 891, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1568, 1599, 1600, 1600, 1601, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2208, 2208, 2210, 2220, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2417, 2418, 2423, 2425, 2431, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3133, 3160, 3161, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3424, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3653, 3654, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4348, 4349, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6210, 6211, 6211, 6212, 6263, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6428, 6480, 6509, 6512, 6516, 6528, 6571, 6593, 6599, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7287, 7288, 7293, 7401, 7404, 7406, 7409, 7413, 7414, 7424, 7467, 7468, 7530, 7531, 7543, 7544, 7544, 7545, 7578, 7579, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8472, 8472, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8494, 8494, 8495, 8500, 8501, 8504, 8505, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8578, 8579, 8580, 8581, 8584, 11264, 11310, 11312, 11358, 11360, 11387, 11388, 11389, 11390, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 12293, 12293, 12294, 12294, 12295, 12295, 12321, 12329, 12337, 12341, 12344, 12346, 12347, 12347, 12348, 12348, 12353, 12438, 12443, 12444, 12445, 12446, 12447, 12447, 12449, 12538, 12540, 12542, 12543, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 40980, 40981, 40981, 40982, 42124, 42192, 42231, 42232, 42237, 42240, 42507, 42508, 42508, 42512, 42527, 42538, 42539, 42560, 42605, 42606, 42606, 42623, 42623, 42624, 42647, 42656, 42725, 42726, 42735, 42775, 42783, 42786, 42863, 42864, 42864, 42865, 42887, 42888, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43001, 43002, 43002, 43003, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43631, 43632, 43632, 43633, 43638, 43642, 43642, 43648, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43740, 43741, 43741, 43744, 43754, 43762, 43762, 43763, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65391, 65392, 65392, 65393, 65437, 65438, 65439, 65440, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65536, 65547, 65549, 65574, 65576, 65594, 65596, 65597, 65599, 65613, 65616, 65629, 65664, 65786, 65856, 65908, 66176, 66204, 66208, 66256, 66304, 66334, 66352, 66368, 66369, 66369, 66370, 66377, 66378, 66378, 66432, 66461, 66464, 66499, 66504, 66511, 66513, 66517, 66560, 66639, 66640, 66717, 67584, 67589, 67592, 67592, 67594, 67637, 67639, 67640, 67644, 67644, 67647, 67669, 67840, 67861, 67872, 67897, 67968, 68023, 68030, 68031, 68096, 68096, 68112, 68115, 68117, 68119, 68121, 68147, 68192, 68220, 68352, 68405, 68416, 68437, 68448, 68466, 68608, 68680, 69635, 69687, 69763, 69807, 69840, 69864, 69891, 69926, 70019, 70066, 70081, 70084, 71296, 71338, 73728, 74606, 74752, 74850, 77824, 78894, 92160, 92728, 93952, 94020, 94032, 94032, 94099, 94111, 110592, 110593, 119808, 119892, 119894, 119964, 119966, 119967, 119970, 119970, 119973, 119974, 119977, 119980, 119982, 119993, 119995, 119995, 119997, 120003, 120005, 120069, 120071, 120074, 120077, 120084, 120086, 120092, 120094, 120121, 120123, 120126, 120128, 120132, 120134, 120134, 120138, 120144, 120146, 120485, 120488, 120512, 120514, 120538, 120540, 120570, 120572, 120596, 120598, 120628, 120630, 120654, 120656, 120686, 120688, 120712, 120714, 120744, 120746, 120770, 120772, 120779, 126464, 126467, 126469, 126495, 126497, 126498, 126500, 126500, 126503, 126503, 126505, 126514, 126516, 126519, 126521, 126521, 126523, 126523, 126530, 126530, 126535, 126535, 126537, 126537, 126539, 126539, 126541, 126543, 126545, 126546, 126548, 126548, 126551, 126551, 126553, 126553, 126555, 126555, 126557, 126557, 126559, 126559, 126561, 126562, 126564, 126564, 126567, 126570, 126572, 126578, 126580, 126583, 126585, 126588, 126590, 126590, 126592, 126601, 126603, 126619, 126625, 126627, 126629, 126633, 126635, 126651, 131072, 173782, 173824, 177972, 177984, 178205, 194560, 195101]; var idContinueTable = [183, 183, 768, 879, 903, 903, 1155, 1159, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1552, 1562, 1611, 1631, 1632, 1641, 1648, 1648, 1750, 1756, 1759, 1764, 1767, 1768, 1770, 1773, 1776, 1785, 1809, 1809, 1840, 1866, 1958, 1968, 1984, 1993, 2027, 2035, 2070, 2073, 2075, 2083, 2085, 2087, 2089, 2093, 2137, 2139, 2276, 2302, 2304, 2306, 2307, 2307, 2362, 2362, 2363, 2363, 2364, 2364, 2366, 2368, 2369, 2376, 2377, 2380, 2381, 2381, 2382, 2383, 2385, 2391, 2402, 2403, 2406, 2415, 2433, 2433, 2434, 2435, 2492, 2492, 2494, 2496, 2497, 2500, 2503, 2504, 2507, 2508, 2509, 2509, 2519, 2519, 2530, 2531, 2534, 2543, 2561, 2562, 2563, 2563, 2620, 2620, 2622, 2624, 2625, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2662, 2671, 2672, 2673, 2677, 2677, 2689, 2690, 2691, 2691, 2748, 2748, 2750, 2752, 2753, 2757, 2759, 2760, 2761, 2761, 2763, 2764, 2765, 2765, 2786, 2787, 2790, 2799, 2817, 2817, 2818, 2819, 2876, 2876, 2878, 2878, 2879, 2879, 2880, 2880, 2881, 2884, 2887, 2888, 2891, 2892, 2893, 2893, 2902, 2902, 2903, 2903, 2914, 2915, 2918, 2927, 2946, 2946, 3006, 3007, 3008, 3008, 3009, 3010, 3014, 3016, 3018, 3020, 3021, 3021, 3031, 3031, 3046, 3055, 3073, 3075, 3134, 3136, 3137, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3170, 3171, 3174, 3183, 3202, 3203, 3260, 3260, 3262, 3262, 3263, 3263, 3264, 3268, 3270, 3270, 3271, 3272, 3274, 3275, 3276, 3277, 3285, 3286, 3298, 3299, 3302, 3311, 3330, 3331, 3390, 3392, 3393, 3396, 3398, 3400, 3402, 3404, 3405, 3405, 3415, 3415, 3426, 3427, 3430, 3439, 3458, 3459, 3530, 3530, 3535, 3537, 3538, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3633, 3633, 3636, 3642, 3655, 3662, 3664, 3673, 3761, 3761, 3764, 3769, 3771, 3772, 3784, 3789, 3792, 3801, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3903, 3953, 3966, 3967, 3967, 3968, 3972, 3974, 3975, 3981, 3991, 3993, 4028, 4038, 4038, 4139, 4140, 4141, 4144, 4145, 4145, 4146, 4151, 4152, 4152, 4153, 4154, 4155, 4156, 4157, 4158, 4160, 4169, 4182, 4183, 4184, 4185, 4190, 4192, 4194, 4196, 4199, 4205, 4209, 4212, 4226, 4226, 4227, 4228, 4229, 4230, 4231, 4236, 4237, 4237, 4239, 4239, 4240, 4249, 4250, 4252, 4253, 4253, 4957, 4959, 4969, 4977, 5906, 5908, 5938, 5940, 5970, 5971, 6002, 6003, 6068, 6069, 6070, 6070, 6071, 6077, 6078, 6085, 6086, 6086, 6087, 6088, 6089, 6099, 6109, 6109, 6112, 6121, 6155, 6157, 6160, 6169, 6313, 6313, 6432, 6434, 6435, 6438, 6439, 6440, 6441, 6443, 6448, 6449, 6450, 6450, 6451, 6456, 6457, 6459, 6470, 6479, 6576, 6592, 6600, 6601, 6608, 6617, 6618, 6618, 6679, 6680, 6681, 6683, 6741, 6741, 6742, 6742, 6743, 6743, 6744, 6750, 6752, 6752, 6753, 6753, 6754, 6754, 6755, 6756, 6757, 6764, 6765, 6770, 6771, 6780, 6783, 6783, 6784, 6793, 6800, 6809, 6912, 6915, 6916, 6916, 6964, 6964, 6965, 6965, 6966, 6970, 6971, 6971, 6972, 6972, 6973, 6977, 6978, 6978, 6979, 6980, 6992, 7001, 7019, 7027, 7040, 7041, 7042, 7042, 7073, 7073, 7074, 7077, 7078, 7079, 7080, 7081, 7082, 7082, 7083, 7083, 7084, 7085, 7088, 7097, 7142, 7142, 7143, 7143, 7144, 7145, 7146, 7148, 7149, 7149, 7150, 7150, 7151, 7153, 7154, 7155, 7204, 7211, 7212, 7219, 7220, 7221, 7222, 7223, 7232, 7241, 7248, 7257, 7376, 7378, 7380, 7392, 7393, 7393, 7394, 7400, 7405, 7405, 7410, 7411, 7412, 7412, 7616, 7654, 7676, 7679, 8255, 8256, 8276, 8276, 8400, 8412, 8417, 8417, 8421, 8432, 11503, 11505, 11647, 11647, 11744, 11775, 12330, 12333, 12334, 12335, 12441, 12442, 42528, 42537, 42607, 42607, 42612, 42621, 42655, 42655, 42736, 42737, 43010, 43010, 43014, 43014, 43019, 43019, 43043, 43044, 43045, 43046, 43047, 43047, 43136, 43137, 43188, 43203, 43204, 43204, 43216, 43225, 43232, 43249, 43264, 43273, 43302, 43309, 43335, 43345, 43346, 43347, 43392, 43394, 43395, 43395, 43443, 43443, 43444, 43445, 43446, 43449, 43450, 43451, 43452, 43452, 43453, 43456, 43472, 43481, 43561, 43566, 43567, 43568, 43569, 43570, 43571, 43572, 43573, 43574, 43587, 43587, 43596, 43596, 43597, 43597, 43600, 43609, 43643, 43643, 43696, 43696, 43698, 43700, 43703, 43704, 43710, 43711, 43713, 43713, 43755, 43755, 43756, 43757, 43758, 43759, 43765, 43765, 43766, 43766, 44003, 44004, 44005, 44005, 44006, 44007, 44008, 44008, 44009, 44010, 44012, 44012, 44013, 44013, 44016, 44025, 64286, 64286, 65024, 65039, 65056, 65062, 65075, 65076, 65101, 65103, 65296, 65305, 65343, 65343, 66045, 66045, 66720, 66729, 68097, 68099, 68101, 68102, 68108, 68111, 68152, 68154, 68159, 68159, 69632, 69632, 69633, 69633, 69634, 69634, 69688, 69702, 69734, 69743, 69760, 69761, 69762, 69762, 69808, 69810, 69811, 69814, 69815, 69816, 69817, 69818, 69872, 69881, 69888, 69890, 69927, 69931, 69932, 69932, 69933, 69940, 69942, 69951, 70016, 70017, 70018, 70018, 70067, 70069, 70070, 70078, 70079, 70080, 70096, 70105, 71339, 71339, 71340, 71340, 71341, 71341, 71342, 71343, 71344, 71349, 71350, 71350, 71351, 71351, 71360, 71369, 94033, 94078, 94095, 94098, 119141, 119142, 119143, 119145, 119149, 119154, 119163, 119170, 119173, 119179, 119210, 119213, 119362, 119364, 120782, 120831, 917760, 917999]; return { get idStartTable() { return idStartTable; }, get idContinueTable() { return idContinueTable; } }; }); System.register("traceur@0.0.52/src/syntax/Scanner", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/syntax/Scanner"; var IdentifierToken = System.get("traceur@0.0.52/src/syntax/IdentifierToken").IdentifierToken; var KeywordToken = System.get("traceur@0.0.52/src/syntax/KeywordToken").KeywordToken; var LiteralToken = System.get("traceur@0.0.52/src/syntax/LiteralToken").LiteralToken; var Token = System.get("traceur@0.0.52/src/syntax/Token").Token; var getKeywordType = System.get("traceur@0.0.52/src/syntax/Keywords").getKeywordType; var $__123 = System.get("traceur@0.0.52/src/syntax/unicode-tables"), idContinueTable = $__123.idContinueTable, idStartTable = $__123.idStartTable; var $__124 = System.get("traceur@0.0.52/src/Options"), options = $__124.options, parseOptions = $__124.parseOptions; var $__125 = System.get("traceur@0.0.52/src/syntax/TokenType"), AMPERSAND = $__125.AMPERSAND, AMPERSAND_EQUAL = $__125.AMPERSAND_EQUAL, AND = $__125.AND, ARROW = $__125.ARROW, AT = $__125.AT, BANG = $__125.BANG, BAR = $__125.BAR, BAR_EQUAL = $__125.BAR_EQUAL, CARET = $__125.CARET, CARET_EQUAL = $__125.CARET_EQUAL, CLOSE_ANGLE = $__125.CLOSE_ANGLE, CLOSE_CURLY = $__125.CLOSE_CURLY, CLOSE_PAREN = $__125.CLOSE_PAREN, CLOSE_SQUARE = $__125.CLOSE_SQUARE, COLON = $__125.COLON, COMMA = $__125.COMMA, DOT_DOT_DOT = $__125.DOT_DOT_DOT, END_OF_FILE = $__125.END_OF_FILE, EQUAL = $__125.EQUAL, EQUAL_EQUAL = $__125.EQUAL_EQUAL, EQUAL_EQUAL_EQUAL = $__125.EQUAL_EQUAL_EQUAL, ERROR = $__125.ERROR, GREATER_EQUAL = $__125.GREATER_EQUAL, LEFT_SHIFT = $__125.LEFT_SHIFT, LEFT_SHIFT_EQUAL = $__125.LEFT_SHIFT_EQUAL, LESS_EQUAL = $__125.LESS_EQUAL, MINUS = $__125.MINUS, MINUS_EQUAL = $__125.MINUS_EQUAL, MINUS_MINUS = $__125.MINUS_MINUS, NO_SUBSTITUTION_TEMPLATE = $__125.NO_SUBSTITUTION_TEMPLATE, NOT_EQUAL = $__125.NOT_EQUAL, NOT_EQUAL_EQUAL = $__125.NOT_EQUAL_EQUAL, NUMBER = $__125.NUMBER, OPEN_ANGLE = $__125.OPEN_ANGLE, OPEN_CURLY = $__125.OPEN_CURLY, OPEN_PAREN = $__125.OPEN_PAREN, OPEN_SQUARE = $__125.OPEN_SQUARE, OR = $__125.OR, PERCENT = $__125.PERCENT, PERCENT_EQUAL = $__125.PERCENT_EQUAL, PERIOD = $__125.PERIOD, PLUS = $__125.PLUS, PLUS_EQUAL = $__125.PLUS_EQUAL, PLUS_PLUS = $__125.PLUS_PLUS, QUESTION = $__125.QUESTION, REGULAR_EXPRESSION = $__125.REGULAR_EXPRESSION, RIGHT_SHIFT = $__125.RIGHT_SHIFT, RIGHT_SHIFT_EQUAL = $__125.RIGHT_SHIFT_EQUAL, SEMI_COLON = $__125.SEMI_COLON, SLASH = $__125.SLASH, SLASH_EQUAL = $__125.SLASH_EQUAL, STAR = $__125.STAR, STAR_EQUAL = $__125.STAR_EQUAL, STRING = $__125.STRING, TEMPLATE_HEAD = $__125.TEMPLATE_HEAD, TEMPLATE_MIDDLE = $__125.TEMPLATE_MIDDLE, TEMPLATE_TAIL = $__125.TEMPLATE_TAIL, TILDE = $__125.TILDE, UNSIGNED_RIGHT_SHIFT = $__125.UNSIGNED_RIGHT_SHIFT, UNSIGNED_RIGHT_SHIFT_EQUAL = $__125.UNSIGNED_RIGHT_SHIFT_EQUAL; var isWhitespaceArray = []; for (var i = 0; i < 128; i++) { isWhitespaceArray[i] = i >= 9 && i <= 13 || i === 0x20; } var isWhitespaceArray = []; for (var i = 0; i < 128; i++) { isWhitespaceArray[i] = i >= 9 && i <= 13 || i === 0x20; } function isWhitespace(code) { if (code < 128) return isWhitespaceArray[code]; switch (code) { case 0xA0: case 0xFEFF: case 0x2028: case 0x2029: return true; } return false; } function isLineTerminator(code) { switch (code) { case 10: case 13: case 0x2028: case 0x2029: return true; } return false; } function isDecimalDigit(code) { return code >= 48 && code <= 57; } var isHexDigitArray = []; for (var i = 0; i < 128; i++) { isHexDigitArray[i] = i >= 48 && i <= 57 || i >= 65 && i <= 70 || i >= 97 && i <= 102; } function isHexDigit(code) { return code < 128 && isHexDigitArray[code]; } function isBinaryDigit(code) { return code === 48 || code === 49; } function isOctalDigit(code) { return code >= 48 && code <= 55; } var isIdentifierStartArray = []; for (var i = 0; i < 128; i++) { isIdentifierStartArray[i] = i === 36 || i >= 65 && i <= 90 || i === 95 || i >= 97 && i <= 122; } function isIdentifierStart(code) { return code < 128 ? isIdentifierStartArray[code] : inTable(idStartTable, code); } var isIdentifierPartArray = []; for (var i = 0; i < 128; i++) { isIdentifierPartArray[i] = isIdentifierStart(i) || isDecimalDigit(i); } function isIdentifierPart(code) { return code < 128 ? isIdentifierPartArray[code] : inTable(idStartTable, code) || inTable(idContinueTable, code) || code === 8204 || code === 8205; } function inTable(table, code) { for (var i = 0; i < table.length; ) { if (code < table[i++]) return false; if (code <= table[i++]) return true; } return false; } function isRegularExpressionChar(code) { switch (code) { case 47: return false; case 91: case 92: return true; } return !isLineTerminator(code); } function isRegularExpressionFirstChar(code) { return isRegularExpressionChar(code) && code !== 42; } var index, input, length, token, lastToken, lookaheadToken, currentCharCode, lineNumberTable, errorReporter, currentParser; var Scanner = function Scanner(reporter, file, parser) { errorReporter = reporter; lineNumberTable = file.lineNumberTable; input = file.contents; length = file.contents.length; this.index = 0; currentParser = parser; }; ($traceurRuntime.createClass)(Scanner, { get lastToken() { return lastToken; }, getPosition: function() { return getPosition(getOffset()); }, nextRegularExpressionLiteralToken: function() { lastToken = nextRegularExpressionLiteralToken(); token = scanToken(); return lastToken; }, nextTemplateLiteralToken: function() { var t = nextTemplateLiteralToken(); token = scanToken(); return t; }, nextToken: function() { return nextToken(); }, peekToken: function(opt_index) { return opt_index ? peekTokenLookahead() : peekToken(); }, peekTokenNoLineTerminator: function() { return peekTokenNoLineTerminator(); }, isAtEnd: function() { return isAtEnd(); }, set index(i) { index = i; lastToken = null; token = null; lookaheadToken = null; updateCurrentCharCode(); }, get index() { return index; } }, {}); function getPosition(offset) { return lineNumberTable.getSourcePosition(offset); } function getTokenRange(startOffset) { return lineNumberTable.getSourceRange(startOffset, index); } function getOffset() { return token ? token.location.start.offset : index; } function nextRegularExpressionLiteralToken() { var beginIndex = index - token.toString().length; if (!(token.type == SLASH_EQUAL && currentCharCode === 47) && !skipRegularExpressionBody()) { return new LiteralToken(REGULAR_EXPRESSION, getTokenString(beginIndex), getTokenRange(beginIndex)); } if (currentCharCode !== 47) { reportError('Expected \'/\' in regular expression literal'); return new LiteralToken(REGULAR_EXPRESSION, getTokenString(beginIndex), getTokenRange(beginIndex)); } next(); while (isIdentifierPart(currentCharCode)) { next(); } return new LiteralToken(REGULAR_EXPRESSION, getTokenString(beginIndex), getTokenRange(beginIndex)); } function skipRegularExpressionBody() { if (!isRegularExpressionFirstChar(currentCharCode)) { reportError('Expected regular expression first char'); return false; } while (!isAtEnd() && isRegularExpressionChar(currentCharCode)) { if (!skipRegularExpressionChar()) return false; } return true; } function skipRegularExpressionChar() { switch (currentCharCode) { case 92: return skipRegularExpressionBackslashSequence(); case 91: return skipRegularExpressionClass(); default: next(); return true; } } function skipRegularExpressionBackslashSequence() { next(); if (isLineTerminator(currentCharCode) || isAtEnd()) { reportError('New line not allowed in regular expression literal'); return false; } next(); return true; } function skipRegularExpressionClass() { next(); while (!isAtEnd() && peekRegularExpressionClassChar()) { if (!skipRegularExpressionClassChar()) { return false; } } if (currentCharCode !== 93) { reportError('\']\' expected'); return false; } next(); return true; } function peekRegularExpressionClassChar() { return currentCharCode !== 93 && !isLineTerminator(currentCharCode); } function skipRegularExpressionClassChar() { if (currentCharCode === 92) { return skipRegularExpressionBackslashSequence(); } next(); return true; } function skipTemplateCharacter() { while (!isAtEnd()) { switch (currentCharCode) { case 96: return; case 92: skipStringLiteralEscapeSequence(); break; case 36: var code = input.charCodeAt(index + 1); if (code === 123) return; default: next(); } } } function scanTemplateStart(beginIndex) { if (isAtEnd()) { reportError('Unterminated template literal'); return lastToken = createToken(END_OF_FILE, beginIndex); } return nextTemplateLiteralTokenShared(NO_SUBSTITUTION_TEMPLATE, TEMPLATE_HEAD); } function nextTemplateLiteralToken() { if (isAtEnd()) { reportError('Expected \'}\' after expression in template literal'); return createToken(END_OF_FILE, index); } if (token.type !== CLOSE_CURLY) { reportError('Expected \'}\' after expression in template literal'); return createToken(ERROR, index); } return nextTemplateLiteralTokenShared(TEMPLATE_TAIL, TEMPLATE_MIDDLE); } function nextTemplateLiteralTokenShared(endType, middleType) { var beginIndex = index; skipTemplateCharacter(); if (isAtEnd()) { reportError('Unterminated template literal'); return createToken(ERROR, beginIndex); } var value = getTokenString(beginIndex); switch (currentCharCode) { case 96: next(); return lastToken = new LiteralToken(endType, value, getTokenRange(beginIndex - 1)); case 36: next(); next(); return lastToken = new LiteralToken(middleType, value, getTokenRange(beginIndex - 1)); } } function nextToken() { var t = peekToken(); token = lookaheadToken || scanToken(); lookaheadToken = null; lastToken = t; return t; } function peekTokenNoLineTerminator() { var t = peekToken(); var start = lastToken.location.end.offset; var end = t.location.start.offset; for (var i = start; i < end; i++) { var code = input.charCodeAt(i); if (isLineTerminator(code)) return null; if (code === 47) { code = input.charCodeAt(++i); if (code === 47) return null; i = input.indexOf('*/', i) + 2; } } return t; } function peekToken() { return token || (token = scanToken()); } function peekTokenLookahead() { if (!token) token = scanToken(); if (!lookaheadToken) lookaheadToken = scanToken(); return lookaheadToken; } function skipWhitespace() { while (!isAtEnd() && peekWhitespace()) { next(); } } function peekWhitespace() { return isWhitespace(currentCharCode); } function skipComments() { while (skipComment()) {} } function skipComment() { skipWhitespace(); var code = currentCharCode; if (code === 47) { code = input.charCodeAt(index + 1); switch (code) { case 47: skipSingleLineComment(); return true; case 42: skipMultiLineComment(); return true; } } return false; } function commentCallback(start, index) { if (options.commentCallback) currentParser.handleComment(lineNumberTable.getSourceRange(start, index)); } function skipSingleLineComment() { var start = index; index += 2; while (!isAtEnd() && !isLineTerminator(input.charCodeAt(index++))) {} updateCurrentCharCode(); commentCallback(start, index); } function skipMultiLineComment() { var start = index; var i = input.indexOf('*/', index + 2); if (i !== -1) index = i + 2; else index = length; updateCurrentCharCode(); commentCallback(start, index); } function scanToken() { skipComments(); var beginIndex = index; if (isAtEnd()) return createToken(END_OF_FILE, beginIndex); var code = currentCharCode; next(); switch (code) { case 123: return createToken(OPEN_CURLY, beginIndex); case 125: return createToken(CLOSE_CURLY, beginIndex); case 40: return createToken(OPEN_PAREN, beginIndex); case 41: return createToken(CLOSE_PAREN, beginIndex); case 91: return createToken(OPEN_SQUARE, beginIndex); case 93: return createToken(CLOSE_SQUARE, beginIndex); case 46: switch (currentCharCode) { case 46: if (input.charCodeAt(index + 1) === 46) { next(); next(); return createToken(DOT_DOT_DOT, beginIndex); } break; default: if (isDecimalDigit(currentCharCode)) return scanNumberPostPeriod(beginIndex); } return createToken(PERIOD, beginIndex); case 59: return createToken(SEMI_COLON, beginIndex); case 44: return createToken(COMMA, beginIndex); case 126: return createToken(TILDE, beginIndex); case 63: return createToken(QUESTION, beginIndex); case 58: return createToken(COLON, beginIndex); case 60: switch (currentCharCode) { case 60: next(); if (currentCharCode === 61) { next(); return createToken(LEFT_SHIFT_EQUAL, beginIndex); } return createToken(LEFT_SHIFT, beginIndex); case 61: next(); return createToken(LESS_EQUAL, beginIndex); default: return createToken(OPEN_ANGLE, beginIndex); } case 62: switch (currentCharCode) { case 62: next(); switch (currentCharCode) { case 61: next(); return createToken(RIGHT_SHIFT_EQUAL, beginIndex); case 62: next(); if (currentCharCode === 61) { next(); return createToken(UNSIGNED_RIGHT_SHIFT_EQUAL, beginIndex); } return createToken(UNSIGNED_RIGHT_SHIFT, beginIndex); default: return createToken(RIGHT_SHIFT, beginIndex); } case 61: next(); return createToken(GREATER_EQUAL, beginIndex); default: return createToken(CLOSE_ANGLE, beginIndex); } case 61: if (currentCharCode === 61) { next(); if (currentCharCode === 61) { next(); return createToken(EQUAL_EQUAL_EQUAL, beginIndex); } return createToken(EQUAL_EQUAL, beginIndex); } if (currentCharCode === 62) { next(); return createToken(ARROW, beginIndex); } return createToken(EQUAL, beginIndex); case 33: if (currentCharCode === 61) { next(); if (currentCharCode === 61) { next(); return createToken(NOT_EQUAL_EQUAL, beginIndex); } return createToken(NOT_EQUAL, beginIndex); } return createToken(BANG, beginIndex); case 42: if (currentCharCode === 61) { next(); return createToken(STAR_EQUAL, beginIndex); } return createToken(STAR, beginIndex); case 37: if (currentCharCode === 61) { next(); return createToken(PERCENT_EQUAL, beginIndex); } return createToken(PERCENT, beginIndex); case 94: if (currentCharCode === 61) { next(); return createToken(CARET_EQUAL, beginIndex); } return createToken(CARET, beginIndex); case 47: if (currentCharCode === 61) { next(); return createToken(SLASH_EQUAL, beginIndex); } return createToken(SLASH, beginIndex); case 43: switch (currentCharCode) { case 43: next(); return createToken(PLUS_PLUS, beginIndex); case 61: next(); return createToken(PLUS_EQUAL, beginIndex); default: return createToken(PLUS, beginIndex); } case 45: switch (currentCharCode) { case 45: next(); return createToken(MINUS_MINUS, beginIndex); case 61: next(); return createToken(MINUS_EQUAL, beginIndex); default: return createToken(MINUS, beginIndex); } case 38: switch (currentCharCode) { case 38: next(); return createToken(AND, beginIndex); case 61: next(); return createToken(AMPERSAND_EQUAL, beginIndex); default: return createToken(AMPERSAND, beginIndex); } case 124: switch (currentCharCode) { case 124: next(); return createToken(OR, beginIndex); case 61: next(); return createToken(BAR_EQUAL, beginIndex); default: return createToken(BAR, beginIndex); } case 96: return scanTemplateStart(beginIndex); case 64: return createToken(AT, beginIndex); case 48: return scanPostZero(beginIndex); case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57: return scanPostDigit(beginIndex); case 34: case 39: return scanStringLiteral(beginIndex, code); default: return scanIdentifierOrKeyword(beginIndex, code); } } function scanNumberPostPeriod(beginIndex) { skipDecimalDigits(); return scanExponentOfNumericLiteral(beginIndex); } function scanPostDigit(beginIndex) { skipDecimalDigits(); return scanFractionalNumericLiteral(beginIndex); } function scanPostZero(beginIndex) { switch (currentCharCode) { case 46: return scanFractionalNumericLiteral(beginIndex); case 88: case 120: next(); if (!isHexDigit(currentCharCode)) { reportError('Hex Integer Literal must contain at least one digit'); } skipHexDigits(); return new LiteralToken(NUMBER, getTokenString(beginIndex), getTokenRange(beginIndex)); case 66: case 98: if (!parseOptions.numericLiterals) break; next(); if (!isBinaryDigit(currentCharCode)) { reportError('Binary Integer Literal must contain at least one digit'); } skipBinaryDigits(); return new LiteralToken(NUMBER, getTokenString(beginIndex), getTokenRange(beginIndex)); case 79: case 111: if (!parseOptions.numericLiterals) break; next(); if (!isOctalDigit(currentCharCode)) { reportError('Octal Integer Literal must contain at least one digit'); } skipOctalDigits(); return new LiteralToken(NUMBER, getTokenString(beginIndex), getTokenRange(beginIndex)); case 48: case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57: return scanPostDigit(beginIndex); } return new LiteralToken(NUMBER, getTokenString(beginIndex), getTokenRange(beginIndex)); } function createToken(type, beginIndex) { return new Token(type, getTokenRange(beginIndex)); } function readUnicodeEscapeSequence() { var beginIndex = index; if (currentCharCode === 117) { next(); if (skipHexDigit() && skipHexDigit() && skipHexDigit() && skipHexDigit()) { return parseInt(getTokenString(beginIndex + 1), 16); } } reportError('Invalid unicode escape sequence in identifier', beginIndex - 1); return 0; } function scanIdentifierOrKeyword(beginIndex, code) { var escapedCharCodes; if (code === 92) { code = readUnicodeEscapeSequence(); escapedCharCodes = [code]; } if (!isIdentifierStart(code)) { reportError(("Character code '" + code + "' is not a valid identifier start char"), beginIndex); return createToken(ERROR, beginIndex); } for (; ; ) { code = currentCharCode; if (isIdentifierPart(code)) { next(); } else if (code === 92) { next(); code = readUnicodeEscapeSequence(); if (!escapedCharCodes) escapedCharCodes = []; escapedCharCodes.push(code); if (!isIdentifierPart(code)) return createToken(ERROR, beginIndex); } else { break; } } var value = input.slice(beginIndex, index); var keywordType = getKeywordType(value); if (keywordType) return new KeywordToken(value, keywordType, getTokenRange(beginIndex)); if (escapedCharCodes) { var i = 0; value = value.replace(/\\u..../g, function(s) { return String.fromCharCode(escapedCharCodes[i++]); }); } return new IdentifierToken(getTokenRange(beginIndex), value); } function scanStringLiteral(beginIndex, terminator) { while (peekStringLiteralChar(terminator)) { if (!skipStringLiteralChar()) { return new LiteralToken(STRING, getTokenString(beginIndex), getTokenRange(beginIndex)); } } if (currentCharCode !== terminator) { reportError('Unterminated String Literal', beginIndex); } else { next(); } return new LiteralToken(STRING, getTokenString(beginIndex), getTokenRange(beginIndex)); } function getTokenString(beginIndex) { return input.substring(beginIndex, index); } function peekStringLiteralChar(terminator) { return !isAtEnd() && currentCharCode !== terminator && !isLineTerminator(currentCharCode); } function skipStringLiteralChar() { if (currentCharCode === 92) { return skipStringLiteralEscapeSequence(); } next(); return true; } function skipStringLiteralEscapeSequence() { next(); if (isAtEnd()) { reportError('Unterminated string literal escape sequence'); return false; } if (isLineTerminator(currentCharCode)) { skipLineTerminator(); return true; } var code = currentCharCode; next(); switch (code) { case 39: case 34: case 92: case 98: case 102: case 110: case 114: case 116: case 118: case 48: return true; case 120: return skipHexDigit() && skipHexDigit(); case 117: return skipHexDigit() && skipHexDigit() && skipHexDigit() && skipHexDigit(); default: return true; } } function skipHexDigit() { if (!isHexDigit(currentCharCode)) { reportError('Hex digit expected'); return false; } next(); return true; } function skipLineTerminator() { var first = currentCharCode; next(); if (first === 13 && currentCharCode === 10) { next(); } } function scanFractionalNumericLiteral(beginIndex) { if (currentCharCode === 46) { next(); skipDecimalDigits(); } return scanExponentOfNumericLiteral(beginIndex); } function scanExponentOfNumericLiteral(beginIndex) { switch (currentCharCode) { case 101: case 69: next(); switch (currentCharCode) { case 43: case 45: next(); break; } if (!isDecimalDigit(currentCharCode)) { reportError('Exponent part must contain at least one digit'); } skipDecimalDigits(); break; default: break; } return new LiteralToken(NUMBER, getTokenString(beginIndex), getTokenRange(beginIndex)); } function skipDecimalDigits() { while (isDecimalDigit(currentCharCode)) { next(); } } function skipHexDigits() { while (isHexDigit(currentCharCode)) { next(); } } function skipBinaryDigits() { while (isBinaryDigit(currentCharCode)) { next(); } } function skipOctalDigits() { while (isOctalDigit(currentCharCode)) { next(); } } function isAtEnd() { return index === length; } function next() { index++; updateCurrentCharCode(); } function updateCurrentCharCode() { currentCharCode = input.charCodeAt(index); } function reportError(message) { var indexArg = arguments[1] !== (void 0) ? arguments[1] : index; var position = getPosition(indexArg); errorReporter.reportError(position, message); } return { get isWhitespace() { return isWhitespace; }, get isLineTerminator() { return isLineTerminator; }, get isIdentifierPart() { return isIdentifierPart; }, get Scanner() { return Scanner; } }; }); System.register("traceur@0.0.52/src/syntax/Parser", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/syntax/Parser"; var FindVisitor = System.get("traceur@0.0.52/src/codegeneration/FindVisitor").FindVisitor; var IdentifierToken = System.get("traceur@0.0.52/src/syntax/IdentifierToken").IdentifierToken; var $__129 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), ARRAY_LITERAL_EXPRESSION = $__129.ARRAY_LITERAL_EXPRESSION, BINDING_IDENTIFIER = $__129.BINDING_IDENTIFIER, CALL_EXPRESSION = $__129.CALL_EXPRESSION, COMPUTED_PROPERTY_NAME = $__129.COMPUTED_PROPERTY_NAME, COVER_FORMALS = $__129.COVER_FORMALS, FORMAL_PARAMETER_LIST = $__129.FORMAL_PARAMETER_LIST, IDENTIFIER_EXPRESSION = $__129.IDENTIFIER_EXPRESSION, LITERAL_PROPERTY_NAME = $__129.LITERAL_PROPERTY_NAME, OBJECT_LITERAL_EXPRESSION = $__129.OBJECT_LITERAL_EXPRESSION, REST_PARAMETER = $__129.REST_PARAMETER, SYNTAX_ERROR_TREE = $__129.SYNTAX_ERROR_TREE; var $__130 = System.get("traceur@0.0.52/src/syntax/PredefinedName"), AS = $__130.AS, ASYNC = $__130.ASYNC, AWAIT = $__130.AWAIT, FROM = $__130.FROM, GET = $__130.GET, MODULE = $__130.MODULE, OF = $__130.OF, SET = $__130.SET; var SyntaxErrorReporter = System.get("traceur@0.0.52/src/util/SyntaxErrorReporter").SyntaxErrorReporter; var Scanner = System.get("traceur@0.0.52/src/syntax/Scanner").Scanner; var SourceRange = System.get("traceur@0.0.52/src/util/SourceRange").SourceRange; var StrictParams = System.get("traceur@0.0.52/src/staticsemantics/StrictParams").StrictParams; var $__135 = System.get("traceur@0.0.52/src/syntax/Token"), Token = $__135.Token, isAssignmentOperator = $__135.isAssignmentOperator; var getKeywordType = System.get("traceur@0.0.52/src/syntax/Keywords").getKeywordType; var $__137 = System.get("traceur@0.0.52/src/Options"), parseOptions = $__137.parseOptions, options = $__137.options; var $__138 = System.get("traceur@0.0.52/src/syntax/TokenType"), AMPERSAND = $__138.AMPERSAND, AND = $__138.AND, ARROW = $__138.ARROW, AT = $__138.AT, BANG = $__138.BANG, BAR = $__138.BAR, BREAK = $__138.BREAK, CARET = $__138.CARET, CASE = $__138.CASE, CATCH = $__138.CATCH, CLASS = $__138.CLASS, CLOSE_ANGLE = $__138.CLOSE_ANGLE, CLOSE_CURLY = $__138.CLOSE_CURLY, CLOSE_PAREN = $__138.CLOSE_PAREN, CLOSE_SQUARE = $__138.CLOSE_SQUARE, COLON = $__138.COLON, COMMA = $__138.COMMA, CONST = $__138.CONST, CONTINUE = $__138.CONTINUE, DEBUGGER = $__138.DEBUGGER, DEFAULT = $__138.DEFAULT, DELETE = $__138.DELETE, DO = $__138.DO, DOT_DOT_DOT = $__138.DOT_DOT_DOT, ELSE = $__138.ELSE, END_OF_FILE = $__138.END_OF_FILE, EQUAL = $__138.EQUAL, EQUAL_EQUAL = $__138.EQUAL_EQUAL, EQUAL_EQUAL_EQUAL = $__138.EQUAL_EQUAL_EQUAL, ERROR = $__138.ERROR, EXPORT = $__138.EXPORT, EXTENDS = $__138.EXTENDS, FALSE = $__138.FALSE, FINALLY = $__138.FINALLY, FOR = $__138.FOR, FUNCTION = $__138.FUNCTION, GREATER_EQUAL = $__138.GREATER_EQUAL, IDENTIFIER = $__138.IDENTIFIER, IF = $__138.IF, IMPLEMENTS = $__138.IMPLEMENTS, IMPORT = $__138.IMPORT, IN = $__138.IN, INSTANCEOF = $__138.INSTANCEOF, INTERFACE = $__138.INTERFACE, LEFT_SHIFT = $__138.LEFT_SHIFT, LESS_EQUAL = $__138.LESS_EQUAL, LET = $__138.LET, MINUS = $__138.MINUS, MINUS_MINUS = $__138.MINUS_MINUS, NEW = $__138.NEW, NO_SUBSTITUTION_TEMPLATE = $__138.NO_SUBSTITUTION_TEMPLATE, NOT_EQUAL = $__138.NOT_EQUAL, NOT_EQUAL_EQUAL = $__138.NOT_EQUAL_EQUAL, NULL = $__138.NULL, NUMBER = $__138.NUMBER, OPEN_ANGLE = $__138.OPEN_ANGLE, OPEN_CURLY = $__138.OPEN_CURLY, OPEN_PAREN = $__138.OPEN_PAREN, OPEN_SQUARE = $__138.OPEN_SQUARE, OR = $__138.OR, PACKAGE = $__138.PACKAGE, PERCENT = $__138.PERCENT, PERIOD = $__138.PERIOD, PLUS = $__138.PLUS, PLUS_PLUS = $__138.PLUS_PLUS, PRIVATE = $__138.PRIVATE, PROTECTED = $__138.PROTECTED, PUBLIC = $__138.PUBLIC, QUESTION = $__138.QUESTION, RETURN = $__138.RETURN, RIGHT_SHIFT = $__138.RIGHT_SHIFT, SEMI_COLON = $__138.SEMI_COLON, SLASH = $__138.SLASH, SLASH_EQUAL = $__138.SLASH_EQUAL, STAR = $__138.STAR, STATIC = $__138.STATIC, STRING = $__138.STRING, SUPER = $__138.SUPER, SWITCH = $__138.SWITCH, TEMPLATE_HEAD = $__138.TEMPLATE_HEAD, TEMPLATE_TAIL = $__138.TEMPLATE_TAIL, THIS = $__138.THIS, THROW = $__138.THROW, TILDE = $__138.TILDE, TRUE = $__138.TRUE, TRY = $__138.TRY, TYPEOF = $__138.TYPEOF, UNSIGNED_RIGHT_SHIFT = $__138.UNSIGNED_RIGHT_SHIFT, VAR = $__138.VAR, VOID = $__138.VOID, WHILE = $__138.WHILE, WITH = $__138.WITH, YIELD = $__138.YIELD; var $__139 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), ArgumentList = $__139.ArgumentList, ArrayComprehension = $__139.ArrayComprehension, ArrayLiteralExpression = $__139.ArrayLiteralExpression, ArrayPattern = $__139.ArrayPattern, ArrowFunctionExpression = $__139.ArrowFunctionExpression, AssignmentElement = $__139.AssignmentElement, AwaitExpression = $__139.AwaitExpression, BinaryExpression = $__139.BinaryExpression, BindingElement = $__139.BindingElement, BindingIdentifier = $__139.BindingIdentifier, Block = $__139.Block, BreakStatement = $__139.BreakStatement, CallExpression = $__139.CallExpression, CaseClause = $__139.CaseClause, Catch = $__139.Catch, ClassDeclaration = $__139.ClassDeclaration, ClassExpression = $__139.ClassExpression, CommaExpression = $__139.CommaExpression, ComprehensionFor = $__139.ComprehensionFor, ComprehensionIf = $__139.ComprehensionIf, ComputedPropertyName = $__139.ComputedPropertyName, ConditionalExpression = $__139.ConditionalExpression, ContinueStatement = $__139.ContinueStatement, CoverFormals = $__139.CoverFormals, CoverInitializedName = $__139.CoverInitializedName, DebuggerStatement = $__139.DebuggerStatement, Annotation = $__139.Annotation, DefaultClause = $__139.DefaultClause, DoWhileStatement = $__139.DoWhileStatement, EmptyStatement = $__139.EmptyStatement, ExportDeclaration = $__139.ExportDeclaration, ExportDefault = $__139.ExportDefault, ExportSpecifier = $__139.ExportSpecifier, ExportSpecifierSet = $__139.ExportSpecifierSet, ExportStar = $__139.ExportStar, ExpressionStatement = $__139.ExpressionStatement, Finally = $__139.Finally, ForInStatement = $__139.ForInStatement, ForOfStatement = $__139.ForOfStatement, ForStatement = $__139.ForStatement, FormalParameter = $__139.FormalParameter, FormalParameterList = $__139.FormalParameterList, FunctionBody = $__139.FunctionBody, FunctionDeclaration = $__139.FunctionDeclaration, FunctionExpression = $__139.FunctionExpression, GeneratorComprehension = $__139.GeneratorComprehension, GetAccessor = $__139.GetAccessor, IdentifierExpression = $__139.IdentifierExpression, IfStatement = $__139.IfStatement, ImportDeclaration = $__139.ImportDeclaration, ImportSpecifier = $__139.ImportSpecifier, ImportSpecifierSet = $__139.ImportSpecifierSet, ImportedBinding = $__139.ImportedBinding, LabelledStatement = $__139.LabelledStatement, LiteralExpression = $__139.LiteralExpression, LiteralPropertyName = $__139.LiteralPropertyName, MemberExpression = $__139.MemberExpression, MemberLookupExpression = $__139.MemberLookupExpression, Module = $__139.Module, ModuleDeclaration = $__139.ModuleDeclaration, ModuleSpecifier = $__139.ModuleSpecifier, NamedExport = $__139.NamedExport, NewExpression = $__139.NewExpression, ObjectLiteralExpression = $__139.ObjectLiteralExpression, ObjectPattern = $__139.ObjectPattern, ObjectPatternField = $__139.ObjectPatternField, ParenExpression = $__139.ParenExpression, PostfixExpression = $__139.PostfixExpression, PredefinedType = $__139.PredefinedType, Script = $__139.Script, PropertyMethodAssignment = $__139.PropertyMethodAssignment, PropertyNameAssignment = $__139.PropertyNameAssignment, PropertyNameShorthand = $__139.PropertyNameShorthand, RestParameter = $__139.RestParameter, ReturnStatement = $__139.ReturnStatement, SetAccessor = $__139.SetAccessor, SpreadExpression = $__139.SpreadExpression, SpreadPatternElement = $__139.SpreadPatternElement, SuperExpression = $__139.SuperExpression, SwitchStatement = $__139.SwitchStatement, SyntaxErrorTree = $__139.SyntaxErrorTree, TemplateLiteralExpression = $__139.TemplateLiteralExpression, TemplateLiteralPortion = $__139.TemplateLiteralPortion, TemplateSubstitution = $__139.TemplateSubstitution, ThisExpression = $__139.ThisExpression, ThrowStatement = $__139.ThrowStatement, TryStatement = $__139.TryStatement, TypeName = $__139.TypeName, UnaryExpression = $__139.UnaryExpression, VariableDeclaration = $__139.VariableDeclaration, VariableDeclarationList = $__139.VariableDeclarationList, VariableStatement = $__139.VariableStatement, WhileStatement = $__139.WhileStatement, WithStatement = $__139.WithStatement, YieldExpression = $__139.YieldExpression; var Expression = { NO_IN: 'NO_IN', NORMAL: 'NORMAL' }; var DestructuringInitializer = { REQUIRED: 'REQUIRED', OPTIONAL: 'OPTIONAL' }; var Initializer = { ALLOWED: 'ALLOWED', REQUIRED: 'REQUIRED' }; var ValidateObjectLiteral = function ValidateObjectLiteral(tree) { this.errorToken = null; $traceurRuntime.superCall(this, $ValidateObjectLiteral.prototype, "constructor", [tree]); }; var $ValidateObjectLiteral = ValidateObjectLiteral; ($traceurRuntime.createClass)(ValidateObjectLiteral, {visitCoverInitializedName: function(tree) { this.errorToken = tree.equalToken; this.found = true; }}, {}, FindVisitor); var Parser = function Parser(file) { var errorReporter = arguments[1] !== (void 0) ? arguments[1] : new SyntaxErrorReporter(); this.errorReporter_ = errorReporter; this.scanner_ = new Scanner(errorReporter, file, this); this.allowYield_ = false; this.allowAwait_ = false; this.coverInitializedNameCount_ = 0; this.strictMode_ = false; this.annotations_ = []; }; ($traceurRuntime.createClass)(Parser, { parseScript: function() { this.strictMode_ = false; var start = this.getTreeStartLocation_(); var scriptItemList = this.parseScriptItemList_(); this.eat_(END_OF_FILE); return new Script(this.getTreeLocation_(start), scriptItemList); }, parseScriptItemList_: function() { var result = []; var type; var checkUseStrictDirective = true; while ((type = this.peekType_()) !== END_OF_FILE) { var scriptItem = this.parseScriptItem_(type, false); if (checkUseStrictDirective) { if (!scriptItem.isDirectivePrologue()) { checkUseStrictDirective = false; } else if (scriptItem.isUseStrictDirective()) { this.strictMode_ = true; checkUseStrictDirective = false; } } result.push(scriptItem); } return result; }, parseScriptItem_: function(type, allowModuleItem) { return this.parseStatement_(type, allowModuleItem, true); }, parseModule: function() { var start = this.getTreeStartLocation_(); var scriptItemList = this.parseModuleItemList_(); this.eat_(END_OF_FILE); return new Module(this.getTreeLocation_(start), scriptItemList); }, parseModuleItemList_: function() { this.strictMode_ = true; var result = []; var type; while ((type = this.peekType_()) !== END_OF_FILE) { var scriptItem = this.parseScriptItem_(type, true); result.push(scriptItem); } return result; }, parseModuleSpecifier_: function() { var start = this.getTreeStartLocation_(); var token = this.eat_(STRING); return new ModuleSpecifier(this.getTreeLocation_(start), token); }, parseImportDeclaration_: function() { var start = this.getTreeStartLocation_(); this.eat_(IMPORT); var importClause = null; if (this.peekImportClause_(this.peekType_())) { importClause = this.parseImportClause_(); this.eatId_(FROM); } var moduleSpecifier = this.parseModuleSpecifier_(); this.eatPossibleImplicitSemiColon_(); return new ImportDeclaration(this.getTreeLocation_(start), importClause, moduleSpecifier); }, peekImportClause_: function(type) { return type === OPEN_CURLY || this.peekBindingIdentifier_(type); }, parseImportClause_: function() { var start = this.getTreeStartLocation_(); if (this.eatIf_(OPEN_CURLY)) { var specifiers = []; while (!this.peek_(CLOSE_CURLY) && !this.isAtEnd()) { specifiers.push(this.parseImportSpecifier_()); if (!this.eatIf_(COMMA)) break; } this.eat_(CLOSE_CURLY); return new ImportSpecifierSet(this.getTreeLocation_(start), specifiers); } var binding = this.parseBindingIdentifier_(); return new ImportedBinding(this.getTreeLocation_(start), binding); }, parseImportSpecifier_: function() { var start = this.getTreeStartLocation_(); var token = this.peekToken_(); var isKeyword = token.isKeyword(); var lhs = this.eatIdName_(); var rhs = null; if (isKeyword || this.peekPredefinedString_(AS)) { this.eatId_(AS); rhs = this.eatId_(); } return new ImportSpecifier(this.getTreeLocation_(start), lhs, rhs); }, parseExportDeclaration_: function() { var start = this.getTreeStartLocation_(); this.eat_(EXPORT); var exportTree; var annotations = this.popAnnotations_(); var type = this.peekType_(); switch (type) { case CONST: case LET: case VAR: exportTree = this.parseVariableStatement_(); break; case FUNCTION: exportTree = this.parseFunctionDeclaration_(); break; case CLASS: exportTree = this.parseClassDeclaration_(); break; case DEFAULT: exportTree = this.parseExportDefault_(); break; case OPEN_CURLY: case STAR: exportTree = this.parseNamedExport_(); break; case IDENTIFIER: if (options.asyncFunctions && this.peekPredefinedString_(ASYNC)) { var asyncToken = this.eatId_(); exportTree = this.parseAsyncFunctionDeclaration_(asyncToken); break; } default: return this.parseUnexpectedToken_(type); } return new ExportDeclaration(this.getTreeLocation_(start), exportTree, annotations); }, parseExportDefault_: function() { var start = this.getTreeStartLocation_(); this.eat_(DEFAULT); var exportValue; switch (this.peekType_()) { case FUNCTION: exportValue = this.parseFunctionDeclaration_(); break; case CLASS: if (parseOptions.classes) { exportValue = this.parseClassDeclaration_(); break; } default: exportValue = this.parseAssignmentExpression(); this.eatPossibleImplicitSemiColon_(); } return new ExportDefault(this.getTreeLocation_(start), exportValue); }, parseNamedExport_: function() { var start = this.getTreeStartLocation_(); var specifierSet, expression = null; if (this.peek_(OPEN_CURLY)) { specifierSet = this.parseExportSpecifierSet_(); if (this.peekPredefinedString_(FROM)) { this.eatId_(FROM); expression = this.parseModuleSpecifier_(); } else { this.validateExportSpecifierSet_(specifierSet); } } else { this.eat_(STAR); specifierSet = new ExportStar(this.getTreeLocation_(start)); this.eatId_(FROM); expression = this.parseModuleSpecifier_(); } this.eatPossibleImplicitSemiColon_(); return new NamedExport(this.getTreeLocation_(start), expression, specifierSet); }, parseExportSpecifierSet_: function() { var start = this.getTreeStartLocation_(); this.eat_(OPEN_CURLY); var specifiers = [this.parseExportSpecifier_()]; while (this.eatIf_(COMMA)) { if (this.peek_(CLOSE_CURLY)) break; specifiers.push(this.parseExportSpecifier_()); } this.eat_(CLOSE_CURLY); return new ExportSpecifierSet(this.getTreeLocation_(start), specifiers); }, parseExportSpecifier_: function() { var start = this.getTreeStartLocation_(); var lhs = this.eatIdName_(); var rhs = null; if (this.peekPredefinedString_(AS)) { this.eatId_(); rhs = this.eatIdName_(); } return new ExportSpecifier(this.getTreeLocation_(start), lhs, rhs); }, validateExportSpecifierSet_: function(tree) { for (var i = 0; i < tree.specifiers.length; i++) { var specifier = tree.specifiers[i]; if (getKeywordType(specifier.lhs.value)) { this.reportError_(specifier.lhs.location, ("Unexpected token " + specifier.lhs.value)); } } }, peekId_: function(type) { if (type === IDENTIFIER) return true; if (this.strictMode_) return false; return this.peekToken_().isStrictKeyword(); }, peekIdName_: function(token) { return token.type === IDENTIFIER || token.isKeyword(); }, parseClassShared_: function(constr) { var start = this.getTreeStartLocation_(); var strictMode = this.strictMode_; this.strictMode_ = true; this.eat_(CLASS); var name = null; var annotations = []; if (constr == ClassDeclaration || !this.peek_(EXTENDS) && !this.peek_(OPEN_CURLY)) { name = this.parseBindingIdentifier_(); annotations = this.popAnnotations_(); } var superClass = null; if (this.eatIf_(EXTENDS)) { superClass = this.parseAssignmentExpression(); } this.eat_(OPEN_CURLY); var elements = this.parseClassElements_(); this.eat_(CLOSE_CURLY); this.strictMode_ = strictMode; return new constr(this.getTreeLocation_(start), name, superClass, elements, annotations); }, parseClassDeclaration_: function() { return this.parseClassShared_(ClassDeclaration); }, parseClassExpression_: function() { return this.parseClassShared_(ClassExpression); }, parseClassElements_: function() { var result = []; while (true) { var type = this.peekType_(); if (type === SEMI_COLON) { this.nextToken_(); } else if (this.peekClassElement_(this.peekType_())) { result.push(this.parseClassElement_()); } else { break; } } return result; }, peekClassElement_: function(type) { return this.peekPropertyName_(type) || type === STAR && parseOptions.generators || type === AT && parseOptions.annotations; }, parsePropertyName_: function() { if (this.peek_(OPEN_SQUARE)) return this.parseComputedPropertyName_(); return this.parseLiteralPropertyName_(); }, parseLiteralPropertyName_: function() { var start = this.getTreeStartLocation_(); var token = this.nextToken_(); return new LiteralPropertyName(this.getTreeLocation_(start), token); }, parseComputedPropertyName_: function() { var start = this.getTreeStartLocation_(); this.eat_(OPEN_SQUARE); var expression = this.parseAssignmentExpression(); this.eat_(CLOSE_SQUARE); return new ComputedPropertyName(this.getTreeLocation_(start), expression); }, parseStatement: function() { return this.parseStatement_(this.peekType_(), false, false); }, parseStatement_: function(type, allowModuleItem, allowScriptItem) { switch (type) { case RETURN: return this.parseReturnStatement_(); case CONST: case LET: if (!parseOptions.blockBinding) break; case VAR: return this.parseVariableStatement_(); case IF: return this.parseIfStatement_(); case FOR: return this.parseForStatement_(); case BREAK: return this.parseBreakStatement_(); case SWITCH: return this.parseSwitchStatement_(); case THROW: return this.parseThrowStatement_(); case WHILE: return this.parseWhileStatement_(); case FUNCTION: return this.parseFunctionDeclaration_(); case AT: if (parseOptions.annotations) return this.parseAnnotatedDeclarations_(allowModuleItem, allowScriptItem); break; case CLASS: if (parseOptions.classes) return this.parseClassDeclaration_(); break; case CONTINUE: return this.parseContinueStatement_(); case DEBUGGER: return this.parseDebuggerStatement_(); case DO: return this.parseDoWhileStatement_(); case EXPORT: if (allowModuleItem && parseOptions.modules) return this.parseExportDeclaration_(); break; case IMPORT: if (allowScriptItem && parseOptions.modules) return this.parseImportDeclaration_(); break; case OPEN_CURLY: return this.parseBlock_(); case SEMI_COLON: return this.parseEmptyStatement_(); case TRY: return this.parseTryStatement_(); case WITH: return this.parseWithStatement_(); } return this.parseFallThroughStatement_(allowScriptItem); }, parseFunctionDeclaration_: function() { return this.parseFunction_(FunctionDeclaration); }, parseFunctionExpression_: function() { return this.parseFunction_(FunctionExpression); }, parseAsyncFunctionDeclaration_: function(asyncToken) { return this.parseAsyncFunction_(asyncToken, FunctionDeclaration); }, parseAsyncFunctionExpression_: function(asyncToken) { return this.parseAsyncFunction_(asyncToken, FunctionExpression); }, parseAsyncFunction_: function(asyncToken, ctor) { var start = asyncToken.location.start; this.eat_(FUNCTION); return this.parseFunction2_(start, asyncToken, ctor); }, parseFunction_: function(ctor) { var start = this.getTreeStartLocation_(); this.eat_(FUNCTION); var functionKind = null; if (parseOptions.generators && this.peek_(STAR)) functionKind = this.eat_(STAR); return this.parseFunction2_(start, functionKind, ctor); }, parseFunction2_: function(start, functionKind, ctor) { var name = null; var annotations = []; if (ctor === FunctionDeclaration || this.peekBindingIdentifier_(this.peekType_())) { name = this.parseBindingIdentifier_(); annotations = this.popAnnotations_(); } this.eat_(OPEN_PAREN); var parameters = this.parseFormalParameters_(); this.eat_(CLOSE_PAREN); var typeAnnotation = this.parseTypeAnnotationOpt_(); var body = this.parseFunctionBody_(functionKind, parameters); return new ctor(this.getTreeLocation_(start), name, functionKind, parameters, typeAnnotation, annotations, body); }, peekRest_: function(type) { return type === DOT_DOT_DOT && parseOptions.restParameters; }, parseFormalParameters_: function() { var start = this.getTreeStartLocation_(); var formals = []; this.pushAnnotations_(); var type = this.peekType_(); if (this.peekRest_(type)) { formals.push(this.parseFormalRestParameter_()); } else { if (this.peekFormalParameter_(this.peekType_())) formals.push(this.parseFormalParameter_()); while (this.eatIf_(COMMA)) { this.pushAnnotations_(); if (this.peekRest_(this.peekType_())) { formals.push(this.parseFormalRestParameter_()); break; } formals.push(this.parseFormalParameter_()); } } return new FormalParameterList(this.getTreeLocation_(start), formals); }, peekFormalParameter_: function(type) { return this.peekBindingElement_(type); }, parseFormalParameter_: function() { var initializerAllowed = arguments[0]; var start = this.getTreeStartLocation_(); var binding = this.parseBindingElementBinding_(); var typeAnnotation = this.parseTypeAnnotationOpt_(); var initializer = this.parseBindingElementInitializer_(initializerAllowed); return new FormalParameter(this.getTreeLocation_(start), new BindingElement(this.getTreeLocation_(start), binding, initializer), typeAnnotation, this.popAnnotations_()); }, parseFormalRestParameter_: function() { var start = this.getTreeStartLocation_(); var restParameter = this.parseRestParameter_(); var typeAnnotation = this.parseTypeAnnotationOpt_(); return new FormalParameter(this.getTreeLocation_(start), restParameter, typeAnnotation, this.popAnnotations_()); }, parseRestParameter_: function() { var start = this.getTreeStartLocation_(); this.eat_(DOT_DOT_DOT); var id = this.parseBindingIdentifier_(); return new RestParameter(this.getTreeLocation_(start), id); }, parseFunctionBody_: function(functionKind, params) { var start = this.getTreeStartLocation_(); this.eat_(OPEN_CURLY); var allowYield = this.allowYield_; var allowAwait = this.allowAwait_; var strictMode = this.strictMode_; this.allowYield_ = functionKind && functionKind.type === STAR; this.allowAwait_ = functionKind && functionKind.type === IDENTIFIER && functionKind.value === ASYNC; var result = this.parseStatementList_(!strictMode); if (!strictMode && this.strictMode_ && params) StrictParams.visit(params, this.errorReporter_); this.strictMode_ = strictMode; this.allowYield_ = allowYield; this.allowAwait_ = allowAwait; this.eat_(CLOSE_CURLY); return new FunctionBody(this.getTreeLocation_(start), result); }, parseStatements: function() { return this.parseStatementList_(false); }, parseStatementList_: function(checkUseStrictDirective) { var result = []; var type; while ((type = this.peekType_()) !== CLOSE_CURLY && type !== END_OF_FILE) { var statement = this.parseStatement_(type, false, false); if (checkUseStrictDirective) { if (!statement.isDirectivePrologue()) { checkUseStrictDirective = false; } else if (statement.isUseStrictDirective()) { this.strictMode_ = true; checkUseStrictDirective = false; } } result.push(statement); } return result; }, parseSpreadExpression_: function() { if (!parseOptions.spread) return this.parseUnexpectedToken_(DOT_DOT_DOT); var start = this.getTreeStartLocation_(); this.eat_(DOT_DOT_DOT); var operand = this.parseAssignmentExpression(); return new SpreadExpression(this.getTreeLocation_(start), operand); }, parseBlock_: function() { var start = this.getTreeStartLocation_(); this.eat_(OPEN_CURLY); var result = this.parseStatementList_(false); this.eat_(CLOSE_CURLY); return new Block(this.getTreeLocation_(start), result); }, parseVariableStatement_: function() { var start = this.getTreeStartLocation_(); var declarations = this.parseVariableDeclarationList_(); this.checkInitializers_(declarations); this.eatPossibleImplicitSemiColon_(); return new VariableStatement(this.getTreeLocation_(start), declarations); }, parseVariableDeclarationList_: function() { var expressionIn = arguments[0] !== (void 0) ? arguments[0] : Expression.NORMAL; var initializer = arguments[1] !== (void 0) ? arguments[1] : DestructuringInitializer.REQUIRED; var type = this.peekType_(); switch (type) { case CONST: case LET: if (!parseOptions.blockBinding) debugger; case VAR: this.nextToken_(); break; default: throw Error('unreachable'); } var start = this.getTreeStartLocation_(); var declarations = []; declarations.push(this.parseVariableDeclaration_(type, expressionIn, initializer)); while (this.eatIf_(COMMA)) { declarations.push(this.parseVariableDeclaration_(type, expressionIn, initializer)); } return new VariableDeclarationList(this.getTreeLocation_(start), type, declarations); }, parseVariableDeclaration_: function(binding, expressionIn) { var initializer = arguments[2] !== (void 0) ? arguments[2] : DestructuringInitializer.REQUIRED; var initRequired = initializer !== DestructuringInitializer.OPTIONAL; var start = this.getTreeStartLocation_(); var lvalue; var typeAnnotation; if (this.peekPattern_(this.peekType_())) { lvalue = this.parseBindingPattern_(); typeAnnotation = null; } else { lvalue = this.parseBindingIdentifier_(); typeAnnotation = this.parseTypeAnnotationOpt_(); } var initializer = null; if (this.peek_(EQUAL)) initializer = this.parseInitializer_(expressionIn); else if (lvalue.isPattern() && initRequired) this.reportError_('destructuring must have an initializer'); return new VariableDeclaration(this.getTreeLocation_(start), lvalue, typeAnnotation, initializer); }, parseInitializer_: function(expressionIn) { this.eat_(EQUAL); return this.parseAssignmentExpression(expressionIn); }, parseInitializerOpt_: function(expressionIn) { if (this.eatIf_(EQUAL)) return this.parseAssignmentExpression(expressionIn); return null; }, parseEmptyStatement_: function() { var start = this.getTreeStartLocation_(); this.eat_(SEMI_COLON); return new EmptyStatement(this.getTreeLocation_(start)); }, parseFallThroughStatement_: function(allowScriptItem) { var start = this.getTreeStartLocation_(); var expression; if (parseOptions.asyncFunctions && this.peekPredefinedString_(ASYNC) && this.peek_(FUNCTION, 1)) { var asyncToken = this.eatId_(); var functionToken = this.peekTokenNoLineTerminator_(); if (functionToken !== null) return this.parseAsyncFunctionDeclaration_(asyncToken); expression = new IdentifierExpression(this.getTreeLocation_(start), asyncToken); } else { expression = this.parseExpression(); } if (expression.type === IDENTIFIER_EXPRESSION) { var nameToken = expression.identifierToken; if (this.eatIf_(COLON)) { var statement = this.parseStatement(); return new LabelledStatement(this.getTreeLocation_(start), nameToken, statement); } if (allowScriptItem && nameToken.value === MODULE && parseOptions.modules) { var token = this.peekTokenNoLineTerminator_(); if (token !== null && token.type === IDENTIFIER) { var name = this.eatId_(); this.eatId_(FROM); var moduleSpecifier = this.parseModuleSpecifier_(); this.eatPossibleImplicitSemiColon_(); return new ModuleDeclaration(this.getTreeLocation_(start), name, moduleSpecifier); } } } this.eatPossibleImplicitSemiColon_(); return new ExpressionStatement(this.getTreeLocation_(start), expression); }, parseIfStatement_: function() { var start = this.getTreeStartLocation_(); this.eat_(IF); this.eat_(OPEN_PAREN); var condition = this.parseExpression(); this.eat_(CLOSE_PAREN); var ifClause = this.parseStatement(); var elseClause = null; if (this.eatIf_(ELSE)) { elseClause = this.parseStatement(); } return new IfStatement(this.getTreeLocation_(start), condition, ifClause, elseClause); }, parseDoWhileStatement_: function() { var start = this.getTreeStartLocation_(); this.eat_(DO); var body = this.parseStatement(); this.eat_(WHILE); this.eat_(OPEN_PAREN); var condition = this.parseExpression(); this.eat_(CLOSE_PAREN); this.eatPossibleImplicitSemiColon_(); return new DoWhileStatement(this.getTreeLocation_(start), body, condition); }, parseWhileStatement_: function() { var start = this.getTreeStartLocation_(); this.eat_(WHILE); this.eat_(OPEN_PAREN); var condition = this.parseExpression(); this.eat_(CLOSE_PAREN); var body = this.parseStatement(); return new WhileStatement(this.getTreeLocation_(start), condition, body); }, parseForStatement_: function() { var $__140 = this; var start = this.getTreeStartLocation_(); this.eat_(FOR); this.eat_(OPEN_PAREN); var validate = (function(variables, kind) { if (variables.declarations.length > 1) { $__140.reportError_(kind + ' statement may not have more than one variable declaration'); } var declaration = variables.declarations[0]; if (declaration.lvalue.isPattern() && declaration.initializer) { $__140.reportError_(declaration.initializer.location, ("initializer is not allowed in " + kind + " loop with pattern")); } }); var type = this.peekType_(); if (this.peekVariableDeclarationList_(type)) { var variables = this.parseVariableDeclarationList_(Expression.NO_IN, DestructuringInitializer.OPTIONAL); type = this.peekType_(); if (type === IN) { validate(variables, 'for-in'); var declaration = variables.declarations[0]; if (parseOptions.blockBinding && (variables.declarationType == LET || variables.declarationType == CONST)) { if (declaration.initializer != null) { this.reportError_('let/const in for-in statement may not have initializer'); } } return this.parseForInStatement_(start, variables); } else if (this.peekOf_(type)) { validate(variables, 'for-of'); var declaration = variables.declarations[0]; if (declaration.initializer != null) { this.reportError_('for-of statement may not have initializer'); } return this.parseForOfStatement_(start, variables); } else { this.checkInitializers_(variables); return this.parseForStatement2_(start, variables); } } if (type === SEMI_COLON) { return this.parseForStatement2_(start, null); } var coverInitializedNameCount = this.coverInitializedNameCount_; var initializer = this.parseExpressionAllowPattern_(Expression.NO_IN); type = this.peekType_(); if (initializer.isLeftHandSideExpression() && (type === IN || this.peekOf_(type))) { initializer = this.transformLeftHandSideExpression_(initializer); if (this.peekOf_(type)) return this.parseForOfStatement_(start, initializer); return this.parseForInStatement_(start, initializer); } this.ensureNoCoverInitializedNames_(initializer, coverInitializedNameCount); return this.parseForStatement2_(start, initializer); }, peekOf_: function(type) { return type === IDENTIFIER && parseOptions.forOf && this.peekToken_().value === OF; }, parseForOfStatement_: function(start, initializer) { this.eatId_(); var collection = this.parseExpression(); this.eat_(CLOSE_PAREN); var body = this.parseStatement(); return new ForOfStatement(this.getTreeLocation_(start), initializer, collection, body); }, checkInitializers_: function(variables) { if (parseOptions.blockBinding && variables.declarationType == CONST) { var type = variables.declarationType; for (var i = 0; i < variables.declarations.length; i++) { if (!this.checkInitializer_(type, variables.declarations[i])) { break; } } } }, checkInitializer_: function(type, declaration) { if (parseOptions.blockBinding && type == CONST && declaration.initializer == null) { this.reportError_('const variables must have an initializer'); return false; } return true; }, peekVariableDeclarationList_: function(type) { switch (type) { case VAR: return true; case CONST: case LET: return parseOptions.blockBinding; default: return false; } }, parseForStatement2_: function(start, initializer) { this.eat_(SEMI_COLON); var condition = null; if (!this.peek_(SEMI_COLON)) { condition = this.parseExpression(); } this.eat_(SEMI_COLON); var increment = null; if (!this.peek_(CLOSE_PAREN)) { increment = this.parseExpression(); } this.eat_(CLOSE_PAREN); var body = this.parseStatement(); return new ForStatement(this.getTreeLocation_(start), initializer, condition, increment, body); }, parseForInStatement_: function(start, initializer) { this.eat_(IN); var collection = this.parseExpression(); this.eat_(CLOSE_PAREN); var body = this.parseStatement(); return new ForInStatement(this.getTreeLocation_(start), initializer, collection, body); }, parseContinueStatement_: function() { var start = this.getTreeStartLocation_(); this.eat_(CONTINUE); var name = null; if (!this.peekImplicitSemiColon_(this.peekType_())) { name = this.eatIdOpt_(); } this.eatPossibleImplicitSemiColon_(); return new ContinueStatement(this.getTreeLocation_(start), name); }, parseBreakStatement_: function() { var start = this.getTreeStartLocation_(); this.eat_(BREAK); var name = null; if (!this.peekImplicitSemiColon_(this.peekType_())) { name = this.eatIdOpt_(); } this.eatPossibleImplicitSemiColon_(); return new BreakStatement(this.getTreeLocation_(start), name); }, parseReturnStatement_: function() { var start = this.getTreeStartLocation_(); this.eat_(RETURN); var expression = null; if (!this.peekImplicitSemiColon_(this.peekType_())) { expression = this.parseExpression(); } this.eatPossibleImplicitSemiColon_(); return new ReturnStatement(this.getTreeLocation_(start), expression); }, parseYieldExpression_: function() { var start = this.getTreeStartLocation_(); this.eat_(YIELD); var expression = null; var isYieldFor = false; if (!this.peekImplicitSemiColon_(this.peekType_())) { isYieldFor = this.eatIf_(STAR); expression = this.parseAssignmentExpression(); } return new YieldExpression(this.getTreeLocation_(start), expression, isYieldFor); }, parseWithStatement_: function() { if (this.strictMode_) this.reportError_('Strict mode code may not include a with statement'); var start = this.getTreeStartLocation_(); this.eat_(WITH); this.eat_(OPEN_PAREN); var expression = this.parseExpression(); this.eat_(CLOSE_PAREN); var body = this.parseStatement(); return new WithStatement(this.getTreeLocation_(start), expression, body); }, parseSwitchStatement_: function() { var start = this.getTreeStartLocation_(); this.eat_(SWITCH); this.eat_(OPEN_PAREN); var expression = this.parseExpression(); this.eat_(CLOSE_PAREN); this.eat_(OPEN_CURLY); var caseClauses = this.parseCaseClauses_(); this.eat_(CLOSE_CURLY); return new SwitchStatement(this.getTreeLocation_(start), expression, caseClauses); }, parseCaseClauses_: function() { var foundDefaultClause = false; var result = []; while (true) { var start = this.getTreeStartLocation_(); switch (this.peekType_()) { case CASE: this.nextToken_(); var expression = this.parseExpression(); this.eat_(COLON); var statements = this.parseCaseStatementsOpt_(); result.push(new CaseClause(this.getTreeLocation_(start), expression, statements)); break; case DEFAULT: if (foundDefaultClause) { this.reportError_('Switch statements may have at most one default clause'); } else { foundDefaultClause = true; } this.nextToken_(); this.eat_(COLON); result.push(new DefaultClause(this.getTreeLocation_(start), this.parseCaseStatementsOpt_())); break; default: return result; } } }, parseCaseStatementsOpt_: function() { var result = []; var type; while (true) { switch (type = this.peekType_()) { case CASE: case DEFAULT: case CLOSE_CURLY: case END_OF_FILE: return result; } result.push(this.parseStatement_(type, false, false)); } }, parseThrowStatement_: function() { var start = this.getTreeStartLocation_(); this.eat_(THROW); var value = null; if (!this.peekImplicitSemiColon_(this.peekType_())) { value = this.parseExpression(); } this.eatPossibleImplicitSemiColon_(); return new ThrowStatement(this.getTreeLocation_(start), value); }, parseTryStatement_: function() { var start = this.getTreeStartLocation_(); this.eat_(TRY); var body = this.parseBlock_(); var catchBlock = null; if (this.peek_(CATCH)) { catchBlock = this.parseCatch_(); } var finallyBlock = null; if (this.peek_(FINALLY)) { finallyBlock = this.parseFinallyBlock_(); } if (catchBlock == null && finallyBlock == null) { this.reportError_("'catch' or 'finally' expected."); } return new TryStatement(this.getTreeLocation_(start), body, catchBlock, finallyBlock); }, parseCatch_: function() { var start = this.getTreeStartLocation_(); var catchBlock; this.eat_(CATCH); this.eat_(OPEN_PAREN); var binding; if (this.peekPattern_(this.peekType_())) binding = this.parseBindingPattern_(); else binding = this.parseBindingIdentifier_(); this.eat_(CLOSE_PAREN); var catchBody = this.parseBlock_(); catchBlock = new Catch(this.getTreeLocation_(start), binding, catchBody); return catchBlock; }, parseFinallyBlock_: function() { var start = this.getTreeStartLocation_(); this.eat_(FINALLY); var finallyBlock = this.parseBlock_(); return new Finally(this.getTreeLocation_(start), finallyBlock); }, parseDebuggerStatement_: function() { var start = this.getTreeStartLocation_(); this.eat_(DEBUGGER); this.eatPossibleImplicitSemiColon_(); return new DebuggerStatement(this.getTreeLocation_(start)); }, parsePrimaryExpression_: function() { switch (this.peekType_()) { case CLASS: return parseOptions.classes ? this.parseClassExpression_() : this.parseSyntaxError_('Unexpected reserved word'); case THIS: return this.parseThisExpression_(); case IDENTIFIER: var identifier = this.parseIdentifierExpression_(); if (parseOptions.asyncFunctions && identifier.identifierToken.value === ASYNC) { var token = this.peekTokenNoLineTerminator_(); if (token && token.type === FUNCTION) { var asyncToken = identifier.identifierToken; return this.parseAsyncFunctionExpression_(asyncToken); } } return identifier; case NUMBER: case STRING: case TRUE: case FALSE: case NULL: return this.parseLiteralExpression_(); case OPEN_SQUARE: return this.parseArrayLiteral_(); case OPEN_CURLY: return this.parseObjectLiteral_(); case OPEN_PAREN: return this.parsePrimaryExpressionStartingWithParen_(); case SLASH: case SLASH_EQUAL: return this.parseRegularExpressionLiteral_(); case NO_SUBSTITUTION_TEMPLATE: case TEMPLATE_HEAD: return this.parseTemplateLiteral_(null); case IMPLEMENTS: case INTERFACE: case PACKAGE: case PRIVATE: case PROTECTED: case PUBLIC: case STATIC: case YIELD: if (!this.strictMode_) return this.parseIdentifierExpression_(); this.reportReservedIdentifier_(this.nextToken_()); case END_OF_FILE: return this.parseSyntaxError_('Unexpected end of input'); default: return this.parseUnexpectedToken_(this.peekToken_()); } }, parseSuperExpression_: function() { var start = this.getTreeStartLocation_(); this.eat_(SUPER); return new SuperExpression(this.getTreeLocation_(start)); }, parseThisExpression_: function() { var start = this.getTreeStartLocation_(); this.eat_(THIS); return new ThisExpression(this.getTreeLocation_(start)); }, peekBindingIdentifier_: function(type) { return this.peekId_(type); }, parseBindingIdentifier_: function() { var start = this.getTreeStartLocation_(); var identifier = this.eatId_(); return new BindingIdentifier(this.getTreeLocation_(start), identifier); }, parseIdentifierExpression_: function() { var start = this.getTreeStartLocation_(); var identifier = this.eatId_(); return new IdentifierExpression(this.getTreeLocation_(start), identifier); }, parseIdentifierNameExpression_: function() { var start = this.getTreeStartLocation_(); var identifier = this.eatIdName_(); return new IdentifierExpression(this.getTreeLocation_(start), identifier); }, parseLiteralExpression_: function() { var start = this.getTreeStartLocation_(); var literal = this.nextLiteralToken_(); return new LiteralExpression(this.getTreeLocation_(start), literal); }, nextLiteralToken_: function() { return this.nextToken_(); }, parseRegularExpressionLiteral_: function() { var start = this.getTreeStartLocation_(); var literal = this.nextRegularExpressionLiteralToken_(); return new LiteralExpression(this.getTreeLocation_(start), literal); }, peekSpread_: function(type) { return type === DOT_DOT_DOT && parseOptions.spread; }, parseArrayLiteral_: function() { var start = this.getTreeStartLocation_(); var expression; var elements = []; this.eat_(OPEN_SQUARE); var type = this.peekType_(); if (type === FOR && parseOptions.arrayComprehension) return this.parseArrayComprehension_(start); while (true) { type = this.peekType_(); if (type === COMMA) { expression = null; } else if (this.peekSpread_(type)) { expression = this.parseSpreadExpression_(); } else if (this.peekAssignmentExpression_(type)) { expression = this.parseAssignmentExpression(); } else { break; } elements.push(expression); type = this.peekType_(); if (type !== CLOSE_SQUARE) this.eat_(COMMA); } this.eat_(CLOSE_SQUARE); return new ArrayLiteralExpression(this.getTreeLocation_(start), elements); }, parseArrayComprehension_: function(start) { var list = this.parseComprehensionList_(); var expression = this.parseAssignmentExpression(); this.eat_(CLOSE_SQUARE); return new ArrayComprehension(this.getTreeLocation_(start), list, expression); }, parseComprehensionList_: function() { var list = [this.parseComprehensionFor_()]; while (true) { var type = this.peekType_(); switch (type) { case FOR: list.push(this.parseComprehensionFor_()); break; case IF: list.push(this.parseComprehensionIf_()); break; default: return list; } } }, parseComprehensionFor_: function() { var start = this.getTreeStartLocation_(); this.eat_(FOR); this.eat_(OPEN_PAREN); var left = this.parseForBinding_(); this.eatId_(OF); var iterator = this.parseExpression(); this.eat_(CLOSE_PAREN); return new ComprehensionFor(this.getTreeLocation_(start), left, iterator); }, parseComprehensionIf_: function() { var start = this.getTreeStartLocation_(); this.eat_(IF); this.eat_(OPEN_PAREN); var expression = this.parseExpression(); this.eat_(CLOSE_PAREN); return new ComprehensionIf(this.getTreeLocation_(start), expression); }, parseObjectLiteral_: function() { var start = this.getTreeStartLocation_(); var result = []; this.eat_(OPEN_CURLY); while (this.peekPropertyDefinition_(this.peekType_())) { var propertyDefinition = this.parsePropertyDefinition(); result.push(propertyDefinition); if (!this.eatIf_(COMMA)) break; } this.eat_(CLOSE_CURLY); return new ObjectLiteralExpression(this.getTreeLocation_(start), result); }, parsePropertyDefinition: function() { var start = this.getTreeStartLocation_(); var functionKind = null; var isStatic = false; if (parseOptions.generators && parseOptions.propertyMethods && this.peek_(STAR)) { return this.parseGeneratorMethod_(start, isStatic, []); } var token = this.peekToken_(); var name = this.parsePropertyName_(); if (parseOptions.propertyMethods && this.peek_(OPEN_PAREN)) return this.parseMethod_(start, isStatic, functionKind, name, []); if (this.eatIf_(COLON)) { var value = this.parseAssignmentExpression(); return new PropertyNameAssignment(this.getTreeLocation_(start), name, value); } var type = this.peekType_(); if (name.type === LITERAL_PROPERTY_NAME) { var nameLiteral = name.literalToken; if (nameLiteral.value === GET && this.peekPropertyName_(type)) { return this.parseGetAccessor_(start, isStatic, []); } if (nameLiteral.value === SET && this.peekPropertyName_(type)) { return this.parseSetAccessor_(start, isStatic, []); } if (parseOptions.asyncFunctions && nameLiteral.value === ASYNC && this.peekPropertyName_(type)) { var async = nameLiteral; var name = this.parsePropertyName_(); return this.parseMethod_(start, isStatic, async, name, []); } if (parseOptions.propertyNameShorthand && nameLiteral.type === IDENTIFIER || !this.strictMode_ && nameLiteral.type === YIELD) { if (this.peek_(EQUAL)) { token = this.nextToken_(); var coverInitializedNameCount = this.coverInitializedNameCount_; var expr = this.parseAssignmentExpression(); this.ensureNoCoverInitializedNames_(expr, coverInitializedNameCount); this.coverInitializedNameCount_++; return new CoverInitializedName(this.getTreeLocation_(start), nameLiteral, token, expr); } if (nameLiteral.type === YIELD) nameLiteral = new IdentifierToken(nameLiteral.location, YIELD); return new PropertyNameShorthand(this.getTreeLocation_(start), nameLiteral); } if (this.strictMode_ && nameLiteral.isStrictKeyword()) this.reportReservedIdentifier_(nameLiteral); } if (name.type === COMPUTED_PROPERTY_NAME) token = this.peekToken_(); return this.parseUnexpectedToken_(token); }, parseClassElement_: function() { var start = this.getTreeStartLocation_(); var annotations = this.parseAnnotations_(); var type = this.peekType_(); var isStatic = false, functionKind = null; switch (type) { case STATIC: var staticToken = this.nextToken_(); type = this.peekType_(); switch (type) { case OPEN_PAREN: var name = new LiteralPropertyName(start, staticToken); return this.parseMethod_(start, isStatic, functionKind, name, annotations); default: isStatic = true; if (type === STAR && parseOptions.generators) return this.parseGeneratorMethod_(start, true, annotations); return this.parseGetSetOrMethod_(start, isStatic, annotations); } break; case STAR: return this.parseGeneratorMethod_(start, isStatic, annotations); default: return this.parseGetSetOrMethod_(start, isStatic, annotations); } }, parseGeneratorMethod_: function(start, isStatic, annotations) { var functionKind = this.eat_(STAR); var name = this.parsePropertyName_(); return this.parseMethod_(start, isStatic, functionKind, name, annotations); }, parseMethod_: function(start, isStatic, functionKind, name, annotations) { this.eat_(OPEN_PAREN); var parameterList = this.parseFormalParameters_(); this.eat_(CLOSE_PAREN); var typeAnnotation = this.parseTypeAnnotationOpt_(); var body = this.parseFunctionBody_(functionKind, parameterList); return new PropertyMethodAssignment(this.getTreeLocation_(start), isStatic, functionKind, name, parameterList, typeAnnotation, annotations, body); }, parseGetSetOrMethod_: function(start, isStatic, annotations) { var functionKind = null; var name = this.parsePropertyName_(); var type = this.peekType_(); if (name.type === LITERAL_PROPERTY_NAME && name.literalToken.value === GET && this.peekPropertyName_(type)) { return this.parseGetAccessor_(start, isStatic, annotations); } if (name.type === LITERAL_PROPERTY_NAME && name.literalToken.value === SET && this.peekPropertyName_(type)) { return this.parseSetAccessor_(start, isStatic, annotations); } if (parseOptions.asyncFunctions && name.type === LITERAL_PROPERTY_NAME && name.literalToken.value === ASYNC && this.peekPropertyName_(type)) { var async = name.literalToken; var name = this.parsePropertyName_(); return this.parseMethod_(start, isStatic, async, name, annotations); } return this.parseMethod_(start, isStatic, functionKind, name, annotations); }, parseGetAccessor_: function(start, isStatic, annotations) { var functionKind = null; var name = this.parsePropertyName_(); this.eat_(OPEN_PAREN); this.eat_(CLOSE_PAREN); var typeAnnotation = this.parseTypeAnnotationOpt_(); var body = this.parseFunctionBody_(functionKind, null); return new GetAccessor(this.getTreeLocation_(start), isStatic, name, typeAnnotation, annotations, body); }, parseSetAccessor_: function(start, isStatic, annotations) { var functionKind = null; var name = this.parsePropertyName_(); this.eat_(OPEN_PAREN); var parameterList = this.parsePropertySetParameterList_(); this.eat_(CLOSE_PAREN); var body = this.parseFunctionBody_(functionKind, parameterList); return new SetAccessor(this.getTreeLocation_(start), isStatic, name, parameterList, annotations, body); }, peekPropertyDefinition_: function(type) { return this.peekPropertyName_(type) || type == STAR && parseOptions.propertyMethods && parseOptions.generators; }, peekPropertyName_: function(type) { switch (type) { case IDENTIFIER: case STRING: case NUMBER: return true; case OPEN_SQUARE: return parseOptions.computedPropertyNames; default: return this.peekToken_().isKeyword(); } }, peekPredefinedString_: function(string) { var token = this.peekToken_(); return token.type === IDENTIFIER && token.value === string; }, parsePropertySetParameterList_: function() { var start = this.getTreeStartLocation_(); var binding; this.pushAnnotations_(); if (this.peekPattern_(this.peekType_())) binding = this.parseBindingPattern_(); else binding = this.parseBindingIdentifier_(); var typeAnnotation = this.parseTypeAnnotationOpt_(); var parameter = new FormalParameter(this.getTreeLocation_(start), new BindingElement(this.getTreeLocation_(start), binding, null), typeAnnotation, this.popAnnotations_()); return new FormalParameterList(parameter.location, [parameter]); }, parsePrimaryExpressionStartingWithParen_: function() { var start = this.getTreeStartLocation_(); this.eat_(OPEN_PAREN); if (this.peek_(FOR) && parseOptions.generatorComprehension) return this.parseGeneratorComprehension_(start); return this.parseCoverFormals_(start); }, parseSyntaxError_: function(message) { var start = this.getTreeStartLocation_(); this.reportError_(message); var token = this.nextToken_(); return new SyntaxErrorTree(this.getTreeLocation_(start), token, message); }, parseUnexpectedToken_: function(name) { return this.parseSyntaxError_(("Unexpected token " + name)); }, peekExpression_: function(type) { switch (type) { case NO_SUBSTITUTION_TEMPLATE: case TEMPLATE_HEAD: return parseOptions.templateLiterals; case BANG: case CLASS: case DELETE: case FALSE: case FUNCTION: case IDENTIFIER: case MINUS: case MINUS_MINUS: case NEW: case NULL: case NUMBER: case OPEN_CURLY: case OPEN_PAREN: case OPEN_SQUARE: case PLUS: case PLUS_PLUS: case SLASH: case SLASH_EQUAL: case STRING: case SUPER: case THIS: case TILDE: case TRUE: case TYPEOF: case VOID: case YIELD: return true; default: return false; } }, parseExpression: function() { var expressionIn = arguments[0] !== (void 0) ? arguments[0] : Expression.IN; var coverInitializedNameCount = this.coverInitializedNameCount_; var expression = this.parseExpressionAllowPattern_(expressionIn); this.ensureNoCoverInitializedNames_(expression, coverInitializedNameCount); return expression; }, parseExpressionAllowPattern_: function(expressionIn) { var start = this.getTreeStartLocation_(); var expression = this.parseAssignmentExpression(expressionIn); if (this.peek_(COMMA)) { var expressions = [expression]; while (this.eatIf_(COMMA)) { expressions.push(this.parseAssignmentExpression(expressionIn)); } return new CommaExpression(this.getTreeLocation_(start), expressions); } return expression; }, peekAssignmentExpression_: function(type) { return this.peekExpression_(type); }, parseAssignmentExpression: function() { var expressionIn = arguments[0] !== (void 0) ? arguments[0] : Expression.NORMAL; if (this.allowYield_ && this.peek_(YIELD)) return this.parseYieldExpression_(); var start = this.getTreeStartLocation_(); var validAsyncParen = false; if (options.asyncFunctions && this.peekPredefinedString_(ASYNC)) { var asyncToken = this.peekToken_(); var maybeOpenParenToken = this.peekToken_(1); validAsyncParen = maybeOpenParenToken.type === OPEN_PAREN && asyncToken.location.end.line === maybeOpenParenToken.location.start.line; } var left = this.parseConditional_(expressionIn); var type = this.peekType_(); if (options.asyncFunctions && left.type === IDENTIFIER_EXPRESSION && left.identifierToken.value === ASYNC && type === IDENTIFIER) { if (this.peekTokenNoLineTerminator_() !== null) { var bindingIdentifier = this.parseBindingIdentifier_(); var asyncToken = left.IdentifierToken; return this.parseArrowFunction_(start, bindingIdentifier, asyncToken); } } if (type === ARROW) { if (left.type === COVER_FORMALS || left.type === IDENTIFIER_EXPRESSION) return this.parseArrowFunction_(start, left, null); if (validAsyncParen && left.type === CALL_EXPRESSION) { var arrowToken = this.peekTokenNoLineTerminator_(); if (arrowToken !== null) { var asyncToken = left.operand.identifierToken; return this.parseArrowFunction_(start, left.args, asyncToken); } } } left = this.coverFormalsToParenExpression_(left); if (this.peekAssignmentOperator_(type)) { if (type === EQUAL) left = this.transformLeftHandSideExpression_(left); if (!left.isLeftHandSideExpression() && !left.isPattern()) { this.reportError_('Left hand side of assignment must be new, call, member, function, primary expressions or destructuring pattern'); } var operator = this.nextToken_(); var right = this.parseAssignmentExpression(expressionIn); return new BinaryExpression(this.getTreeLocation_(start), left, operator, right); } return left; }, transformLeftHandSideExpression_: function(tree) { switch (tree.type) { case ARRAY_LITERAL_EXPRESSION: case OBJECT_LITERAL_EXPRESSION: this.scanner_.index = tree.location.start.offset; return this.parseAssignmentPattern_(); } return tree; }, peekAssignmentOperator_: function(type) { return isAssignmentOperator(type); }, parseConditional_: function(expressionIn) { var start = this.getTreeStartLocation_(); var condition = this.parseLogicalOR_(expressionIn); if (this.eatIf_(QUESTION)) { condition = this.toPrimaryExpression_(condition); var left = this.parseAssignmentExpression(); this.eat_(COLON); var right = this.parseAssignmentExpression(expressionIn); return new ConditionalExpression(this.getTreeLocation_(start), condition, left, right); } return condition; }, newBinaryExpression_: function(start, left, operator, right) { left = this.toPrimaryExpression_(left); right = this.toPrimaryExpression_(right); return new BinaryExpression(this.getTreeLocation_(start), left, operator, right); }, parseLogicalOR_: function(expressionIn) { var start = this.getTreeStartLocation_(); var left = this.parseLogicalAND_(expressionIn); var operator; while (operator = this.eatOpt_(OR)) { var right = this.parseLogicalAND_(expressionIn); left = this.newBinaryExpression_(start, left, operator, right); } return left; }, parseLogicalAND_: function(expressionIn) { var start = this.getTreeStartLocation_(); var left = this.parseBitwiseOR_(expressionIn); var operator; while (operator = this.eatOpt_(AND)) { var right = this.parseBitwiseOR_(expressionIn); left = this.newBinaryExpression_(start, left, operator, right); } return left; }, parseBitwiseOR_: function(expressionIn) { var start = this.getTreeStartLocation_(); var left = this.parseBitwiseXOR_(expressionIn); var operator; while (operator = this.eatOpt_(BAR)) { var right = this.parseBitwiseXOR_(expressionIn); left = this.newBinaryExpression_(start, left, operator, right); } return left; }, parseBitwiseXOR_: function(expressionIn) { var start = this.getTreeStartLocation_(); var left = this.parseBitwiseAND_(expressionIn); var operator; while (operator = this.eatOpt_(CARET)) { var right = this.parseBitwiseAND_(expressionIn); left = this.newBinaryExpression_(start, left, operator, right); } return left; }, parseBitwiseAND_: function(expressionIn) { var start = this.getTreeStartLocation_(); var left = this.parseEquality_(expressionIn); var operator; while (operator = this.eatOpt_(AMPERSAND)) { var right = this.parseEquality_(expressionIn); left = this.newBinaryExpression_(start, left, operator, right); } return left; }, parseEquality_: function(expressionIn) { var start = this.getTreeStartLocation_(); var left = this.parseRelational_(expressionIn); while (this.peekEqualityOperator_(this.peekType_())) { var operator = this.nextToken_(); var right = this.parseRelational_(expressionIn); left = this.newBinaryExpression_(start, left, operator, right); } return left; }, peekEqualityOperator_: function(type) { switch (type) { case EQUAL_EQUAL: case NOT_EQUAL: case EQUAL_EQUAL_EQUAL: case NOT_EQUAL_EQUAL: return true; } return false; }, parseRelational_: function(expressionIn) { var start = this.getTreeStartLocation_(); var left = this.parseShiftExpression_(); while (this.peekRelationalOperator_(expressionIn)) { var operator = this.nextToken_(); var right = this.parseShiftExpression_(); left = this.newBinaryExpression_(start, left, operator, right); } return left; }, peekRelationalOperator_: function(expressionIn) { switch (this.peekType_()) { case OPEN_ANGLE: case CLOSE_ANGLE: case GREATER_EQUAL: case LESS_EQUAL: case INSTANCEOF: return true; case IN: return expressionIn == Expression.NORMAL; default: return false; } }, parseShiftExpression_: function() { var start = this.getTreeStartLocation_(); var left = this.parseAdditiveExpression_(); while (this.peekShiftOperator_(this.peekType_())) { var operator = this.nextToken_(); var right = this.parseAdditiveExpression_(); left = this.newBinaryExpression_(start, left, operator, right); } return left; }, peekShiftOperator_: function(type) { switch (type) { case LEFT_SHIFT: case RIGHT_SHIFT: case UNSIGNED_RIGHT_SHIFT: return true; default: return false; } }, parseAdditiveExpression_: function() { var start = this.getTreeStartLocation_(); var left = this.parseMultiplicativeExpression_(); while (this.peekAdditiveOperator_(this.peekType_())) { var operator = this.nextToken_(); var right = this.parseMultiplicativeExpression_(); left = this.newBinaryExpression_(start, left, operator, right); } return left; }, peekAdditiveOperator_: function(type) { switch (type) { case PLUS: case MINUS: return true; default: return false; } }, parseMultiplicativeExpression_: function() { var start = this.getTreeStartLocation_(); var left = this.parseUnaryExpression_(); while (this.peekMultiplicativeOperator_(this.peekType_())) { var operator = this.nextToken_(); var right = this.parseUnaryExpression_(); left = this.newBinaryExpression_(start, left, operator, right); } return left; }, peekMultiplicativeOperator_: function(type) { switch (type) { case STAR: case SLASH: case PERCENT: return true; default: return false; } }, parseUnaryExpression_: function() { var start = this.getTreeStartLocation_(); if (this.allowAwait_ && this.peekPredefinedString_(AWAIT)) { this.eatId_(); var operand = this.parseUnaryExpression_(); operand = this.toPrimaryExpression_(operand); return new AwaitExpression(this.getTreeLocation_(start), operand); } if (this.peekUnaryOperator_(this.peekType_())) { var operator = this.nextToken_(); var operand = this.parseUnaryExpression_(); operand = this.toPrimaryExpression_(operand); return new UnaryExpression(this.getTreeLocation_(start), operator, operand); } return this.parsePostfixExpression_(); }, peekUnaryOperator_: function(type) { switch (type) { case DELETE: case VOID: case TYPEOF: case PLUS_PLUS: case MINUS_MINUS: case PLUS: case MINUS: case TILDE: case BANG: return true; default: return false; } }, parsePostfixExpression_: function() { var start = this.getTreeStartLocation_(); var operand = this.parseLeftHandSideExpression_(); while (this.peekPostfixOperator_(this.peekType_())) { operand = this.toPrimaryExpression_(operand); var operator = this.nextToken_(); operand = new PostfixExpression(this.getTreeLocation_(start), operand, operator); } return operand; }, peekPostfixOperator_: function(type) { switch (type) { case PLUS_PLUS: case MINUS_MINUS: var token = this.peekTokenNoLineTerminator_(); return token !== null; } return false; }, parseLeftHandSideExpression_: function() { var start = this.getTreeStartLocation_(); var operand = this.parseNewExpression_(); if (!(operand instanceof NewExpression) || operand.args != null) { loop: while (true) { switch (this.peekType_()) { case OPEN_PAREN: operand = this.toPrimaryExpression_(operand); operand = this.parseCallExpression_(start, operand); break; case OPEN_SQUARE: operand = this.toPrimaryExpression_(operand); operand = this.parseMemberLookupExpression_(start, operand); break; case PERIOD: operand = this.toPrimaryExpression_(operand); operand = this.parseMemberExpression_(start, operand); break; case NO_SUBSTITUTION_TEMPLATE: case TEMPLATE_HEAD: if (!parseOptions.templateLiterals) break loop; operand = this.toPrimaryExpression_(operand); operand = this.parseTemplateLiteral_(operand); break; default: break loop; } } } return operand; }, parseMemberExpressionNoNew_: function() { var start = this.getTreeStartLocation_(); var operand; if (this.peekType_() === FUNCTION) { operand = this.parseFunctionExpression_(); } else { operand = this.parsePrimaryExpression_(); } loop: while (true) { switch (this.peekType_()) { case OPEN_SQUARE: operand = this.toPrimaryExpression_(operand); operand = this.parseMemberLookupExpression_(start, operand); break; case PERIOD: operand = this.toPrimaryExpression_(operand); operand = this.parseMemberExpression_(start, operand); break; case NO_SUBSTITUTION_TEMPLATE: case TEMPLATE_HEAD: if (!parseOptions.templateLiterals) break loop; operand = this.toPrimaryExpression_(operand); operand = this.parseTemplateLiteral_(operand); break; default: break loop; } } return operand; }, parseMemberExpression_: function(start, operand) { this.nextToken_(); var name = this.eatIdName_(); return new MemberExpression(this.getTreeLocation_(start), operand, name); }, parseMemberLookupExpression_: function(start, operand) { this.nextToken_(); var member = this.parseExpression(); this.eat_(CLOSE_SQUARE); return new MemberLookupExpression(this.getTreeLocation_(start), operand, member); }, parseCallExpression_: function(start, operand) { var args = this.parseArguments_(); return new CallExpression(this.getTreeLocation_(start), operand, args); }, parseNewExpression_: function() { var operand; switch (this.peekType_()) { case NEW: var start = this.getTreeStartLocation_(); this.eat_(NEW); if (this.peek_(SUPER)) operand = this.parseSuperExpression_(); else operand = this.toPrimaryExpression_(this.parseNewExpression_()); var args = null; if (this.peek_(OPEN_PAREN)) { args = this.parseArguments_(); } return new NewExpression(this.getTreeLocation_(start), operand, args); case SUPER: operand = this.parseSuperExpression_(); var type = this.peekType_(); switch (type) { case OPEN_SQUARE: return this.parseMemberLookupExpression_(start, operand); case PERIOD: return this.parseMemberExpression_(start, operand); case OPEN_PAREN: return this.parseCallExpression_(start, operand); default: return this.parseUnexpectedToken_(type); } break; default: return this.parseMemberExpressionNoNew_(); } }, parseArguments_: function() { var start = this.getTreeStartLocation_(); var args = []; this.eat_(OPEN_PAREN); if (!this.peek_(CLOSE_PAREN)) { args.push(this.parseArgument_()); while (this.eatIf_(COMMA)) { args.push(this.parseArgument_()); } } this.eat_(CLOSE_PAREN); return new ArgumentList(this.getTreeLocation_(start), args); }, parseArgument_: function() { if (this.peekSpread_(this.peekType_())) return this.parseSpreadExpression_(); return this.parseAssignmentExpression(); }, parseArrowFunction_: function(start, tree, asyncToken) { var formals; switch (tree.type) { case IDENTIFIER_EXPRESSION: tree = new BindingIdentifier(tree.location, tree.identifierToken); case BINDING_IDENTIFIER: formals = new FormalParameterList(this.getTreeLocation_(start), [new FormalParameter(tree.location, new BindingElement(tree.location, tree, null), null, [])]); break; case FORMAL_PARAMETER_LIST: formals = tree; break; default: formals = this.toFormalParameters_(start, tree, asyncToken); } this.eat_(ARROW); var body = this.parseConciseBody_(asyncToken); return new ArrowFunctionExpression(this.getTreeLocation_(start), asyncToken, formals, body); }, parseCoverFormals_: function(start) { var expressions = []; if (!this.peek_(CLOSE_PAREN)) { do { var type = this.peekType_(); if (this.peekRest_(type)) { expressions.push(this.parseRestParameter_()); break; } else { expressions.push(this.parseAssignmentExpression()); } if (this.eatIf_(COMMA)) continue; } while (!this.peek_(CLOSE_PAREN) && !this.isAtEnd()); } this.eat_(CLOSE_PAREN); return new CoverFormals(this.getTreeLocation_(start), expressions); }, ensureNoCoverInitializedNames_: function(tree, coverInitializedNameCount) { if (coverInitializedNameCount === this.coverInitializedNameCount_) return; var finder = new ValidateObjectLiteral(tree); if (finder.found) { var token = finder.errorToken; this.reportError_(token.location, ("Unexpected token " + token)); } }, toPrimaryExpression_: function(tree) { if (tree.type === COVER_FORMALS) return this.coverFormalsToParenExpression_(tree); return tree; }, validateCoverFormalsAsParenExpression_: function(tree) { for (var i = 0; i < tree.expressions.length; i++) { if (tree.expressions[i].type === REST_PARAMETER) { var token = new Token(DOT_DOT_DOT, tree.expressions[i].location); this.reportError_(token.location, ("Unexpected token " + token)); return; } } }, coverFormalsToParenExpression_: function(tree) { if (tree.type === COVER_FORMALS) { var expressions = tree.expressions; if (expressions.length === 0) { var message = 'Unexpected token )'; this.reportError_(tree.location, message); } else { this.validateCoverFormalsAsParenExpression_(tree); var expression; if (expressions.length > 1) expression = new CommaExpression(expressions[0].location, expressions); else expression = expressions[0]; return new ParenExpression(tree.location, expression); } } return tree; }, toFormalParameters_: function(start, tree, asyncToken) { this.scanner_.index = start.offset; return this.parseArrowFormalParameters_(asyncToken); }, parseArrowFormalParameters_: function(asyncToken) { if (asyncToken) this.eat_(IDENTIFIER); this.eat_(OPEN_PAREN); var parameters = this.parseFormalParameters_(); this.eat_(CLOSE_PAREN); return parameters; }, peekArrow_: function(type) { return type === ARROW && parseOptions.arrowFunctions; }, parseConciseBody_: function(asyncToken) { if (this.peek_(OPEN_CURLY)) return this.parseFunctionBody_(asyncToken); var allowAwait = this.allowAwait_; this.allowAwait_ = asyncToken !== null; var expression = this.parseAssignmentExpression(); this.allowAwait_ = allowAwait; return expression; }, parseGeneratorComprehension_: function(start) { var comprehensionList = this.parseComprehensionList_(); var expression = this.parseAssignmentExpression(); this.eat_(CLOSE_PAREN); return new GeneratorComprehension(this.getTreeLocation_(start), comprehensionList, expression); }, parseForBinding_: function() { if (this.peekPattern_(this.peekType_())) return this.parseBindingPattern_(); return this.parseBindingIdentifier_(); }, peekPattern_: function(type) { return parseOptions.destructuring && (this.peekObjectPattern_(type) || this.peekArrayPattern_(type)); }, peekArrayPattern_: function(type) { return type === OPEN_SQUARE; }, peekObjectPattern_: function(type) { return type === OPEN_CURLY; }, parseBindingPattern_: function() { return this.parsePattern_(true); }, parsePattern_: function(useBinding) { if (this.peekArrayPattern_(this.peekType_())) return this.parseArrayPattern_(useBinding); return this.parseObjectPattern_(useBinding); }, parseArrayBindingPattern_: function() { return this.parseArrayPattern_(true); }, parsePatternElement_: function(useBinding) { return useBinding ? this.parseBindingElement_() : this.parseAssignmentElement_(); }, parsePatternRestElement_: function(useBinding) { return useBinding ? this.parseBindingRestElement_() : this.parseAssignmentRestElement_(); }, parseArrayPattern_: function(useBinding) { var start = this.getTreeStartLocation_(); var elements = []; this.eat_(OPEN_SQUARE); var type; while ((type = this.peekType_()) !== CLOSE_SQUARE && type !== END_OF_FILE) { this.parseElisionOpt_(elements); if (this.peekRest_(this.peekType_())) { elements.push(this.parsePatternRestElement_(useBinding)); break; } else { elements.push(this.parsePatternElement_(useBinding)); if (this.peek_(COMMA) && !this.peek_(CLOSE_SQUARE, 1)) { this.nextToken_(); } } } this.eat_(CLOSE_SQUARE); return new ArrayPattern(this.getTreeLocation_(start), elements); }, parseBindingElementList_: function(elements) { this.parseElisionOpt_(elements); elements.push(this.parseBindingElement_()); while (this.eatIf_(COMMA)) { this.parseElisionOpt_(elements); elements.push(this.parseBindingElement_()); } }, parseElisionOpt_: function(elements) { while (this.eatIf_(COMMA)) { elements.push(null); } }, peekBindingElement_: function(type) { return this.peekBindingIdentifier_(type) || this.peekPattern_(type); }, parseBindingElement_: function() { var initializer = arguments[0] !== (void 0) ? arguments[0] : Initializer.OPTIONAL; var start = this.getTreeStartLocation_(); var binding = this.parseBindingElementBinding_(); var initializer = this.parseBindingElementInitializer_(initializer); return new BindingElement(this.getTreeLocation_(start), binding, initializer); }, parseBindingElementBinding_: function() { if (this.peekPattern_(this.peekType_())) return this.parseBindingPattern_(); return this.parseBindingIdentifier_(); }, parseBindingElementInitializer_: function() { var initializer = arguments[0] !== (void 0) ? arguments[0] : Initializer.OPTIONAL; if (this.peek_(EQUAL) || initializer === Initializer.REQUIRED) { return this.parseInitializer_(); } return null; }, parseBindingRestElement_: function() { var start = this.getTreeStartLocation_(); this.eat_(DOT_DOT_DOT); var identifier = this.parseBindingIdentifier_(); return new SpreadPatternElement(this.getTreeLocation_(start), identifier); }, parseObjectPattern_: function(useBinding) { var start = this.getTreeStartLocation_(); var elements = []; this.eat_(OPEN_CURLY); var type; while ((type = this.peekType_()) !== CLOSE_CURLY && type !== END_OF_FILE) { elements.push(this.parsePatternProperty_(useBinding)); if (!this.eatIf_(COMMA)) break; } this.eat_(CLOSE_CURLY); return new ObjectPattern(this.getTreeLocation_(start), elements); }, parsePatternProperty_: function(useBinding) { var start = this.getTreeStartLocation_(); var name = this.parsePropertyName_(); var requireColon = name.type !== LITERAL_PROPERTY_NAME || !name.literalToken.isStrictKeyword() && name.literalToken.type !== IDENTIFIER; if (requireColon || this.peek_(COLON)) { this.eat_(COLON); var element = this.parsePatternElement_(useBinding); return new ObjectPatternField(this.getTreeLocation_(start), name, element); } var token = name.literalToken; if (this.strictMode_ && token.isStrictKeyword()) this.reportReservedIdentifier_(token); if (useBinding) { var binding = new BindingIdentifier(name.location, token); var initializer = this.parseInitializerOpt_(Expression.NORMAL); return new BindingElement(this.getTreeLocation_(start), binding, initializer); } var assignment = new IdentifierExpression(name.location, token); var initializer = this.parseInitializerOpt_(Expression.NORMAL); return new AssignmentElement(this.getTreeLocation_(start), assignment, initializer); }, parseAssignmentPattern_: function() { return this.parsePattern_(false); }, parseArrayAssignmentPattern_: function() { return this.parseArrayPattern_(false); }, parseAssignmentElement_: function() { var start = this.getTreeStartLocation_(); var assignment = this.parseDestructuringAssignmentTarget_(); var initializer = this.parseInitializerOpt_(Expression.NORMAL); return new AssignmentElement(this.getTreeLocation_(start), assignment, initializer); }, parseDestructuringAssignmentTarget_: function() { switch (this.peekType_()) { case OPEN_SQUARE: return this.parseArrayAssignmentPattern_(); case OPEN_CURLY: return this.parseObjectAssignmentPattern_(); } var expression = this.parseLeftHandSideExpression_(); return this.coverFormalsToParenExpression_(expression); }, parseAssignmentRestElement_: function() { var start = this.getTreeStartLocation_(); this.eat_(DOT_DOT_DOT); var id = this.parseDestructuringAssignmentTarget_(); return new SpreadPatternElement(this.getTreeLocation_(start), id); }, parseObjectAssignmentPattern_: function() { return this.parseObjectPattern_(false); }, parseAssignmentProperty_: function() { return this.parsePatternProperty_(false); }, parseTemplateLiteral_: function(operand) { if (!parseOptions.templateLiterals) return this.parseUnexpectedToken_('`'); var start = operand ? operand.location.start : this.getTreeStartLocation_(); var token = this.nextToken_(); var elements = [new TemplateLiteralPortion(token.location, token)]; if (token.type === NO_SUBSTITUTION_TEMPLATE) { return new TemplateLiteralExpression(this.getTreeLocation_(start), operand, elements); } var expression = this.parseExpression(); elements.push(new TemplateSubstitution(expression.location, expression)); while (expression.type !== SYNTAX_ERROR_TREE) { token = this.nextTemplateLiteralToken_(); if (token.type === ERROR || token.type === END_OF_FILE) break; elements.push(new TemplateLiteralPortion(token.location, token)); if (token.type === TEMPLATE_TAIL) break; expression = this.parseExpression(); elements.push(new TemplateSubstitution(expression.location, expression)); } return new TemplateLiteralExpression(this.getTreeLocation_(start), operand, elements); }, parseTypeAnnotationOpt_: function() { if (parseOptions.types && this.eatOpt_(COLON)) { return this.parseType_(); } return null; }, parseType_: function() { var start = this.getTreeStartLocation_(); var elementType; switch (this.peekType_()) { case IDENTIFIER: elementType = this.parseNamedOrPredefinedType_(); break; case NEW: elementType = this.parseConstructorType_(); break; case OPEN_CURLY: elementType = this.parseObjectType_(); break; case OPEN_PAREN: elementType = this.parseFunctionType_(); break; case VOID: var token = this.nextToken_(); return new PredefinedType(this.getTreeLocation_(start), token); default: return this.parseUnexpectedToken_(this.peekToken_()); } return this.parseArrayTypeSuffix_(start, elementType); }, parseArrayTypeSuffix_: function(start, elementType) { return elementType; }, parseConstructorType_: function() { throw 'NYI'; }, parseObjectType_: function() { throw 'NYI'; }, parseFunctionType_: function() { throw 'NYI'; }, parseNamedOrPredefinedType_: function() { var start = this.getTreeStartLocation_(); switch (this.peekToken_().value) { case 'any': case 'number': case 'boolean': case 'string': var token = this.nextToken_(); return new PredefinedType(this.getTreeLocation_(start), token); default: return this.parseTypeName_(); } }, parseTypeName_: function() { var start = this.getTreeStartLocation_(); var typeName = new TypeName(this.getTreeLocation_(start), null, this.eatId_()); while (this.eatIf_(PERIOD)) { var memberName = this.eatIdName_(); typeName = new TypeName(this.getTreeLocation_(start), typeName, memberName); } return typeName; }, parseAnnotatedDeclarations_: function(allowModuleItem, allowScriptItem) { this.pushAnnotations_(); var declaration = this.parseStatement_(this.peekType_(), allowModuleItem, allowScriptItem); if (this.annotations_.length > 0) return this.parseSyntaxError_('Unsupported annotated expression'); return declaration; }, parseAnnotations_: function() { var annotations = []; while (this.eatIf_(AT)) { annotations.push(this.parseAnnotation_()); } return annotations; }, pushAnnotations_: function() { this.annotations_ = this.parseAnnotations_(); }, popAnnotations_: function() { var annotations = this.annotations_; this.annotations_ = []; return annotations; }, parseAnnotation_: function() { var start = this.getTreeStartLocation_(); var expression = this.parseMemberExpressionNoNew_(); var args = null; if (this.peek_(OPEN_PAREN)) args = this.parseArguments_(); return new Annotation(this.getTreeLocation_(start), expression, args); }, eatPossibleImplicitSemiColon_: function() { var token = this.peekTokenNoLineTerminator_(); if (!token) return; switch (token.type) { case SEMI_COLON: this.nextToken_(); return; case END_OF_FILE: case CLOSE_CURLY: return; } this.reportError_('Semi-colon expected'); }, peekImplicitSemiColon_: function() { switch (this.peekType_()) { case SEMI_COLON: case CLOSE_CURLY: case END_OF_FILE: return true; } var token = this.peekTokenNoLineTerminator_(); return token === null; }, eatOpt_: function(expectedTokenType) { if (this.peek_(expectedTokenType)) return this.nextToken_(); return null; }, eatIdOpt_: function() { return this.peek_(IDENTIFIER) ? this.eatId_() : null; }, eatId_: function() { var expected = arguments[0]; var token = this.nextToken_(); if (!token) { if (expected) this.reportError_(this.peekToken_(), ("expected '" + expected + "'")); return null; } if (token.type === IDENTIFIER) { if (expected && token.value !== expected) this.reportExpectedError_(token, expected); return token; } if (token.isStrictKeyword()) { if (this.strictMode_) { this.reportReservedIdentifier_(token); } else { return new IdentifierToken(token.location, token.type); } } else { this.reportExpectedError_(token, expected || 'identifier'); } return token; }, eatIdName_: function() { var t = this.nextToken_(); if (t.type != IDENTIFIER) { if (!t.isKeyword()) { this.reportExpectedError_(t, 'identifier'); return null; } return new IdentifierToken(t.location, t.type); } return t; }, eat_: function(expectedTokenType) { var token = this.nextToken_(); if (token.type != expectedTokenType) { this.reportExpectedError_(token, expectedTokenType); return null; } return token; }, eatIf_: function(expectedTokenType) { if (this.peek_(expectedTokenType)) { this.nextToken_(); return true; } return false; }, reportExpectedError_: function(token, expected) { this.reportError_(token, ("Unexpected token " + token)); }, getTreeStartLocation_: function() { return this.peekToken_().location.start; }, getTreeEndLocation_: function() { return this.scanner_.lastToken.location.end; }, getTreeLocation_: function(start) { return new SourceRange(start, this.getTreeEndLocation_()); }, handleComment: function(range) {}, nextToken_: function() { return this.scanner_.nextToken(); }, nextRegularExpressionLiteralToken_: function() { return this.scanner_.nextRegularExpressionLiteralToken(); }, nextTemplateLiteralToken_: function() { return this.scanner_.nextTemplateLiteralToken(); }, isAtEnd: function() { return this.scanner_.isAtEnd(); }, peek_: function(expectedType, opt_index) { return this.peekToken_(opt_index).type === expectedType; }, peekType_: function() { return this.peekToken_().type; }, peekToken_: function(opt_index) { return this.scanner_.peekToken(opt_index); }, peekTokenNoLineTerminator_: function() { return this.scanner_.peekTokenNoLineTerminator(); }, reportError_: function() { for (var args = [], $__142 = 0; $__142 < arguments.length; $__142++) args[$__142] = arguments[$__142]; if (args.length == 1) { this.errorReporter_.reportError(this.scanner_.getPosition(), args[0]); } else { var location = args[0]; if (location instanceof Token) { location = location.location; } this.errorReporter_.reportError(location.start, args[1]); } }, reportReservedIdentifier_: function(token) { this.reportError_(token, (token.type + " is a reserved identifier")); } }, {}); return {get Parser() { return Parser; }}; }); System.register("traceur@0.0.52/src/util/SourcePosition", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/util/SourcePosition"; var SourcePosition = function SourcePosition(source, offset) { this.source = source; this.offset = offset; this.line_ = -1; this.column_ = -1; }; ($traceurRuntime.createClass)(SourcePosition, { get line() { if (this.line_ === -1) this.line_ = this.source.lineNumberTable.getLine(this.offset); return this.line_; }, get column() { if (this.column_ === -1) this.column_ = this.source.lineNumberTable.getColumn(this.offset); return this.column_; }, toString: function() { var name = this.source ? this.source.name : ''; return (name + ":" + (this.line + 1) + ":" + (this.column + 1)); } }, {}); return {get SourcePosition() { return SourcePosition; }}; }); System.register("traceur@0.0.52/src/syntax/LineNumberTable", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/syntax/LineNumberTable"; var SourcePosition = System.get("traceur@0.0.52/src/util/SourcePosition").SourcePosition; var SourceRange = System.get("traceur@0.0.52/src/util/SourceRange").SourceRange; var isLineTerminator = System.get("traceur@0.0.52/src/syntax/Scanner").isLineTerminator; var MAX_INT_REPRESENTATION = 9007199254740992; function computeLineStartOffsets(source) { var lineStartOffsets = [0]; var k = 1; for (var index = 0; index < source.length; index++) { var code = source.charCodeAt(index); if (isLineTerminator(code)) { if (code === 13 && source.charCodeAt(index + 1) === 10) { index++; } lineStartOffsets[k++] = index + 1; } } lineStartOffsets[k++] = MAX_INT_REPRESENTATION; return lineStartOffsets; } var LineNumberTable = function LineNumberTable(sourceFile) { this.sourceFile_ = sourceFile; this.lineStartOffsets_ = null; this.lastLine_ = 0; this.lastOffset_ = -1; }; ($traceurRuntime.createClass)(LineNumberTable, { ensureLineStartOffsets_: function() { if (!this.lineStartOffsets_) { this.lineStartOffsets_ = computeLineStartOffsets(this.sourceFile_.contents); } }, getSourcePosition: function(offset) { return new SourcePosition(this.sourceFile_, offset); }, getLine: function(offset) { if (offset === this.lastOffset_) return this.lastLine_; this.ensureLineStartOffsets_(); if (offset < 0) return 0; var line; if (offset < this.lastOffset_) { for (var i = this.lastLine_; i >= 0; i--) { if (this.lineStartOffsets_[i] <= offset) { line = i; break; } } } else { for (var i = this.lastLine_; true; i++) { if (this.lineStartOffsets_[i] > offset) { line = i - 1; break; } } } this.lastLine_ = line; this.lastOffset_ = offset; return line; }, offsetOfLine: function(line) { this.ensureLineStartOffsets_(); return this.lineStartOffsets_[line]; }, getColumn: function(offset) { var line = this.getLine(offset); return offset - this.lineStartOffsets_[line]; }, getSourceRange: function(startOffset, endOffset) { return new SourceRange(this.getSourcePosition(startOffset), this.getSourcePosition(endOffset)); } }, {}); return {get LineNumberTable() { return LineNumberTable; }}; }); System.register("traceur@0.0.52/src/syntax/SourceFile", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/syntax/SourceFile"; var LineNumberTable = System.get("traceur@0.0.52/src/syntax/LineNumberTable").LineNumberTable; var SourceFile = function SourceFile(name, contents) { this.name = name; this.contents = contents; this.lineNumberTable = new LineNumberTable(this); }; ($traceurRuntime.createClass)(SourceFile, {}, {}); return {get SourceFile() { return SourceFile; }}; }); System.register("traceur@0.0.52/src/util/MutedErrorReporter", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/util/MutedErrorReporter"; var ErrorReporter = System.get("traceur@0.0.52/src/util/ErrorReporter").ErrorReporter; var MutedErrorReporter = function MutedErrorReporter() { $traceurRuntime.defaultSuperCall(this, $MutedErrorReporter.prototype, arguments); }; var $MutedErrorReporter = MutedErrorReporter; ($traceurRuntime.createClass)(MutedErrorReporter, {reportMessageInternal: function(location, format, args) {}}, {}, ErrorReporter); return {get MutedErrorReporter() { return MutedErrorReporter; }}; }); System.register("traceur@0.0.52/src/codegeneration/ParseTreeTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/ParseTreeTransformer"; var $__152 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), Annotation = $__152.Annotation, AnonBlock = $__152.AnonBlock, ArgumentList = $__152.ArgumentList, ArrayComprehension = $__152.ArrayComprehension, ArrayLiteralExpression = $__152.ArrayLiteralExpression, ArrayPattern = $__152.ArrayPattern, ArrowFunctionExpression = $__152.ArrowFunctionExpression, AssignmentElement = $__152.AssignmentElement, AwaitExpression = $__152.AwaitExpression, BinaryExpression = $__152.BinaryExpression, BindingElement = $__152.BindingElement, BindingIdentifier = $__152.BindingIdentifier, Block = $__152.Block, BreakStatement = $__152.BreakStatement, CallExpression = $__152.CallExpression, CaseClause = $__152.CaseClause, Catch = $__152.Catch, ClassDeclaration = $__152.ClassDeclaration, ClassExpression = $__152.ClassExpression, CommaExpression = $__152.CommaExpression, ComprehensionFor = $__152.ComprehensionFor, ComprehensionIf = $__152.ComprehensionIf, ComputedPropertyName = $__152.ComputedPropertyName, ConditionalExpression = $__152.ConditionalExpression, ContinueStatement = $__152.ContinueStatement, CoverFormals = $__152.CoverFormals, CoverInitializedName = $__152.CoverInitializedName, DebuggerStatement = $__152.DebuggerStatement, DefaultClause = $__152.DefaultClause, DoWhileStatement = $__152.DoWhileStatement, EmptyStatement = $__152.EmptyStatement, ExportDeclaration = $__152.ExportDeclaration, ExportDefault = $__152.ExportDefault, ExportSpecifier = $__152.ExportSpecifier, ExportSpecifierSet = $__152.ExportSpecifierSet, ExportStar = $__152.ExportStar, ExpressionStatement = $__152.ExpressionStatement, Finally = $__152.Finally, ForInStatement = $__152.ForInStatement, ForOfStatement = $__152.ForOfStatement, ForStatement = $__152.ForStatement, FormalParameter = $__152.FormalParameter, FormalParameterList = $__152.FormalParameterList, FunctionBody = $__152.FunctionBody, FunctionDeclaration = $__152.FunctionDeclaration, FunctionExpression = $__152.FunctionExpression, GeneratorComprehension = $__152.GeneratorComprehension, GetAccessor = $__152.GetAccessor, IdentifierExpression = $__152.IdentifierExpression, IfStatement = $__152.IfStatement, ImportedBinding = $__152.ImportedBinding, ImportDeclaration = $__152.ImportDeclaration, ImportSpecifier = $__152.ImportSpecifier, ImportSpecifierSet = $__152.ImportSpecifierSet, LabelledStatement = $__152.LabelledStatement, LiteralExpression = $__152.LiteralExpression, LiteralPropertyName = $__152.LiteralPropertyName, MemberExpression = $__152.MemberExpression, MemberLookupExpression = $__152.MemberLookupExpression, Module = $__152.Module, ModuleDeclaration = $__152.ModuleDeclaration, ModuleSpecifier = $__152.ModuleSpecifier, NamedExport = $__152.NamedExport, NewExpression = $__152.NewExpression, ObjectLiteralExpression = $__152.ObjectLiteralExpression, ObjectPattern = $__152.ObjectPattern, ObjectPatternField = $__152.ObjectPatternField, ParenExpression = $__152.ParenExpression, PostfixExpression = $__152.PostfixExpression, PredefinedType = $__152.PredefinedType, Script = $__152.Script, PropertyMethodAssignment = $__152.PropertyMethodAssignment, PropertyNameAssignment = $__152.PropertyNameAssignment, PropertyNameShorthand = $__152.PropertyNameShorthand, RestParameter = $__152.RestParameter, ReturnStatement = $__152.ReturnStatement, SetAccessor = $__152.SetAccessor, SpreadExpression = $__152.SpreadExpression, SpreadPatternElement = $__152.SpreadPatternElement, SuperExpression = $__152.SuperExpression, SwitchStatement = $__152.SwitchStatement, SyntaxErrorTree = $__152.SyntaxErrorTree, TemplateLiteralExpression = $__152.TemplateLiteralExpression, TemplateLiteralPortion = $__152.TemplateLiteralPortion, TemplateSubstitution = $__152.TemplateSubstitution, ThisExpression = $__152.ThisExpression, ThrowStatement = $__152.ThrowStatement, TryStatement = $__152.TryStatement, TypeName = $__152.TypeName, UnaryExpression = $__152.UnaryExpression, VariableDeclaration = $__152.VariableDeclaration, VariableDeclarationList = $__152.VariableDeclarationList, VariableStatement = $__152.VariableStatement, WhileStatement = $__152.WhileStatement, WithStatement = $__152.WithStatement, YieldExpression = $__152.YieldExpression; var ParseTreeTransformer = function ParseTreeTransformer() {}; ($traceurRuntime.createClass)(ParseTreeTransformer, { transformAny: function(tree) { return tree && tree.transform(this); }, transformList: function(list) { var $__154; var builder = null; for (var index = 0; index < list.length; index++) { var element = list[index]; var transformed = this.transformAny(element); if (builder != null || element != transformed) { if (builder == null) { builder = list.slice(0, index); } if (transformed instanceof AnonBlock) ($__154 = builder).push.apply($__154, $traceurRuntime.spread(transformed.statements)); else builder.push(transformed); } } return builder || list; }, transformStateMachine: function(tree) { throw Error('State machines should not live outside of the GeneratorTransformer.'); }, transformAnnotation: function(tree) { var name = this.transformAny(tree.name); var args = this.transformAny(tree.args); if (name === tree.name && args === tree.args) { return tree; } return new Annotation(tree.location, name, args); }, transformAnonBlock: function(tree) { var statements = this.transformList(tree.statements); if (statements === tree.statements) { return tree; } return new AnonBlock(tree.location, statements); }, transformArgumentList: function(tree) { var args = this.transformList(tree.args); if (args === tree.args) { return tree; } return new ArgumentList(tree.location, args); }, transformArrayComprehension: function(tree) { var comprehensionList = this.transformList(tree.comprehensionList); var expression = this.transformAny(tree.expression); if (comprehensionList === tree.comprehensionList && expression === tree.expression) { return tree; } return new ArrayComprehension(tree.location, comprehensionList, expression); }, transformArrayLiteralExpression: function(tree) { var elements = this.transformList(tree.elements); if (elements === tree.elements) { return tree; } return new ArrayLiteralExpression(tree.location, elements); }, transformArrayPattern: function(tree) { var elements = this.transformList(tree.elements); if (elements === tree.elements) { return tree; } return new ArrayPattern(tree.location, elements); }, transformArrowFunctionExpression: function(tree) { var parameterList = this.transformAny(tree.parameterList); var body = this.transformAny(tree.body); if (parameterList === tree.parameterList && body === tree.body) { return tree; } return new ArrowFunctionExpression(tree.location, tree.functionKind, parameterList, body); }, transformAssignmentElement: function(tree) { var assignment = this.transformAny(tree.assignment); var initializer = this.transformAny(tree.initializer); if (assignment === tree.assignment && initializer === tree.initializer) { return tree; } return new AssignmentElement(tree.location, assignment, initializer); }, transformAwaitExpression: function(tree) { var expression = this.transformAny(tree.expression); if (expression === tree.expression) { return tree; } return new AwaitExpression(tree.location, expression); }, transformBinaryExpression: function(tree) { var left = this.transformAny(tree.left); var right = this.transformAny(tree.right); if (left === tree.left && right === tree.right) { return tree; } return new BinaryExpression(tree.location, left, tree.operator, right); }, transformBindingElement: function(tree) { var binding = this.transformAny(tree.binding); var initializer = this.transformAny(tree.initializer); if (binding === tree.binding && initializer === tree.initializer) { return tree; } return new BindingElement(tree.location, binding, initializer); }, transformBindingIdentifier: function(tree) { return tree; }, transformBlock: function(tree) { var statements = this.transformList(tree.statements); if (statements === tree.statements) { return tree; } return new Block(tree.location, statements); }, transformBreakStatement: function(tree) { return tree; }, transformCallExpression: function(tree) { var operand = this.transformAny(tree.operand); var args = this.transformAny(tree.args); if (operand === tree.operand && args === tree.args) { return tree; } return new CallExpression(tree.location, operand, args); }, transformCaseClause: function(tree) { var expression = this.transformAny(tree.expression); var statements = this.transformList(tree.statements); if (expression === tree.expression && statements === tree.statements) { return tree; } return new CaseClause(tree.location, expression, statements); }, transformCatch: function(tree) { var binding = this.transformAny(tree.binding); var catchBody = this.transformAny(tree.catchBody); if (binding === tree.binding && catchBody === tree.catchBody) { return tree; } return new Catch(tree.location, binding, catchBody); }, transformClassDeclaration: function(tree) { var name = this.transformAny(tree.name); var superClass = this.transformAny(tree.superClass); var elements = this.transformList(tree.elements); var annotations = this.transformList(tree.annotations); if (name === tree.name && superClass === tree.superClass && elements === tree.elements && annotations === tree.annotations) { return tree; } return new ClassDeclaration(tree.location, name, superClass, elements, annotations); }, transformClassExpression: function(tree) { var name = this.transformAny(tree.name); var superClass = this.transformAny(tree.superClass); var elements = this.transformList(tree.elements); var annotations = this.transformList(tree.annotations); if (name === tree.name && superClass === tree.superClass && elements === tree.elements && annotations === tree.annotations) { return tree; } return new ClassExpression(tree.location, name, superClass, elements, annotations); }, transformCommaExpression: function(tree) { var expressions = this.transformList(tree.expressions); if (expressions === tree.expressions) { return tree; } return new CommaExpression(tree.location, expressions); }, transformComprehensionFor: function(tree) { var left = this.transformAny(tree.left); var iterator = this.transformAny(tree.iterator); if (left === tree.left && iterator === tree.iterator) { return tree; } return new ComprehensionFor(tree.location, left, iterator); }, transformComprehensionIf: function(tree) { var expression = this.transformAny(tree.expression); if (expression === tree.expression) { return tree; } return new ComprehensionIf(tree.location, expression); }, transformComputedPropertyName: function(tree) { var expression = this.transformAny(tree.expression); if (expression === tree.expression) { return tree; } return new ComputedPropertyName(tree.location, expression); }, transformConditionalExpression: function(tree) { var condition = this.transformAny(tree.condition); var left = this.transformAny(tree.left); var right = this.transformAny(tree.right); if (condition === tree.condition && left === tree.left && right === tree.right) { return tree; } return new ConditionalExpression(tree.location, condition, left, right); }, transformContinueStatement: function(tree) { return tree; }, transformCoverFormals: function(tree) { var expressions = this.transformList(tree.expressions); if (expressions === tree.expressions) { return tree; } return new CoverFormals(tree.location, expressions); }, transformCoverInitializedName: function(tree) { var initializer = this.transformAny(tree.initializer); if (initializer === tree.initializer) { return tree; } return new CoverInitializedName(tree.location, tree.name, tree.equalToken, initializer); }, transformDebuggerStatement: function(tree) { return tree; }, transformDefaultClause: function(tree) { var statements = this.transformList(tree.statements); if (statements === tree.statements) { return tree; } return new DefaultClause(tree.location, statements); }, transformDoWhileStatement: function(tree) { var body = this.transformAny(tree.body); var condition = this.transformAny(tree.condition); if (body === tree.body && condition === tree.condition) { return tree; } return new DoWhileStatement(tree.location, body, condition); }, transformEmptyStatement: function(tree) { return tree; }, transformExportDeclaration: function(tree) { var declaration = this.transformAny(tree.declaration); var annotations = this.transformList(tree.annotations); if (declaration === tree.declaration && annotations === tree.annotations) { return tree; } return new ExportDeclaration(tree.location, declaration, annotations); }, transformExportDefault: function(tree) { var expression = this.transformAny(tree.expression); if (expression === tree.expression) { return tree; } return new ExportDefault(tree.location, expression); }, transformExportSpecifier: function(tree) { return tree; }, transformExportSpecifierSet: function(tree) { var specifiers = this.transformList(tree.specifiers); if (specifiers === tree.specifiers) { return tree; } return new ExportSpecifierSet(tree.location, specifiers); }, transformExportStar: function(tree) { return tree; }, transformExpressionStatement: function(tree) { var expression = this.transformAny(tree.expression); if (expression === tree.expression) { return tree; } return new ExpressionStatement(tree.location, expression); }, transformFinally: function(tree) { var block = this.transformAny(tree.block); if (block === tree.block) { return tree; } return new Finally(tree.location, block); }, transformForInStatement: function(tree) { var initializer = this.transformAny(tree.initializer); var collection = this.transformAny(tree.collection); var body = this.transformAny(tree.body); if (initializer === tree.initializer && collection === tree.collection && body === tree.body) { return tree; } return new ForInStatement(tree.location, initializer, collection, body); }, transformForOfStatement: function(tree) { var initializer = this.transformAny(tree.initializer); var collection = this.transformAny(tree.collection); var body = this.transformAny(tree.body); if (initializer === tree.initializer && collection === tree.collection && body === tree.body) { return tree; } return new ForOfStatement(tree.location, initializer, collection, body); }, transformForStatement: function(tree) { var initializer = this.transformAny(tree.initializer); var condition = this.transformAny(tree.condition); var increment = this.transformAny(tree.increment); var body = this.transformAny(tree.body); if (initializer === tree.initializer && condition === tree.condition && increment === tree.increment && body === tree.body) { return tree; } return new ForStatement(tree.location, initializer, condition, increment, body); }, transformFormalParameter: function(tree) { var parameter = this.transformAny(tree.parameter); var typeAnnotation = this.transformAny(tree.typeAnnotation); var annotations = this.transformList(tree.annotations); if (parameter === tree.parameter && typeAnnotation === tree.typeAnnotation && annotations === tree.annotations) { return tree; } return new FormalParameter(tree.location, parameter, typeAnnotation, annotations); }, transformFormalParameterList: function(tree) { var parameters = this.transformList(tree.parameters); if (parameters === tree.parameters) { return tree; } return new FormalParameterList(tree.location, parameters); }, transformFunctionBody: function(tree) { var statements = this.transformList(tree.statements); if (statements === tree.statements) { return tree; } return new FunctionBody(tree.location, statements); }, transformFunctionDeclaration: function(tree) { var name = this.transformAny(tree.name); var parameterList = this.transformAny(tree.parameterList); var typeAnnotation = this.transformAny(tree.typeAnnotation); var annotations = this.transformList(tree.annotations); var body = this.transformAny(tree.body); if (name === tree.name && parameterList === tree.parameterList && typeAnnotation === tree.typeAnnotation && annotations === tree.annotations && body === tree.body) { return tree; } return new FunctionDeclaration(tree.location, name, tree.functionKind, parameterList, typeAnnotation, annotations, body); }, transformFunctionExpression: function(tree) { var name = this.transformAny(tree.name); var parameterList = this.transformAny(tree.parameterList); var typeAnnotation = this.transformAny(tree.typeAnnotation); var annotations = this.transformList(tree.annotations); var body = this.transformAny(tree.body); if (name === tree.name && parameterList === tree.parameterList && typeAnnotation === tree.typeAnnotation && annotations === tree.annotations && body === tree.body) { return tree; } return new FunctionExpression(tree.location, name, tree.functionKind, parameterList, typeAnnotation, annotations, body); }, transformGeneratorComprehension: function(tree) { var comprehensionList = this.transformList(tree.comprehensionList); var expression = this.transformAny(tree.expression); if (comprehensionList === tree.comprehensionList && expression === tree.expression) { return tree; } return new GeneratorComprehension(tree.location, comprehensionList, expression); }, transformGetAccessor: function(tree) { var name = this.transformAny(tree.name); var typeAnnotation = this.transformAny(tree.typeAnnotation); var annotations = this.transformList(tree.annotations); var body = this.transformAny(tree.body); if (name === tree.name && typeAnnotation === tree.typeAnnotation && annotations === tree.annotations && body === tree.body) { return tree; } return new GetAccessor(tree.location, tree.isStatic, name, typeAnnotation, annotations, body); }, transformIdentifierExpression: function(tree) { return tree; }, transformIfStatement: function(tree) { var condition = this.transformAny(tree.condition); var ifClause = this.transformAny(tree.ifClause); var elseClause = this.transformAny(tree.elseClause); if (condition === tree.condition && ifClause === tree.ifClause && elseClause === tree.elseClause) { return tree; } return new IfStatement(tree.location, condition, ifClause, elseClause); }, transformImportedBinding: function(tree) { var binding = this.transformAny(tree.binding); if (binding === tree.binding) { return tree; } return new ImportedBinding(tree.location, binding); }, transformImportDeclaration: function(tree) { var importClause = this.transformAny(tree.importClause); var moduleSpecifier = this.transformAny(tree.moduleSpecifier); if (importClause === tree.importClause && moduleSpecifier === tree.moduleSpecifier) { return tree; } return new ImportDeclaration(tree.location, importClause, moduleSpecifier); }, transformImportSpecifier: function(tree) { return tree; }, transformImportSpecifierSet: function(tree) { var specifiers = this.transformList(tree.specifiers); if (specifiers === tree.specifiers) { return tree; } return new ImportSpecifierSet(tree.location, specifiers); }, transformLabelledStatement: function(tree) { var statement = this.transformAny(tree.statement); if (statement === tree.statement) { return tree; } return new LabelledStatement(tree.location, tree.name, statement); }, transformLiteralExpression: function(tree) { return tree; }, transformLiteralPropertyName: function(tree) { return tree; }, transformMemberExpression: function(tree) { var operand = this.transformAny(tree.operand); if (operand === tree.operand) { return tree; } return new MemberExpression(tree.location, operand, tree.memberName); }, transformMemberLookupExpression: function(tree) { var operand = this.transformAny(tree.operand); var memberExpression = this.transformAny(tree.memberExpression); if (operand === tree.operand && memberExpression === tree.memberExpression) { return tree; } return new MemberLookupExpression(tree.location, operand, memberExpression); }, transformModule: function(tree) { var scriptItemList = this.transformList(tree.scriptItemList); if (scriptItemList === tree.scriptItemList) { return tree; } return new Module(tree.location, scriptItemList, tree.moduleName); }, transformModuleDeclaration: function(tree) { var expression = this.transformAny(tree.expression); if (expression === tree.expression) { return tree; } return new ModuleDeclaration(tree.location, tree.identifier, expression); }, transformModuleSpecifier: function(tree) { return tree; }, transformNamedExport: function(tree) { var moduleSpecifier = this.transformAny(tree.moduleSpecifier); var specifierSet = this.transformAny(tree.specifierSet); if (moduleSpecifier === tree.moduleSpecifier && specifierSet === tree.specifierSet) { return tree; } return new NamedExport(tree.location, moduleSpecifier, specifierSet); }, transformNewExpression: function(tree) { var operand = this.transformAny(tree.operand); var args = this.transformAny(tree.args); if (operand === tree.operand && args === tree.args) { return tree; } return new NewExpression(tree.location, operand, args); }, transformObjectLiteralExpression: function(tree) { var propertyNameAndValues = this.transformList(tree.propertyNameAndValues); if (propertyNameAndValues === tree.propertyNameAndValues) { return tree; } return new ObjectLiteralExpression(tree.location, propertyNameAndValues); }, transformObjectPattern: function(tree) { var fields = this.transformList(tree.fields); if (fields === tree.fields) { return tree; } return new ObjectPattern(tree.location, fields); }, transformObjectPatternField: function(tree) { var name = this.transformAny(tree.name); var element = this.transformAny(tree.element); if (name === tree.name && element === tree.element) { return tree; } return new ObjectPatternField(tree.location, name, element); }, transformParenExpression: function(tree) { var expression = this.transformAny(tree.expression); if (expression === tree.expression) { return tree; } return new ParenExpression(tree.location, expression); }, transformPostfixExpression: function(tree) { var operand = this.transformAny(tree.operand); if (operand === tree.operand) { return tree; } return new PostfixExpression(tree.location, operand, tree.operator); }, transformPredefinedType: function(tree) { return tree; }, transformScript: function(tree) { var scriptItemList = this.transformList(tree.scriptItemList); if (scriptItemList === tree.scriptItemList) { return tree; } return new Script(tree.location, scriptItemList, tree.moduleName); }, transformPropertyMethodAssignment: function(tree) { var name = this.transformAny(tree.name); var parameterList = this.transformAny(tree.parameterList); var typeAnnotation = this.transformAny(tree.typeAnnotation); var annotations = this.transformList(tree.annotations); var body = this.transformAny(tree.body); if (name === tree.name && parameterList === tree.parameterList && typeAnnotation === tree.typeAnnotation && annotations === tree.annotations && body === tree.body) { return tree; } return new PropertyMethodAssignment(tree.location, tree.isStatic, tree.functionKind, name, parameterList, typeAnnotation, annotations, body); }, transformPropertyNameAssignment: function(tree) { var name = this.transformAny(tree.name); var value = this.transformAny(tree.value); if (name === tree.name && value === tree.value) { return tree; } return new PropertyNameAssignment(tree.location, name, value); }, transformPropertyNameShorthand: function(tree) { return tree; }, transformRestParameter: function(tree) { var identifier = this.transformAny(tree.identifier); if (identifier === tree.identifier) { return tree; } return new RestParameter(tree.location, identifier); }, transformReturnStatement: function(tree) { var expression = this.transformAny(tree.expression); if (expression === tree.expression) { return tree; } return new ReturnStatement(tree.location, expression); }, transformSetAccessor: function(tree) { var name = this.transformAny(tree.name); var parameterList = this.transformAny(tree.parameterList); var annotations = this.transformList(tree.annotations); var body = this.transformAny(tree.body); if (name === tree.name && parameterList === tree.parameterList && annotations === tree.annotations && body === tree.body) { return tree; } return new SetAccessor(tree.location, tree.isStatic, name, parameterList, annotations, body); }, transformSpreadExpression: function(tree) { var expression = this.transformAny(tree.expression); if (expression === tree.expression) { return tree; } return new SpreadExpression(tree.location, expression); }, transformSpreadPatternElement: function(tree) { var lvalue = this.transformAny(tree.lvalue); if (lvalue === tree.lvalue) { return tree; } return new SpreadPatternElement(tree.location, lvalue); }, transformSuperExpression: function(tree) { return tree; }, transformSwitchStatement: function(tree) { var expression = this.transformAny(tree.expression); var caseClauses = this.transformList(tree.caseClauses); if (expression === tree.expression && caseClauses === tree.caseClauses) { return tree; } return new SwitchStatement(tree.location, expression, caseClauses); }, transformSyntaxErrorTree: function(tree) { return tree; }, transformTemplateLiteralExpression: function(tree) { var operand = this.transformAny(tree.operand); var elements = this.transformList(tree.elements); if (operand === tree.operand && elements === tree.elements) { return tree; } return new TemplateLiteralExpression(tree.location, operand, elements); }, transformTemplateLiteralPortion: function(tree) { return tree; }, transformTemplateSubstitution: function(tree) { var expression = this.transformAny(tree.expression); if (expression === tree.expression) { return tree; } return new TemplateSubstitution(tree.location, expression); }, transformThisExpression: function(tree) { return tree; }, transformThrowStatement: function(tree) { var value = this.transformAny(tree.value); if (value === tree.value) { return tree; } return new ThrowStatement(tree.location, value); }, transformTryStatement: function(tree) { var body = this.transformAny(tree.body); var catchBlock = this.transformAny(tree.catchBlock); var finallyBlock = this.transformAny(tree.finallyBlock); if (body === tree.body && catchBlock === tree.catchBlock && finallyBlock === tree.finallyBlock) { return tree; } return new TryStatement(tree.location, body, catchBlock, finallyBlock); }, transformTypeName: function(tree) { var moduleName = this.transformAny(tree.moduleName); if (moduleName === tree.moduleName) { return tree; } return new TypeName(tree.location, moduleName, tree.name); }, transformUnaryExpression: function(tree) { var operand = this.transformAny(tree.operand); if (operand === tree.operand) { return tree; } return new UnaryExpression(tree.location, tree.operator, operand); }, transformVariableDeclaration: function(tree) { var lvalue = this.transformAny(tree.lvalue); var typeAnnotation = this.transformAny(tree.typeAnnotation); var initializer = this.transformAny(tree.initializer); if (lvalue === tree.lvalue && typeAnnotation === tree.typeAnnotation && initializer === tree.initializer) { return tree; } return new VariableDeclaration(tree.location, lvalue, typeAnnotation, initializer); }, transformVariableDeclarationList: function(tree) { var declarations = this.transformList(tree.declarations); if (declarations === tree.declarations) { return tree; } return new VariableDeclarationList(tree.location, tree.declarationType, declarations); }, transformVariableStatement: function(tree) { var declarations = this.transformAny(tree.declarations); if (declarations === tree.declarations) { return tree; } return new VariableStatement(tree.location, declarations); }, transformWhileStatement: function(tree) { var condition = this.transformAny(tree.condition); var body = this.transformAny(tree.body); if (condition === tree.condition && body === tree.body) { return tree; } return new WhileStatement(tree.location, condition, body); }, transformWithStatement: function(tree) { var expression = this.transformAny(tree.expression); var body = this.transformAny(tree.body); if (expression === tree.expression && body === tree.body) { return tree; } return new WithStatement(tree.location, expression, body); }, transformYieldExpression: function(tree) { var expression = this.transformAny(tree.expression); if (expression === tree.expression) { return tree; } return new YieldExpression(tree.location, expression, tree.isYieldFor); } }, {}); return {get ParseTreeTransformer() { return ParseTreeTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/PlaceholderParser", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/PlaceholderParser"; var $__155 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), ARGUMENT_LIST = $__155.ARGUMENT_LIST, BLOCK = $__155.BLOCK, EXPRESSION_STATEMENT = $__155.EXPRESSION_STATEMENT, IDENTIFIER_EXPRESSION = $__155.IDENTIFIER_EXPRESSION; var IdentifierToken = System.get("traceur@0.0.52/src/syntax/IdentifierToken").IdentifierToken; var LiteralToken = System.get("traceur@0.0.52/src/syntax/LiteralToken").LiteralToken; var Map = System.get("traceur@0.0.52/src/runtime/polyfills/Map").Map; var MutedErrorReporter = System.get("traceur@0.0.52/src/util/MutedErrorReporter").MutedErrorReporter; var ParseTree = System.get("traceur@0.0.52/src/syntax/trees/ParseTree").ParseTree; var ParseTreeTransformer = System.get("traceur@0.0.52/src/codegeneration/ParseTreeTransformer").ParseTreeTransformer; var Parser = System.get("traceur@0.0.52/src/syntax/Parser").Parser; var $__163 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), LiteralExpression = $__163.LiteralExpression, LiteralPropertyName = $__163.LiteralPropertyName; var SourceFile = System.get("traceur@0.0.52/src/syntax/SourceFile").SourceFile; var IDENTIFIER = System.get("traceur@0.0.52/src/syntax/TokenType").IDENTIFIER; var $__166 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createArrayLiteralExpression = $__166.createArrayLiteralExpression, createBindingIdentifier = $__166.createBindingIdentifier, createBlock = $__166.createBlock, createBooleanLiteral = $__166.createBooleanLiteral, createCommaExpression = $__166.createCommaExpression, createExpressionStatement = $__166.createExpressionStatement, createFunctionBody = $__166.createFunctionBody, createIdentifierExpression = $__166.createIdentifierExpression, createIdentifierToken = $__166.createIdentifierToken, createMemberExpression = $__166.createMemberExpression, createNullLiteral = $__166.createNullLiteral, createNumberLiteral = $__166.createNumberLiteral, createParenExpression = $__166.createParenExpression, createStringLiteral = $__166.createStringLiteral, createVoid0 = $__166.createVoid0; var NOT_FOUND = {}; var PREFIX = '$__placeholder__'; var cache = new Map(); function parseExpression(sourceLiterals) { for (var values = [], $__168 = 1; $__168 < arguments.length; $__168++) values[$__168 - 1] = arguments[$__168]; return parse(sourceLiterals, values, (function() { return new PlaceholderParser().parseExpression(sourceLiterals); })); } function parseStatement(sourceLiterals) { for (var values = [], $__169 = 1; $__169 < arguments.length; $__169++) values[$__169 - 1] = arguments[$__169]; return parse(sourceLiterals, values, (function() { return new PlaceholderParser().parseStatement(sourceLiterals); })); } function parseStatements(sourceLiterals) { for (var values = [], $__170 = 1; $__170 < arguments.length; $__170++) values[$__170 - 1] = arguments[$__170]; return parse(sourceLiterals, values, (function() { return new PlaceholderParser().parseStatements(sourceLiterals); })); } function parsePropertyDefinition(sourceLiterals) { for (var values = [], $__171 = 1; $__171 < arguments.length; $__171++) values[$__171 - 1] = arguments[$__171]; return parse(sourceLiterals, values, (function() { return new PlaceholderParser().parsePropertyDefinition(sourceLiterals); })); } function parse(sourceLiterals, values, doParse) { var tree = cache.get(sourceLiterals); if (!tree) { tree = doParse(); cache.set(sourceLiterals, tree); } if (!values.length) return tree; if (tree instanceof ParseTree) return new PlaceholderTransformer(values).transformAny(tree); return new PlaceholderTransformer(values).transformList(tree); } var counter = 0; var PlaceholderParser = function PlaceholderParser() {}; ($traceurRuntime.createClass)(PlaceholderParser, { parseExpression: function(sourceLiterals) { return this.parse_(sourceLiterals, (function(p) { return p.parseExpression(); })); }, parseStatement: function(sourceLiterals) { return this.parse_(sourceLiterals, (function(p) { return p.parseStatement(); })); }, parseStatements: function(sourceLiterals) { return this.parse_(sourceLiterals, (function(p) { return p.parseStatements(); })); }, parsePropertyDefinition: function(sourceLiterals) { return this.parse_(sourceLiterals, (function(p) { return p.parsePropertyDefinition(); })); }, parse_: function(sourceLiterals, doParse) { var source = sourceLiterals[0]; for (var i = 1; i < sourceLiterals.length; i++) { source += PREFIX + (i - 1) + sourceLiterals[i]; } var file = new SourceFile('@traceur/generated/TemplateParser/' + counter++, source); var errorReporter = new MutedErrorReporter(); var parser = new Parser(file, errorReporter); var tree = doParse(parser); if (errorReporter.hadError() || !tree || !parser.isAtEnd()) throw new Error(("Internal error trying to parse:\n\n" + source)); return tree; } }, {}); function convertValueToExpression(value) { if (value instanceof ParseTree) return value; if (value instanceof IdentifierToken) return createIdentifierExpression(value); if (value instanceof LiteralToken) return new LiteralExpression(value.location, value); if (Array.isArray(value)) { if (value[0] instanceof ParseTree) { if (value.length === 1) return value[0]; if (value[0].isStatement()) return createBlock(value); else return createParenExpression(createCommaExpression(value)); } return createArrayLiteralExpression(value.map(convertValueToExpression)); } if (value === null) return createNullLiteral(); if (value === undefined) return createVoid0(); switch (typeof value) { case 'string': return createStringLiteral(value); case 'boolean': return createBooleanLiteral(value); case 'number': return createNumberLiteral(value); } throw new Error('Not implemented'); } function convertValueToIdentifierToken(value) { if (value instanceof IdentifierToken) return value; return createIdentifierToken(value); } var PlaceholderTransformer = function PlaceholderTransformer(values) { $traceurRuntime.superCall(this, $PlaceholderTransformer.prototype, "constructor", []); this.values = values; }; var $PlaceholderTransformer = PlaceholderTransformer; ($traceurRuntime.createClass)(PlaceholderTransformer, { getValueAt: function(index) { return this.values[index]; }, getValue_: function(str) { if (str.indexOf(PREFIX) !== 0) return NOT_FOUND; return this.getValueAt(Number(str.slice(PREFIX.length))); }, transformIdentifierExpression: function(tree) { var value = this.getValue_(tree.identifierToken.value); if (value === NOT_FOUND) return tree; return convertValueToExpression(value); }, transformBindingIdentifier: function(tree) { var value = this.getValue_(tree.identifierToken.value); if (value === NOT_FOUND) return tree; return createBindingIdentifier(value); }, transformExpressionStatement: function(tree) { if (tree.expression.type === IDENTIFIER_EXPRESSION) { var transformedExpression = this.transformIdentifierExpression(tree.expression); if (transformedExpression === tree.expression) return tree; if (transformedExpression.isStatement()) return transformedExpression; return createExpressionStatement(transformedExpression); } return $traceurRuntime.superCall(this, $PlaceholderTransformer.prototype, "transformExpressionStatement", [tree]); }, transformBlock: function(tree) { if (tree.statements.length === 1 && tree.statements[0].type === EXPRESSION_STATEMENT) { var transformedStatement = this.transformExpressionStatement(tree.statements[0]); if (transformedStatement === tree.statements[0]) return tree; if (transformedStatement.type === BLOCK) return transformedStatement; } return $traceurRuntime.superCall(this, $PlaceholderTransformer.prototype, "transformBlock", [tree]); }, transformFunctionBody: function(tree) { if (tree.statements.length === 1 && tree.statements[0].type === EXPRESSION_STATEMENT) { var transformedStatement = this.transformExpressionStatement(tree.statements[0]); if (transformedStatement === tree.statements[0]) return tree; if (transformedStatement.type === BLOCK) return createFunctionBody(transformedStatement.statements); } return $traceurRuntime.superCall(this, $PlaceholderTransformer.prototype, "transformFunctionBody", [tree]); }, transformMemberExpression: function(tree) { var value = this.getValue_(tree.memberName.value); if (value === NOT_FOUND) return $traceurRuntime.superCall(this, $PlaceholderTransformer.prototype, "transformMemberExpression", [tree]); var operand = this.transformAny(tree.operand); return createMemberExpression(operand, value); }, transformLiteralPropertyName: function(tree) { if (tree.literalToken.type === IDENTIFIER) { var value = this.getValue_(tree.literalToken.value); if (value !== NOT_FOUND) { return new LiteralPropertyName(null, convertValueToIdentifierToken(value)); } } return $traceurRuntime.superCall(this, $PlaceholderTransformer.prototype, "transformLiteralPropertyName", [tree]); }, transformArgumentList: function(tree) { if (tree.args.length === 1 && tree.args[0].type === IDENTIFIER_EXPRESSION) { var arg0 = this.transformAny(tree.args[0]); if (arg0 === tree.args[0]) return tree; if (arg0.type === ARGUMENT_LIST) return arg0; } return $traceurRuntime.superCall(this, $PlaceholderTransformer.prototype, "transformArgumentList", [tree]); } }, {}, ParseTreeTransformer); return { get parseExpression() { return parseExpression; }, get parseStatement() { return parseStatement; }, get parseStatements() { return parseStatements; }, get parsePropertyDefinition() { return parsePropertyDefinition; }, get PlaceholderParser() { return PlaceholderParser; }, get PlaceholderTransformer() { return PlaceholderTransformer; } }; }); System.register("traceur@0.0.52/src/codegeneration/PrependStatements", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/PrependStatements"; var $__172 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), EXPRESSION_STATEMENT = $__172.EXPRESSION_STATEMENT, LITERAL_EXPRESSION = $__172.LITERAL_EXPRESSION; var STRING = System.get("traceur@0.0.52/src/syntax/TokenType").STRING; function isStringExpressionStatement(tree) { return tree.type === EXPRESSION_STATEMENT && tree.expression.type === LITERAL_EXPRESSION && tree.expression.literalToken.type === STRING; } function prependStatements(statements) { for (var statementsToPrepend = [], $__174 = 1; $__174 < arguments.length; $__174++) statementsToPrepend[$__174 - 1] = arguments[$__174]; if (!statements.length) return statementsToPrepend; if (!statementsToPrepend.length) return statements; var transformed = []; var inProlog = true; statements.forEach((function(statement) { var $__175; if (inProlog && !isStringExpressionStatement(statement)) { ($__175 = transformed).push.apply($__175, $traceurRuntime.spread(statementsToPrepend)); inProlog = false; } transformed.push(statement); })); return transformed; } return {get prependStatements() { return prependStatements; }}; }); System.register("traceur@0.0.52/src/codegeneration/TempVarTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/TempVarTransformer"; var ParseTreeTransformer = System.get("traceur@0.0.52/src/codegeneration/ParseTreeTransformer").ParseTreeTransformer; var $__177 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), Module = $__177.Module, Script = $__177.Script; var ARGUMENTS = System.get("traceur@0.0.52/src/syntax/PredefinedName").ARGUMENTS; var VAR = System.get("traceur@0.0.52/src/syntax/TokenType").VAR; var $__180 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createFunctionBody = $__180.createFunctionBody, createThisExpression = $__180.createThisExpression, createIdentifierExpression = $__180.createIdentifierExpression, createVariableDeclaration = $__180.createVariableDeclaration, createVariableDeclarationList = $__180.createVariableDeclarationList, createVariableStatement = $__180.createVariableStatement; var prependStatements = System.get("traceur@0.0.52/src/codegeneration/PrependStatements").prependStatements; var TempVarStatement = function TempVarStatement(name, initializer) { this.name = name; this.initializer = initializer; }; ($traceurRuntime.createClass)(TempVarStatement, {}, {}); var TempScope = function TempScope() { this.identifiers = []; }; ($traceurRuntime.createClass)(TempScope, { push: function(identifier) { this.identifiers.push(identifier); }, pop: function() { return this.identifiers.pop(); }, release: function(obj) { for (var i = this.identifiers.length - 1; i >= 0; i--) { obj.release_(this.identifiers[i]); } } }, {}); var VarScope = function VarScope() { this.thisName = null; this.argumentName = null; this.tempVarStatements = []; }; ($traceurRuntime.createClass)(VarScope, { push: function(tempVarStatement) { this.tempVarStatements.push(tempVarStatement); }, pop: function() { return this.tempVarStatements.pop(); }, release: function(obj) { for (var i = this.tempVarStatements.length - 1; i >= 0; i--) { obj.release_(this.tempVarStatements[i].name); } }, isEmpty: function() { return !this.tempVarStatements.length; }, createVariableStatement: function() { var declarations = []; var seenNames = Object.create(null); for (var i = 0; i < this.tempVarStatements.length; i++) { var $__183 = $traceurRuntime.assertObject(this.tempVarStatements[i]), name = $__183.name, initializer = $__183.initializer; if (name in seenNames) { if (seenNames[name].initializer || initializer) throw new Error('Invalid use of TempVarTransformer'); continue; } seenNames[name] = true; declarations.push(createVariableDeclaration(name, initializer)); } return createVariableStatement(createVariableDeclarationList(VAR, declarations)); } }, {}); var TempVarTransformer = function TempVarTransformer(identifierGenerator) { $traceurRuntime.superCall(this, $TempVarTransformer.prototype, "constructor", []); this.identifierGenerator = identifierGenerator; this.tempVarStack_ = [new VarScope()]; this.tempScopeStack_ = [new TempScope()]; this.namePool_ = []; }; var $TempVarTransformer = TempVarTransformer; ($traceurRuntime.createClass)(TempVarTransformer, { transformStatements_: function(statements) { this.tempVarStack_.push(new VarScope()); var transformedStatements = this.transformList(statements); var vars = this.tempVarStack_.pop(); if (vars.isEmpty()) return transformedStatements; var variableStatement = vars.createVariableStatement(); vars.release(this); return prependStatements(transformedStatements, variableStatement); }, transformScript: function(tree) { var scriptItemList = this.transformStatements_(tree.scriptItemList); if (scriptItemList == tree.scriptItemList) { return tree; } return new Script(tree.location, scriptItemList, tree.moduleName); }, transformModule: function(tree) { var scriptItemList = this.transformStatements_(tree.scriptItemList); if (scriptItemList == tree.scriptItemList) { return tree; } return new Module(tree.location, scriptItemList, tree.moduleName); }, transformFunctionBody: function(tree) { this.pushTempScope(); var statements = this.transformStatements_(tree.statements); this.popTempScope(); if (statements == tree.statements) return tree; return createFunctionBody(statements); }, getTempIdentifier: function() { var name = this.getName_(); this.tempScopeStack_[this.tempScopeStack_.length - 1].push(name); return name; }, getName_: function() { return this.namePool_.length ? this.namePool_.pop() : this.identifierGenerator.generateUniqueIdentifier(); }, addTempVar: function() { var initializer = arguments[0] !== (void 0) ? arguments[0] : null; var vars = this.tempVarStack_[this.tempVarStack_.length - 1]; var name = this.getName_(); vars.push(new TempVarStatement(name, initializer)); return name; }, addTempVarForThis: function() { var varScope = this.tempVarStack_[this.tempVarStack_.length - 1]; return varScope.thisName || (varScope.thisName = this.addTempVar(createThisExpression())); }, addTempVarForArguments: function() { var varScope = this.tempVarStack_[this.tempVarStack_.length - 1]; return varScope.argumentName || (varScope.argumentName = this.addTempVar(createIdentifierExpression(ARGUMENTS))); }, pushTempScope: function() { this.tempScopeStack_.push(new TempScope()); }, popTempScope: function() { this.tempScopeStack_.pop().release(this); }, release_: function(name) { this.namePool_.push(name); } }, {}, ParseTreeTransformer); return {get TempVarTransformer() { return TempVarTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/DestructuringTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/DestructuringTransformer"; var $__184 = Object.freeze(Object.defineProperties(["$traceurRuntime.assertObject(", ")"], {raw: {value: Object.freeze(["$traceurRuntime.assertObject(", ")"])}})), $__185 = Object.freeze(Object.defineProperties(["", " = ", ""], {raw: {value: Object.freeze(["", " = ", ""])}})), $__186 = Object.freeze(Object.defineProperties(["Array.prototype.slice.call(", ", ", ")"], {raw: {value: Object.freeze(["Array.prototype.slice.call(", ", ", ")"])}})), $__187 = Object.freeze(Object.defineProperties(["(", " = ", ".", ") === void 0 ?\n ", " : ", ""], {raw: {value: Object.freeze(["(", " = ", ".", ") === void 0 ?\n ", " : ", ""])}})), $__188 = Object.freeze(Object.defineProperties(["(", " = ", "[", "]) === void 0 ?\n ", " : ", ""], {raw: {value: Object.freeze(["(", " = ", "[", "]) === void 0 ?\n ", " : ", ""])}})); var $__189 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), ARRAY_COMPREHENSION = $__189.ARRAY_COMPREHENSION, ARRAY_LITERAL_EXPRESSION = $__189.ARRAY_LITERAL_EXPRESSION, ARRAY_PATTERN = $__189.ARRAY_PATTERN, ASSIGNMENT_ELEMENT = $__189.ASSIGNMENT_ELEMENT, ARROW_FUNCTION_EXPRESSION = $__189.ARROW_FUNCTION_EXPRESSION, BINDING_ELEMENT = $__189.BINDING_ELEMENT, BINDING_IDENTIFIER = $__189.BINDING_IDENTIFIER, BLOCK = $__189.BLOCK, CALL_EXPRESSION = $__189.CALL_EXPRESSION, CLASS_EXPRESSION = $__189.CLASS_EXPRESSION, COMPUTED_PROPERTY_NAME = $__189.COMPUTED_PROPERTY_NAME, FUNCTION_EXPRESSION = $__189.FUNCTION_EXPRESSION, GENERATOR_COMPREHENSION = $__189.GENERATOR_COMPREHENSION, IDENTIFIER_EXPRESSION = $__189.IDENTIFIER_EXPRESSION, LITERAL_EXPRESSION = $__189.LITERAL_EXPRESSION, MEMBER_EXPRESSION = $__189.MEMBER_EXPRESSION, MEMBER_LOOKUP_EXPRESSION = $__189.MEMBER_LOOKUP_EXPRESSION, OBJECT_LITERAL_EXPRESSION = $__189.OBJECT_LITERAL_EXPRESSION, OBJECT_PATTERN = $__189.OBJECT_PATTERN, OBJECT_PATTERN_FIELD = $__189.OBJECT_PATTERN_FIELD, PAREN_EXPRESSION = $__189.PAREN_EXPRESSION, THIS_EXPRESSION = $__189.THIS_EXPRESSION, VARIABLE_DECLARATION_LIST = $__189.VARIABLE_DECLARATION_LIST; var $__190 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), AssignmentElement = $__190.AssignmentElement, BindingElement = $__190.BindingElement, Catch = $__190.Catch, ForInStatement = $__190.ForInStatement, ForOfStatement = $__190.ForOfStatement; var TempVarTransformer = System.get("traceur@0.0.52/src/codegeneration/TempVarTransformer").TempVarTransformer; var $__192 = System.get("traceur@0.0.52/src/syntax/TokenType"), EQUAL = $__192.EQUAL, LET = $__192.LET, REGULAR_EXPRESSION = $__192.REGULAR_EXPRESSION, VAR = $__192.VAR; var $__193 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createAssignmentExpression = $__193.createAssignmentExpression, createBindingIdentifier = $__193.createBindingIdentifier, createBlock = $__193.createBlock, createCommaExpression = $__193.createCommaExpression, createExpressionStatement = $__193.createExpressionStatement, createFunctionBody = $__193.createFunctionBody, createIdentifierExpression = $__193.createIdentifierExpression, createMemberExpression = $__193.createMemberExpression, createMemberLookupExpression = $__193.createMemberLookupExpression, createNumberLiteral = $__193.createNumberLiteral, createParenExpression = $__193.createParenExpression, createVariableDeclaration = $__193.createVariableDeclaration, createVariableDeclarationList = $__193.createVariableDeclarationList, createVariableStatement = $__193.createVariableStatement; var options = System.get("traceur@0.0.52/src/Options").options; var parseExpression = System.get("traceur@0.0.52/src/codegeneration/PlaceholderParser").parseExpression; var prependStatements = System.get("traceur@0.0.52/src/codegeneration/PrependStatements").prependStatements; var Desugaring = function Desugaring(rvalue) { this.rvalue = rvalue; }; ($traceurRuntime.createClass)(Desugaring, {}, {}); var AssignmentExpressionDesugaring = function AssignmentExpressionDesugaring(rvalue) { $traceurRuntime.superCall(this, $AssignmentExpressionDesugaring.prototype, "constructor", [rvalue]); this.expressions = []; }; var $AssignmentExpressionDesugaring = AssignmentExpressionDesugaring; ($traceurRuntime.createClass)(AssignmentExpressionDesugaring, {assign: function(lvalue, rvalue) { lvalue = lvalue instanceof AssignmentElement ? lvalue.assignment : lvalue; this.expressions.push(createAssignmentExpression(lvalue, rvalue)); }}, {}, Desugaring); var VariableDeclarationDesugaring = function VariableDeclarationDesugaring(rvalue) { $traceurRuntime.superCall(this, $VariableDeclarationDesugaring.prototype, "constructor", [rvalue]); this.declarations = []; }; var $VariableDeclarationDesugaring = VariableDeclarationDesugaring; ($traceurRuntime.createClass)(VariableDeclarationDesugaring, {assign: function(lvalue, rvalue) { var binding = lvalue instanceof BindingElement ? lvalue.binding : createBindingIdentifier(lvalue); this.declarations.push(createVariableDeclaration(binding, rvalue)); }}, {}, Desugaring); function staticallyKnownObject(tree) { switch (tree.type) { case OBJECT_LITERAL_EXPRESSION: case ARRAY_LITERAL_EXPRESSION: case ARRAY_COMPREHENSION: case GENERATOR_COMPREHENSION: case ARROW_FUNCTION_EXPRESSION: case FUNCTION_EXPRESSION: case CLASS_EXPRESSION: case THIS_EXPRESSION: return true; case LITERAL_EXPRESSION: return tree.literalToken.type === REGULAR_EXPRESSION; } return false; } var DestructuringTransformer = function DestructuringTransformer(identifierGenerator) { $traceurRuntime.superCall(this, $DestructuringTransformer.prototype, "constructor", [identifierGenerator]); this.parameterDeclarations = null; }; var $DestructuringTransformer = DestructuringTransformer; ($traceurRuntime.createClass)(DestructuringTransformer, { transformArrayPattern: function(tree) { throw new Error('unreachable'); }, transformObjectPattern: function(tree) { throw new Error('unreachable'); }, transformBinaryExpression: function(tree) { this.pushTempScope(); var rv; if (tree.operator.type == EQUAL && tree.left.isPattern()) { rv = this.transformAny(this.desugarAssignment_(tree.left, tree.right)); } else { rv = $traceurRuntime.superCall(this, $DestructuringTransformer.prototype, "transformBinaryExpression", [tree]); } this.popTempScope(); return rv; }, desugarAssignment_: function(lvalue, rvalue) { var tempIdent = createIdentifierExpression(this.addTempVar()); var desugaring = new AssignmentExpressionDesugaring(tempIdent); this.desugarPattern_(desugaring, lvalue); desugaring.expressions.unshift(this.createGuardedAssignment(tempIdent, rvalue)); desugaring.expressions.push(tempIdent); return createParenExpression(createCommaExpression(desugaring.expressions)); }, transformVariableDeclarationList: function(tree) { var $__197 = this; if (!this.destructuringInDeclaration_(tree)) { return $traceurRuntime.superCall(this, $DestructuringTransformer.prototype, "transformVariableDeclarationList", [tree]); } this.pushTempScope(); var desugaredDeclarations = []; tree.declarations.forEach((function(declaration) { var $__199; if (declaration.lvalue.isPattern()) { ($__199 = desugaredDeclarations).push.apply($__199, $traceurRuntime.spread($__197.desugarVariableDeclaration_(declaration))); } else { desugaredDeclarations.push(declaration); } })); var transformedTree = this.transformVariableDeclarationList(createVariableDeclarationList(tree.declarationType, desugaredDeclarations)); this.popTempScope(); return transformedTree; }, transformForInStatement: function(tree) { return this.transformForInOrOf_(tree, $traceurRuntime.superGet(this, $DestructuringTransformer.prototype, "transformForInStatement"), ForInStatement); }, transformForOfStatement: function(tree) { return this.transformForInOrOf_(tree, $traceurRuntime.superGet(this, $DestructuringTransformer.prototype, "transformForOfStatement"), ForOfStatement); }, transformForInOrOf_: function(tree, superMethod, constr) { var $__199; if (!tree.initializer.isPattern() && (tree.initializer.type !== VARIABLE_DECLARATION_LIST || !this.destructuringInDeclaration_(tree.initializer))) { return superMethod.call(this, tree); } this.pushTempScope(); var declarationType, lvalue; if (tree.initializer.isPattern()) { declarationType = null; lvalue = tree.initializer; } else { declarationType = tree.initializer.declarationType; lvalue = tree.initializer.declarations[0].lvalue; } var statements = []; var binding = this.desugarBinding_(lvalue, statements, declarationType); var initializer = createVariableDeclarationList(VAR, binding, null); var collection = this.transformAny(tree.collection); var body = this.transformAny(tree.body); if (body.type === BLOCK) ($__199 = statements).push.apply($__199, $traceurRuntime.spread(body.statements)); else statements.push(body); body = createBlock(statements); this.popTempScope(); return new constr(tree.location, initializer, collection, body); }, transformAssignmentElement: function(tree) { throw new Error('unreachable'); }, transformBindingElement: function(tree) { if (!tree.binding.isPattern() || tree.initializer) return tree; if (this.parameterDeclarations === null) { this.parameterDeclarations = []; this.pushTempScope(); } var varName = this.getTempIdentifier(); var binding = createBindingIdentifier(varName); var initializer = createIdentifierExpression(varName); var decl = createVariableDeclaration(tree.binding, initializer); this.parameterDeclarations.push(decl); return new BindingElement(null, binding, null); }, transformFunctionBody: function(tree) { if (this.parameterDeclarations === null) return $traceurRuntime.superCall(this, $DestructuringTransformer.prototype, "transformFunctionBody", [tree]); var list = createVariableDeclarationList(VAR, this.parameterDeclarations); var statement = createVariableStatement(list); var statements = prependStatements(tree.statements, statement); var newBody = createFunctionBody(statements); this.parameterDeclarations = null; var result = $traceurRuntime.superCall(this, $DestructuringTransformer.prototype, "transformFunctionBody", [newBody]); this.popTempScope(); return result; }, transformCatch: function(tree) { var $__199; if (!tree.binding.isPattern()) return $traceurRuntime.superCall(this, $DestructuringTransformer.prototype, "transformCatch", [tree]); var body = this.transformAny(tree.catchBody); var statements = []; var kind = options.blockBinding ? LET : VAR; var binding = this.desugarBinding_(tree.binding, statements, kind); ($__199 = statements).push.apply($__199, $traceurRuntime.spread(body.statements)); return new Catch(tree.location, binding, createBlock(statements)); }, desugarBinding_: function(bindingTree, statements, declarationType) { var varName = this.getTempIdentifier(); var binding = createBindingIdentifier(varName); var idExpr = createIdentifierExpression(varName); var desugaring; if (declarationType === null) desugaring = new AssignmentExpressionDesugaring(idExpr); else desugaring = new VariableDeclarationDesugaring(idExpr); this.desugarPattern_(desugaring, bindingTree); if (declarationType === null) { statements.push(createExpressionStatement(createCommaExpression(desugaring.expressions))); } else { statements.push(createVariableStatement(this.transformVariableDeclarationList(createVariableDeclarationList(declarationType, desugaring.declarations)))); } return binding; }, destructuringInDeclaration_: function(tree) { return tree.declarations.some((function(declaration) { return declaration.lvalue.isPattern(); })); }, createGuardedExpression: function(tree) { if (staticallyKnownObject(tree)) return tree; return parseExpression($__184, tree); }, createGuardedAssignment: function(lvalue, rvalue) { return parseExpression($__185, lvalue, this.createGuardedExpression(rvalue)); }, desugarVariableDeclaration_: function(tree) { var tempRValueName = this.getTempIdentifier(); var tempRValueIdent = createIdentifierExpression(tempRValueName); var desugaring; var initializer; switch (tree.initializer.type) { case ARRAY_LITERAL_EXPRESSION: case CALL_EXPRESSION: case IDENTIFIER_EXPRESSION: case LITERAL_EXPRESSION: case MEMBER_EXPRESSION: case MEMBER_LOOKUP_EXPRESSION: case OBJECT_LITERAL_EXPRESSION: case PAREN_EXPRESSION: initializer = tree.initializer; default: desugaring = new VariableDeclarationDesugaring(tempRValueIdent); desugaring.assign(desugaring.rvalue, this.createGuardedExpression(tree.initializer)); var initializerFound = this.desugarPattern_(desugaring, tree.lvalue); if (initializerFound || desugaring.declarations.length > 2) return desugaring.declarations; initializer = this.createGuardedExpression(initializer || tree.initializer); desugaring = new VariableDeclarationDesugaring(initializer); this.desugarPattern_(desugaring, tree.lvalue); return desugaring.declarations; } }, desugarPattern_: function(desugaring, tree) { var $__197 = this; var initializerFound = false; switch (tree.type) { case ARRAY_PATTERN: var pattern = tree; for (var i = 0; i < pattern.elements.length; i++) { var lvalue = pattern.elements[i]; if (lvalue === null) { continue; } else if (lvalue.isSpreadPatternElement()) { desugaring.assign(lvalue.lvalue, parseExpression($__186, desugaring.rvalue, i)); } else { if (lvalue.initializer) initializerFound = true; desugaring.assign(lvalue, this.createConditionalMemberLookupExpression(desugaring.rvalue, createNumberLiteral(i), lvalue.initializer)); } } break; case OBJECT_PATTERN: var pattern = tree; var elementHelper = (function(lvalue, initializer) { if (initializer) initializerFound = true; var lookup = $__197.createConditionalMemberExpression(desugaring.rvalue, lvalue, initializer); desugaring.assign(lvalue, lookup); }); pattern.fields.forEach((function(field) { var lookup; switch (field.type) { case ASSIGNMENT_ELEMENT: elementHelper(field.assignment, field.initializer); break; case BINDING_ELEMENT: elementHelper(field.binding, field.initializer); break; case OBJECT_PATTERN_FIELD: if (field.element.initializer) initializerFound = true; var name = field.name; lookup = $__197.createConditionalMemberExpression(desugaring.rvalue, name, field.element.initializer); desugaring.assign(field.element, lookup); break; default: throw Error('unreachable'); } })); break; case PAREN_EXPRESSION: return this.desugarPattern_(desugaring, tree.expression); default: throw new Error('unreachable'); } if (desugaring instanceof VariableDeclarationDesugaring && desugaring.declarations.length === 0) { desugaring.assign(createBindingIdentifier(this.getTempIdentifier()), desugaring.rvalue); } return initializerFound; }, createConditionalMemberExpression: function(rvalue, name, initializer) { if (name.type === COMPUTED_PROPERTY_NAME) { return this.createConditionalMemberLookupExpression(rvalue, name.expression, initializer); } var token; switch (name.type) { case BINDING_IDENTIFIER: case IDENTIFIER_EXPRESSION: token = name.identifierToken; break; default: token = name.literalToken; } if (!initializer) return createMemberExpression(rvalue, token); var tempIdent = createIdentifierExpression(this.addTempVar()); return parseExpression($__187, tempIdent, rvalue, token, initializer, tempIdent); }, createConditionalMemberLookupExpression: function(rvalue, index, initializer) { if (!initializer) return createMemberLookupExpression(rvalue, index); var tempIdent = createIdentifierExpression(this.addTempVar()); return parseExpression($__188, tempIdent, rvalue, index, initializer, tempIdent); } }, {}, TempVarTransformer); return {get DestructuringTransformer() { return DestructuringTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/module/ModuleSymbol", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/module/ModuleSymbol"; var assert = System.get("traceur@0.0.52/src/util/assert").assert; var ExportsList = function ExportsList(normalizedName) { this.exports_ = Object.create(null); if (normalizedName !== null) this.normalizedName = normalizedName.replace(/\\/g, '/'); else this.normalizedName = null; }; ($traceurRuntime.createClass)(ExportsList, { addExport: function(name, tree) { assert(!this.exports_[name]); this.exports_[name] = tree; }, getExport: function(name) { return this.exports_[name]; }, getExports: function() { return Object.keys(this.exports_); } }, {}); var ModuleDescription = function ModuleDescription(normalizedName, module) { var $__201 = this; $traceurRuntime.superCall(this, $ModuleDescription.prototype, "constructor", [normalizedName]); Object.getOwnPropertyNames(module).forEach((function(name) { $__201.addExport(name, true); })); }; var $ModuleDescription = ModuleDescription; ($traceurRuntime.createClass)(ModuleDescription, {}, {}, ExportsList); var ModuleSymbol = function ModuleSymbol(tree, normalizedName) { $traceurRuntime.superCall(this, $ModuleSymbol.prototype, "constructor", [normalizedName]); this.tree = tree; this.imports_ = Object.create(null); }; var $ModuleSymbol = ModuleSymbol; ($traceurRuntime.createClass)(ModuleSymbol, { addImport: function(name, tree) { assert(!this.imports_[name]); this.imports_[name] = tree; }, getImport: function(name) { return this.imports_[name]; } }, {}, ExportsList); return { get ModuleDescription() { return ModuleDescription; }, get ModuleSymbol() { return ModuleSymbol; } }; }); System.register("traceur@0.0.52/src/codegeneration/module/ModuleVisitor", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/module/ModuleVisitor"; var ModuleDescription = System.get("traceur@0.0.52/src/codegeneration/module/ModuleSymbol").ModuleDescription; var ParseTreeVisitor = System.get("traceur@0.0.52/src/syntax/ParseTreeVisitor").ParseTreeVisitor; var $__205 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), MODULE_DECLARATION = $__205.MODULE_DECLARATION, EXPORT_DECLARATION = $__205.EXPORT_DECLARATION, IMPORT_DECLARATION = $__205.IMPORT_DECLARATION; var ModuleVisitor = function ModuleVisitor(reporter, loader, moduleSymbol) { this.reporter = reporter; this.loader_ = loader; this.moduleSymbol = moduleSymbol; }; ($traceurRuntime.createClass)(ModuleVisitor, { getModuleDescriptionFromCodeUnit_: function(name, codeUnitToModuleInfo) { var referrer = this.moduleSymbol.normalizedName; var codeUnit = this.loader_.getCodeUnitForModuleSpecifier(name, referrer); var moduleDescription = codeUnitToModuleInfo(codeUnit); if (!moduleDescription) { var msg = (name + " is not a module, required by " + referrer); this.reportError(codeUnit.metadata.tree, msg); return null; } return moduleDescription; }, getModuleSymbolForModuleSpecifier: function(name) { return this.getModuleDescriptionFromCodeUnit_(name, (function(codeUnit) { return codeUnit.metadata.moduleSymbol; })); }, getModuleDescriptionForModuleSpecifier: function(name) { return this.getModuleDescriptionFromCodeUnit_(name, (function(codeUnit) { var moduleDescription = codeUnit.metadata.moduleSymbol; if (!moduleDescription && codeUnit.result) { moduleDescription = new ModuleDescription(codeUnit.normalizedName, codeUnit.result); } return moduleDescription; })); }, visitFunctionDeclaration: function(tree) {}, visitFunctionExpression: function(tree) {}, visitFunctionBody: function(tree) {}, visitBlock: function(tree) {}, visitClassDeclaration: function(tree) {}, visitClassExpression: function(tree) {}, visitModuleElement_: function(element) { switch (element.type) { case MODULE_DECLARATION: case EXPORT_DECLARATION: case IMPORT_DECLARATION: this.visitAny(element); } }, visitScript: function(tree) { tree.scriptItemList.forEach(this.visitModuleElement_, this); }, visitModule: function(tree) { tree.scriptItemList.forEach(this.visitModuleElement_, this); }, reportError: function(tree, message) { this.reporter.reportError(tree.location.start, message); } }, {}, ParseTreeVisitor); return {get ModuleVisitor() { return ModuleVisitor; }}; }); System.register("traceur@0.0.52/src/codegeneration/module/ExportVisitor", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/module/ExportVisitor"; var ModuleVisitor = System.get("traceur@0.0.52/src/codegeneration/module/ModuleVisitor").ModuleVisitor; var assert = System.get("traceur@0.0.52/src/util/assert").assert; var ExportVisitor = function ExportVisitor(reporter, loaderHooks, moduleSymbol) { $traceurRuntime.superCall(this, $ExportVisitor.prototype, "constructor", [reporter, loaderHooks, moduleSymbol]); this.inExport_ = false; this.moduleSpecifier = null; }; var $ExportVisitor = ExportVisitor; ($traceurRuntime.createClass)(ExportVisitor, { addExport_: function(name, tree) { assert(typeof name == 'string'); if (this.inExport_) this.addExport(name, tree); }, addExport: function(name, tree) { var moduleSymbol = this.moduleSymbol; var existingExport = moduleSymbol.getExport(name); if (existingExport) { this.reportError(tree, ("Duplicate export. '" + name + "' was previously ") + ("exported at " + existingExport.location.start)); } else { moduleSymbol.addExport(name, tree); } }, visitClassDeclaration: function(tree) { this.addExport_(tree.name.identifierToken.value, tree); }, visitExportDeclaration: function(tree) { this.inExport_ = true; this.visitAny(tree.declaration); this.inExport_ = false; }, visitNamedExport: function(tree) { this.moduleSpecifier = tree.moduleSpecifier; this.visitAny(tree.specifierSet); this.moduleSpecifier = null; }, visitExportDefault: function(tree) { this.addExport_('default', tree); }, visitExportSpecifier: function(tree) { this.addExport_((tree.rhs || tree.lhs).value, tree); }, visitExportStar: function(tree) { var $__209 = this; var name = this.moduleSpecifier.token.processedValue; var moduleDescription = this.getModuleDescriptionForModuleSpecifier(name); if (moduleDescription) { moduleDescription.getExports().forEach((function(name) { $__209.addExport(name, tree); })); } }, visitFunctionDeclaration: function(tree) { this.addExport_(tree.name.identifierToken.value, tree); }, visitModuleDeclaration: function(tree) { this.addExport_(tree.identifier.value, tree); }, visitVariableDeclaration: function(tree) { this.addExport_(tree.lvalue.identifierToken.value, tree); } }, {}, ModuleVisitor); return {get ExportVisitor() { return ExportVisitor; }}; }); System.register("traceur@0.0.52/src/codegeneration/module/DirectExportVisitor", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/module/DirectExportVisitor"; var ExportVisitor = System.get("traceur@0.0.52/src/codegeneration/module/ExportVisitor").ExportVisitor; var DirectExportVisitor = function DirectExportVisitor() { $traceurRuntime.superCall(this, $DirectExportVisitor.prototype, "constructor", [null, null, null]); this.namedExports = []; this.starExports = []; }; var $DirectExportVisitor = DirectExportVisitor; ($traceurRuntime.createClass)(DirectExportVisitor, { addExport: function(name, tree) { this.namedExports.push({ name: name, tree: tree, moduleSpecifier: this.moduleSpecifier }); }, visitExportStar: function(tree) { this.starExports.push(this.moduleSpecifier); }, hasExports: function() { return this.namedExports.length != 0 || this.starExports.length != 0; } }, {}, ExportVisitor); return {get DirectExportVisitor() { return DirectExportVisitor; }}; }); System.register("traceur@0.0.52/src/codegeneration/ModuleTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/ModuleTransformer"; var $__213 = Object.freeze(Object.defineProperties(["var __moduleName = ", ";"], {raw: {value: Object.freeze(["var __moduleName = ", ";"])}})), $__214 = Object.freeze(Object.defineProperties(["function() {\n ", "\n }"], {raw: {value: Object.freeze(["function() {\n ", "\n }"])}})), $__215 = Object.freeze(Object.defineProperties(["$traceurRuntime.ModuleStore.getAnonymousModule(\n ", ");"], {raw: {value: Object.freeze(["$traceurRuntime.ModuleStore.getAnonymousModule(\n ", ");"])}})), $__216 = Object.freeze(Object.defineProperties(["System.register(", ", [], ", ");"], {raw: {value: Object.freeze(["System.register(", ", [], ", ");"])}})), $__217 = Object.freeze(Object.defineProperties(["get ", "() { return ", "; }"], {raw: {value: Object.freeze(["get ", "() { return ", "; }"])}})), $__218 = Object.freeze(Object.defineProperties(["$traceurRuntime.exportStar(", ")"], {raw: {value: Object.freeze(["$traceurRuntime.exportStar(", ")"])}})), $__219 = Object.freeze(Object.defineProperties(["return ", ""], {raw: {value: Object.freeze(["return ", ""])}})), $__220 = Object.freeze(Object.defineProperties(["var $__default = ", ""], {raw: {value: Object.freeze(["var $__default = ", ""])}})), $__221 = Object.freeze(Object.defineProperties(["var $__default = ", ""], {raw: {value: Object.freeze(["var $__default = ", ""])}})), $__222 = Object.freeze(Object.defineProperties(["System.get(", ")"], {raw: {value: Object.freeze(["System.get(", ")"])}})); var $__223 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), AnonBlock = $__223.AnonBlock, BindingElement = $__223.BindingElement, BindingIdentifier = $__223.BindingIdentifier, EmptyStatement = $__223.EmptyStatement, LiteralPropertyName = $__223.LiteralPropertyName, ObjectPattern = $__223.ObjectPattern, ObjectPatternField = $__223.ObjectPatternField, Script = $__223.Script; var DestructuringTransformer = System.get("traceur@0.0.52/src/codegeneration/DestructuringTransformer").DestructuringTransformer; var DirectExportVisitor = System.get("traceur@0.0.52/src/codegeneration/module/DirectExportVisitor").DirectExportVisitor; var TempVarTransformer = System.get("traceur@0.0.52/src/codegeneration/TempVarTransformer").TempVarTransformer; var $__227 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), CLASS_DECLARATION = $__227.CLASS_DECLARATION, EXPORT_DEFAULT = $__227.EXPORT_DEFAULT, EXPORT_SPECIFIER = $__227.EXPORT_SPECIFIER, FUNCTION_DECLARATION = $__227.FUNCTION_DECLARATION, IMPORT_SPECIFIER_SET = $__227.IMPORT_SPECIFIER_SET; var VAR = System.get("traceur@0.0.52/src/syntax/TokenType").VAR; var assert = System.get("traceur@0.0.52/src/util/assert").assert; var $__230 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createArgumentList = $__230.createArgumentList, createBindingIdentifier = $__230.createBindingIdentifier, createExpressionStatement = $__230.createExpressionStatement, createIdentifierExpression = $__230.createIdentifierExpression, createIdentifierToken = $__230.createIdentifierToken, createMemberExpression = $__230.createMemberExpression, createObjectLiteralExpression = $__230.createObjectLiteralExpression, createUseStrictDirective = $__230.createUseStrictDirective, createVariableStatement = $__230.createVariableStatement; var $__231 = System.get("traceur@0.0.52/src/Options"), parseOptions = $__231.parseOptions, transformOptions = $__231.transformOptions; var $__232 = System.get("traceur@0.0.52/src/codegeneration/PlaceholderParser"), parseExpression = $__232.parseExpression, parsePropertyDefinition = $__232.parsePropertyDefinition, parseStatement = $__232.parseStatement, parseStatements = $__232.parseStatements; var DestructImportVarStatement = function DestructImportVarStatement() { $traceurRuntime.defaultSuperCall(this, $DestructImportVarStatement.prototype, arguments); }; var $DestructImportVarStatement = DestructImportVarStatement; ($traceurRuntime.createClass)(DestructImportVarStatement, {createGuardedExpression: function(tree) { return tree; }}, {}, DestructuringTransformer); var ModuleTransformer = function ModuleTransformer(identifierGenerator) { $traceurRuntime.superCall(this, $ModuleTransformer.prototype, "constructor", [identifierGenerator]); this.exportVisitor_ = new DirectExportVisitor(); this.moduleSpecifierKind_ = null; this.moduleName = null; }; var $ModuleTransformer = ModuleTransformer; ($traceurRuntime.createClass)(ModuleTransformer, { getTempVarNameForModuleName: function(moduleName) { return '$__' + moduleName.replace(/[^a-zA-Z0-9$]/g, function(c) { return '_' + c.charCodeAt(0) + '_'; }) + '__'; }, getTempVarNameForModuleSpecifier: function(moduleSpecifier) { var normalizedName = System.normalize(moduleSpecifier.token.processedValue, this.moduleName); return this.getTempVarNameForModuleName(normalizedName); }, transformScript: function(tree) { this.moduleName = tree.moduleName; return $traceurRuntime.superCall(this, $ModuleTransformer.prototype, "transformScript", [tree]); }, transformModule: function(tree) { this.moduleName = tree.moduleName; this.pushTempScope(); var statements = this.transformList(tree.scriptItemList); statements = this.appendExportStatement(statements); this.popTempScope(); statements = this.wrapModule(this.moduleProlog().concat(statements)); return new Script(tree.location, statements); }, moduleProlog: function() { var statements = [createUseStrictDirective()]; if (this.moduleName) statements.push(parseStatement($__213, this.moduleName)); return statements; }, wrapModule: function(statements) { var functionExpression = parseExpression($__214, statements); if (this.moduleName === null) { return parseStatements($__215, functionExpression); } return parseStatements($__216, this.moduleName, functionExpression); }, getGetterExport: function($__235) { var $__236 = $traceurRuntime.assertObject($__235), name = $__236.name, tree = $__236.tree, moduleSpecifier = $__236.moduleSpecifier; var returnExpression; switch (tree.type) { case EXPORT_DEFAULT: returnExpression = createIdentifierExpression('$__default'); break; case EXPORT_SPECIFIER: if (moduleSpecifier) { var idName = this.getTempVarNameForModuleSpecifier(moduleSpecifier); returnExpression = createMemberExpression(idName, tree.lhs); } else { returnExpression = createIdentifierExpression(tree.lhs); } break; default: returnExpression = createIdentifierExpression(name); break; } return parsePropertyDefinition($__217, name, returnExpression); }, getExportProperties: function() { var $__233 = this; return this.exportVisitor_.namedExports.map((function(exp) { return $__233.getGetterExport(exp); })).concat(this.exportVisitor_.namedExports.map((function(exp) { return $__233.getSetterExport(exp); }))).filter((function(e) { return e; })); }, getSetterExport: function($__235) { var $__236 = $traceurRuntime.assertObject($__235), name = $__236.name, tree = $__236.tree, moduleSpecifier = $__236.moduleSpecifier; return null; }, getExportObject: function() { var $__233 = this; var exportObject = createObjectLiteralExpression(this.getExportProperties()); if (this.exportVisitor_.starExports.length) { var starExports = this.exportVisitor_.starExports; var starIdents = starExports.map((function(moduleSpecifier) { return createIdentifierExpression($__233.getTempVarNameForModuleSpecifier(moduleSpecifier)); })); var args = createArgumentList($traceurRuntime.spread([exportObject], starIdents)); return parseExpression($__218, args); } return exportObject; }, appendExportStatement: function(statements) { var exportObject = this.getExportObject(); statements.push(parseStatement($__219, exportObject)); return statements; }, hasExports: function() { return this.exportVisitor_.hasExports(); }, transformExportDeclaration: function(tree) { this.exportVisitor_.visitAny(tree); return this.transformAny(tree.declaration); }, transformExportDefault: function(tree) { switch (tree.expression.type) { case CLASS_DECLARATION: case FUNCTION_DECLARATION: var nameBinding = tree.expression.name; var name = createIdentifierExpression(nameBinding.identifierToken); return new AnonBlock(null, [tree.expression, parseStatement($__220, name)]); } return parseStatement($__221, tree.expression); }, transformNamedExport: function(tree) { var moduleSpecifier = tree.moduleSpecifier; if (moduleSpecifier) { var expression = this.transformAny(moduleSpecifier); var idName = this.getTempVarNameForModuleSpecifier(moduleSpecifier); return createVariableStatement(VAR, idName, expression); } return new EmptyStatement(null); }, transformModuleSpecifier: function(tree) { assert(this.moduleName); var name = tree.token.processedValue; var normalizedName = System.normalize(name, this.moduleName); return parseExpression($__222, normalizedName); }, transformModuleDeclaration: function(tree) { this.moduleSpecifierKind_ = 'module'; var initializer = this.transformAny(tree.expression); return createVariableStatement(VAR, tree.identifier, initializer); }, transformImportedBinding: function(tree) { var bindingElement = new BindingElement(tree.location, tree.binding, null); var name = new LiteralPropertyName(null, createIdentifierToken('default')); return new ObjectPattern(null, [new ObjectPatternField(null, name, bindingElement)]); }, transformImportDeclaration: function(tree) { this.moduleSpecifierKind_ = 'import'; if (!tree.importClause || (tree.importClause.type === IMPORT_SPECIFIER_SET && tree.importClause.specifiers.length === 0)) { return createExpressionStatement(this.transformAny(tree.moduleSpecifier)); } var binding = this.transformAny(tree.importClause); var initializer = this.transformAny(tree.moduleSpecifier); var varStatement = createVariableStatement(VAR, binding, initializer); if (transformOptions.destructuring || !parseOptions.destructuring) { var destructuringTransformer = new DestructImportVarStatement(this.identifierGenerator); varStatement = varStatement.transform(destructuringTransformer); } return varStatement; }, transformImportSpecifierSet: function(tree) { var fields = this.transformList(tree.specifiers); return new ObjectPattern(null, fields); }, transformImportSpecifier: function(tree) { if (tree.rhs) { var binding = new BindingIdentifier(tree.location, tree.rhs); var bindingElement = new BindingElement(tree.location, binding, null); var name = new LiteralPropertyName(tree.lhs.location, tree.lhs); return new ObjectPatternField(tree.location, name, bindingElement); } return new BindingElement(tree.location, createBindingIdentifier(tree.lhs), null); } }, {}, TempVarTransformer); return {get ModuleTransformer() { return ModuleTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/globalThis", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/globalThis"; var $__237 = Object.freeze(Object.defineProperties(["Reflect.global"], {raw: {value: Object.freeze(["Reflect.global"])}})); var parseExpression = System.get("traceur@0.0.52/src/codegeneration/PlaceholderParser").parseExpression; var expr; function globalThis() { if (!expr) expr = parseExpression($__237); return expr; } var $__default = globalThis; return {get default() { return $__default; }}; }); System.register("traceur@0.0.52/src/codegeneration/FindInFunctionScope", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/FindInFunctionScope"; var FindVisitor = System.get("traceur@0.0.52/src/codegeneration/FindVisitor").FindVisitor; var FindInFunctionScope = function FindInFunctionScope() { $traceurRuntime.defaultSuperCall(this, $FindInFunctionScope.prototype, arguments); }; var $FindInFunctionScope = FindInFunctionScope; ($traceurRuntime.createClass)(FindInFunctionScope, { visitFunctionDeclaration: function(tree) {}, visitFunctionExpression: function(tree) {}, visitSetAccessor: function(tree) {}, visitGetAccessor: function(tree) {}, visitPropertyMethodAssignment: function(tree) {} }, {}, FindVisitor); return {get FindInFunctionScope() { return FindInFunctionScope; }}; }); System.register("traceur@0.0.52/src/codegeneration/scopeContainsThis", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/scopeContainsThis"; var FindInFunctionScope = System.get("traceur@0.0.52/src/codegeneration/FindInFunctionScope").FindInFunctionScope; var FindThis = function FindThis() { $traceurRuntime.defaultSuperCall(this, $FindThis.prototype, arguments); }; var $FindThis = FindThis; ($traceurRuntime.createClass)(FindThis, {visitThisExpression: function(tree) { this.found = true; }}, {}, FindInFunctionScope); function scopeContainsThis(tree) { var visitor = new FindThis(tree); return visitor.found; } var $__default = scopeContainsThis; return {get default() { return $__default; }}; }); System.register("traceur@0.0.52/src/codegeneration/AmdTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/AmdTransformer"; var $__243 = Object.freeze(Object.defineProperties(["__esModule: true"], {raw: {value: Object.freeze(["__esModule: true"])}})), $__244 = Object.freeze(Object.defineProperties(["if (!", " || !", ".__esModule)\n ", " = { 'default': ", " }"], {raw: {value: Object.freeze(["if (!", " || !", ".__esModule)\n ", " = { 'default': ", " }"])}})), $__245 = Object.freeze(Object.defineProperties(["function(", ") {\n ", "\n }"], {raw: {value: Object.freeze(["function(", ") {\n ", "\n }"])}})), $__246 = Object.freeze(Object.defineProperties(["", ".bind(", ")"], {raw: {value: Object.freeze(["", ".bind(", ")"])}})), $__247 = Object.freeze(Object.defineProperties(["define(", ", ", ", ", ");"], {raw: {value: Object.freeze(["define(", ", ", ", ", ");"])}})), $__248 = Object.freeze(Object.defineProperties(["define(", ", ", ");"], {raw: {value: Object.freeze(["define(", ", ", ");"])}})); var ModuleTransformer = System.get("traceur@0.0.52/src/codegeneration/ModuleTransformer").ModuleTransformer; var $__250 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createBindingIdentifier = $__250.createBindingIdentifier, createIdentifierExpression = $__250.createIdentifierExpression; var globalThis = System.get("traceur@0.0.52/src/codegeneration/globalThis").default; var $__252 = System.get("traceur@0.0.52/src/codegeneration/PlaceholderParser"), parseExpression = $__252.parseExpression, parseStatement = $__252.parseStatement, parseStatements = $__252.parseStatements, parsePropertyDefinition = $__252.parsePropertyDefinition; var scopeContainsThis = System.get("traceur@0.0.52/src/codegeneration/scopeContainsThis").default; var AmdTransformer = function AmdTransformer(identifierGenerator) { $traceurRuntime.superCall(this, $AmdTransformer.prototype, "constructor", [identifierGenerator]); this.dependencies = []; }; var $AmdTransformer = AmdTransformer; ($traceurRuntime.createClass)(AmdTransformer, { getExportProperties: function() { var properties = $traceurRuntime.superCall(this, $AmdTransformer.prototype, "getExportProperties", []); if (this.exportVisitor_.hasExports()) properties.push(parsePropertyDefinition($__243)); return properties; }, moduleProlog: function() { var locals = this.dependencies.map((function(dep) { var local = createIdentifierExpression(dep.local); return parseStatement($__244, local, local, local, local); })); return $traceurRuntime.superCall(this, $AmdTransformer.prototype, "moduleProlog", []).concat(locals); }, wrapModule: function(statements) { var depPaths = this.dependencies.map((function(dep) { return dep.path; })); var depLocals = this.dependencies.map((function(dep) { return dep.local; })); var hasTopLevelThis = statements.some(scopeContainsThis); var func = parseExpression($__245, depLocals, statements); if (hasTopLevelThis) func = parseExpression($__246, func, globalThis()); if (this.moduleName) { return parseStatements($__247, this.moduleName, depPaths, func); } else { return parseStatements($__248, depPaths, func); } }, transformModuleSpecifier: function(tree) { var localName = this.getTempIdentifier(); this.dependencies.push({ path: tree.token, local: localName }); return createBindingIdentifier(localName); } }, {}, ModuleTransformer); return {get AmdTransformer() { return AmdTransformer; }}; }); System.register("traceur@0.0.52/src/staticsemantics/PropName", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/staticsemantics/PropName"; var $__255 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), COMPUTED_PROPERTY_NAME = $__255.COMPUTED_PROPERTY_NAME, GET_ACCESSOR = $__255.GET_ACCESSOR, LITERAL_PROPERTY_NAME = $__255.LITERAL_PROPERTY_NAME, PROPERTY_METHOD_ASSIGNMENT = $__255.PROPERTY_METHOD_ASSIGNMENT, PROPERTY_NAME_ASSIGNMENT = $__255.PROPERTY_NAME_ASSIGNMENT, PROPERTY_NAME_SHORTHAND = $__255.PROPERTY_NAME_SHORTHAND, SET_ACCESSOR = $__255.SET_ACCESSOR; var IDENTIFIER = System.get("traceur@0.0.52/src/syntax/TokenType").IDENTIFIER; function propName(tree) { switch (tree.type) { case LITERAL_PROPERTY_NAME: var token = tree.literalToken; if (token.isKeyword() || token.type === IDENTIFIER) return token.toString(); return String(tree.literalToken.processedValue); case COMPUTED_PROPERTY_NAME: return ''; case PROPERTY_NAME_SHORTHAND: return tree.name.toString(); case PROPERTY_METHOD_ASSIGNMENT: case PROPERTY_NAME_ASSIGNMENT: case GET_ACCESSOR: case SET_ACCESSOR: return propName(tree.name); } } return {get propName() { return propName; }}; }); System.register("traceur@0.0.52/src/codegeneration/AnnotationsTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/AnnotationsTransformer"; var $__257 = Object.freeze(Object.defineProperties(["Object.getOwnPropertyDescriptor(", ")"], {raw: {value: Object.freeze(["Object.getOwnPropertyDescriptor(", ")"])}})); var ParseTreeTransformer = System.get("traceur@0.0.52/src/codegeneration/ParseTreeTransformer").ParseTreeTransformer; var CONSTRUCTOR = System.get("traceur@0.0.52/src/syntax/PredefinedName").CONSTRUCTOR; var STRING = System.get("traceur@0.0.52/src/syntax/TokenType").STRING; var $__261 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), AnonBlock = $__261.AnonBlock, ClassDeclaration = $__261.ClassDeclaration, ExportDeclaration = $__261.ExportDeclaration, FormalParameter = $__261.FormalParameter, FunctionDeclaration = $__261.FunctionDeclaration, GetAccessor = $__261.GetAccessor, LiteralExpression = $__261.LiteralExpression, PropertyMethodAssignment = $__261.PropertyMethodAssignment, SetAccessor = $__261.SetAccessor; var propName = System.get("traceur@0.0.52/src/staticsemantics/PropName").propName; var $__263 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createArgumentList = $__263.createArgumentList, createArrayLiteralExpression = $__263.createArrayLiteralExpression, createAssignmentStatement = $__263.createAssignmentStatement, createIdentifierExpression = $__263.createIdentifierExpression, createMemberExpression = $__263.createMemberExpression, createNewExpression = $__263.createNewExpression, createStringLiteralToken = $__263.createStringLiteralToken; var parseExpression = System.get("traceur@0.0.52/src/codegeneration/PlaceholderParser").parseExpression; var AnnotationsScope = function AnnotationsScope() { this.className = null; this.isExport = false; this.constructorParameters = []; this.annotations = []; this.metadata = []; }; ($traceurRuntime.createClass)(AnnotationsScope, {get inClassScope() { return this.className !== null; }}, {}); var AnnotationsTransformer = function AnnotationsTransformer() { this.stack_ = [new AnnotationsScope()]; }; var $AnnotationsTransformer = AnnotationsTransformer; ($traceurRuntime.createClass)(AnnotationsTransformer, { transformExportDeclaration: function(tree) { var $__267; var scope = this.pushAnnotationScope_(); scope.isExport = true; ($__267 = scope.annotations).push.apply($__267, $traceurRuntime.spread(tree.annotations)); var declaration = this.transformAny(tree.declaration); if (declaration !== tree.declaration || tree.annotations.length > 0) tree = new ExportDeclaration(tree.location, declaration, []); return this.appendMetadata_(tree); }, transformClassDeclaration: function(tree) { var $__267, $__268; var elementsChanged = false; var exportAnnotations = this.scope.isExport ? this.scope.annotations : []; var scope = this.pushAnnotationScope_(); scope.className = tree.name; ($__267 = scope.annotations).push.apply($__267, $traceurRuntime.spread(exportAnnotations, tree.annotations)); tree = $traceurRuntime.superCall(this, $AnnotationsTransformer.prototype, "transformClassDeclaration", [tree]); ($__268 = scope.metadata).unshift.apply($__268, $traceurRuntime.spread(this.transformMetadata_(createIdentifierExpression(tree.name), scope.annotations, scope.constructorParameters))); if (tree.annotations.length > 0) { tree = new ClassDeclaration(tree.location, tree.name, tree.superClass, tree.elements, []); } return this.appendMetadata_(tree); }, transformFunctionDeclaration: function(tree) { var $__267, $__268; var exportAnnotations = this.scope.isExport ? this.scope.annotations : []; var scope = this.pushAnnotationScope_(); ($__267 = scope.annotations).push.apply($__267, $traceurRuntime.spread(exportAnnotations, tree.annotations)); ($__268 = scope.metadata).push.apply($__268, $traceurRuntime.spread(this.transformMetadata_(createIdentifierExpression(tree.name), scope.annotations, tree.parameterList.parameters))); tree = $traceurRuntime.superCall(this, $AnnotationsTransformer.prototype, "transformFunctionDeclaration", [tree]); if (tree.annotations.length > 0) { tree = new FunctionDeclaration(tree.location, tree.name, tree.functionKind, tree.parameterList, tree.typeAnnotation, [], tree.body); } return this.appendMetadata_(tree); }, transformFormalParameter: function(tree) { if (tree.annotations.length > 0) { tree = new FormalParameter(tree.location, tree.parameter, tree.typeAnnotation, []); } return $traceurRuntime.superCall(this, $AnnotationsTransformer.prototype, "transformFormalParameter", [tree]); }, transformGetAccessor: function(tree) { var $__267; if (!this.scope.inClassScope) return $traceurRuntime.superCall(this, $AnnotationsTransformer.prototype, "transformGetAccessor", [tree]); ($__267 = this.scope.metadata).push.apply($__267, $traceurRuntime.spread(this.transformMetadata_(this.transformAccessor_(tree, this.scope.className, 'get'), tree.annotations, []))); if (tree.annotations.length > 0) { tree = new GetAccessor(tree.location, tree.isStatic, tree.name, tree.typeAnnotation, [], tree.body); } return $traceurRuntime.superCall(this, $AnnotationsTransformer.prototype, "transformGetAccessor", [tree]); }, transformSetAccessor: function(tree) { var $__267; if (!this.scope.inClassScope) return $traceurRuntime.superCall(this, $AnnotationsTransformer.prototype, "transformSetAccessor", [tree]); ($__267 = this.scope.metadata).push.apply($__267, $traceurRuntime.spread(this.transformMetadata_(this.transformAccessor_(tree, this.scope.className, 'set'), tree.annotations, tree.parameterList.parameters))); var parameterList = this.transformAny(tree.parameterList); if (parameterList !== tree.parameterList || tree.annotations.length > 0) { tree = new SetAccessor(tree.location, tree.isStatic, tree.name, parameterList, [], tree.body); } return $traceurRuntime.superCall(this, $AnnotationsTransformer.prototype, "transformSetAccessor", [tree]); }, transformPropertyMethodAssignment: function(tree) { var $__267, $__268; if (!this.scope.inClassScope) return $traceurRuntime.superCall(this, $AnnotationsTransformer.prototype, "transformPropertyMethodAssignment", [tree]); if (!tree.isStatic && propName(tree) === CONSTRUCTOR) { ($__267 = this.scope.annotations).push.apply($__267, $traceurRuntime.spread(tree.annotations)); this.scope.constructorParameters = tree.parameterList.parameters; } else { ($__268 = this.scope.metadata).push.apply($__268, $traceurRuntime.spread(this.transformMetadata_(this.transformPropertyMethod_(tree, this.scope.className), tree.annotations, tree.parameterList.parameters))); } var parameterList = this.transformAny(tree.parameterList); if (parameterList !== tree.parameterList || tree.annotations.length > 0) { tree = new PropertyMethodAssignment(tree.location, tree.isStatic, tree.functionKind, tree.name, parameterList, tree.typeAnnotation, [], tree.body); } return $traceurRuntime.superCall(this, $AnnotationsTransformer.prototype, "transformPropertyMethodAssignment", [tree]); }, appendMetadata_: function(tree) { var $__267; var metadata = this.stack_.pop().metadata; if (metadata.length > 0) { if (this.scope.isExport) { ($__267 = this.scope.metadata).push.apply($__267, $traceurRuntime.spread(metadata)); } else { tree = new AnonBlock(null, $traceurRuntime.spread([tree], metadata)); } } return tree; }, transformClassReference_: function(tree, className) { var parent = createIdentifierExpression(className); if (!tree.isStatic) parent = createMemberExpression(parent, 'prototype'); return parent; }, transformPropertyMethod_: function(tree, className) { return createMemberExpression(this.transformClassReference_(tree, className), tree.name.literalToken); }, transformAccessor_: function(tree, className, accessor) { var args = createArgumentList([this.transformClassReference_(tree, className), this.createLiteralStringExpression_(tree.name)]); var descriptor = parseExpression($__257, args); return createMemberExpression(descriptor, accessor); }, transformParameters_: function(parameters) { var $__265 = this; var hasParameterMetadata = false; parameters = parameters.map((function(param) { var $__267; var metadata = []; if (param.typeAnnotation) metadata.push($__265.transformAny(param.typeAnnotation)); if (param.annotations && param.annotations.length > 0) ($__267 = metadata).push.apply($__267, $traceurRuntime.spread($__265.transformAnnotations_(param.annotations))); if (metadata.length > 0) { hasParameterMetadata = true; return createArrayLiteralExpression(metadata); } return createArrayLiteralExpression([]); })); return hasParameterMetadata ? parameters : []; }, transformAnnotations_: function(annotations) { return annotations.map((function(annotation) { return createNewExpression(annotation.name, annotation.args); })); }, transformMetadata_: function(target, annotations, parameters) { var metadataStatements = []; if (annotations !== null) { annotations = this.transformAnnotations_(annotations); if (annotations.length > 0) { metadataStatements.push(createAssignmentStatement(createMemberExpression(target, 'annotations'), createArrayLiteralExpression(annotations))); } } if (parameters !== null) { parameters = this.transformParameters_(parameters); if (parameters.length > 0) { metadataStatements.push(createAssignmentStatement(createMemberExpression(target, 'parameters'), createArrayLiteralExpression(parameters))); } } return metadataStatements; }, createLiteralStringExpression_: function(tree) { var token = tree.literalToken; if (tree.literalToken.type !== STRING) token = createStringLiteralToken(tree.literalToken.value); return new LiteralExpression(null, token); }, get scope() { return this.stack_[this.stack_.length - 1]; }, pushAnnotationScope_: function() { var scope = new AnnotationsScope(); this.stack_.push(scope); return scope; } }, {}, ParseTreeTransformer); return {get AnnotationsTransformer() { return AnnotationsTransformer; }}; }); System.register("traceur@0.0.52/src/semantics/VariableBinder", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/semantics/VariableBinder"; var ScopeChainBuilder = System.get("traceur@0.0.52/src/semantics/ScopeChainBuilder").ScopeChainBuilder; function variablesInBlock(tree) { var includeFunctionScope = arguments[1]; var builder = new ScopeChainBuilder(null); builder.visitAny(tree); var scope = builder.getScopeForTree(tree); var names = scope.getLexicalBindingNames(); if (!includeFunctionScope) { return names; } var variableBindingNames = scope.getVariableBindingNames(); for (var name in variableBindingNames) { names[name] = true; } return names; } function variablesInFunction(tree) { var builder = new ScopeChainBuilder(null); builder.visitAny(tree); var scope = builder.getScopeForTree(tree); return scope.getVariableBindingNames(); } return { get variablesInBlock() { return variablesInBlock; }, get variablesInFunction() { return variablesInFunction; } }; }); System.register("traceur@0.0.52/src/codegeneration/ScopeTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/ScopeTransformer"; var ParseTreeTransformer = System.get("traceur@0.0.52/src/codegeneration/ParseTreeTransformer").ParseTreeTransformer; var $__271 = System.get("traceur@0.0.52/src/syntax/PredefinedName"), ARGUMENTS = $__271.ARGUMENTS, THIS = $__271.THIS; var $__272 = System.get("traceur@0.0.52/src/semantics/VariableBinder"), variablesInBlock = $__272.variablesInBlock, variablesInFunction = $__272.variablesInFunction; var ScopeTransformer = function ScopeTransformer(varName) { $traceurRuntime.superCall(this, $ScopeTransformer.prototype, "constructor", []); this.varName_ = varName; }; var $ScopeTransformer = ScopeTransformer; ($traceurRuntime.createClass)(ScopeTransformer, { transformBlock: function(tree) { if (this.varName_ in variablesInBlock(tree)) { return tree; } else { return $traceurRuntime.superCall(this, $ScopeTransformer.prototype, "transformBlock", [tree]); } }, transformThisExpression: function(tree) { if (this.varName_ !== THIS) return tree; return $traceurRuntime.superCall(this, $ScopeTransformer.prototype, "transformThisExpression", [tree]); }, transformFunctionDeclaration: function(tree) { if (this.getDoNotRecurse(tree)) return tree; return $traceurRuntime.superCall(this, $ScopeTransformer.prototype, "transformFunctionDeclaration", [tree]); }, transformFunctionExpression: function(tree) { if (this.getDoNotRecurse(tree)) return tree; return $traceurRuntime.superCall(this, $ScopeTransformer.prototype, "transformFunctionExpression", [tree]); }, getDoNotRecurse: function(tree) { return this.varName_ === ARGUMENTS || this.varName_ === THIS || this.varName_ in variablesInFunction(tree); }, transformCatch: function(tree) { if (!tree.binding.isPattern() && this.varName_ === tree.binding.identifierToken.value) { return tree; } return $traceurRuntime.superCall(this, $ScopeTransformer.prototype, "transformCatch", [tree]); } }, {}, ParseTreeTransformer); return {get ScopeTransformer() { return ScopeTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/AlphaRenamer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/AlphaRenamer"; var ScopeTransformer = System.get("traceur@0.0.52/src/codegeneration/ScopeTransformer").ScopeTransformer; var $__275 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), FunctionDeclaration = $__275.FunctionDeclaration, FunctionExpression = $__275.FunctionExpression; var THIS = System.get("traceur@0.0.52/src/syntax/PredefinedName").THIS; var createIdentifierExpression = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory").createIdentifierExpression; var AlphaRenamer = function AlphaRenamer(varName, newName) { $traceurRuntime.superCall(this, $AlphaRenamer.prototype, "constructor", [varName]); this.newName_ = newName; }; var $AlphaRenamer = AlphaRenamer; ($traceurRuntime.createClass)(AlphaRenamer, { transformIdentifierExpression: function(tree) { if (this.varName_ == tree.identifierToken.value) { return createIdentifierExpression(this.newName_); } else { return tree; } }, transformThisExpression: function(tree) { if (this.varName_ !== THIS) return tree; return createIdentifierExpression(this.newName_); }, transformFunctionDeclaration: function(tree) { if (this.varName_ === tree.name) { tree = new FunctionDeclaration(tree.location, this.newName_, tree.functionKind, tree.parameterList, tree.typeAnnotation, tree.annotations, tree.body); } return $traceurRuntime.superCall(this, $AlphaRenamer.prototype, "transformFunctionDeclaration", [tree]); }, transformFunctionExpression: function(tree) { if (this.varName_ === tree.name) { tree = new FunctionExpression(tree.location, this.newName_, tree.functionKind, tree.parameterList, tree.typeAnnotation, tree.annotations, tree.body); } return $traceurRuntime.superCall(this, $AlphaRenamer.prototype, "transformFunctionExpression", [tree]); } }, {rename: function(tree, varName, newName) { return new $AlphaRenamer(varName, newName).transformAny(tree); }}, ScopeTransformer); return {get AlphaRenamer() { return AlphaRenamer; }}; }); System.register("traceur@0.0.52/src/codegeneration/alphaRenameThisAndArguments", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/alphaRenameThisAndArguments"; var $__279 = System.get("traceur@0.0.52/src/syntax/PredefinedName"), ARGUMENTS = $__279.ARGUMENTS, THIS = $__279.THIS; var AlphaRenamer = System.get("traceur@0.0.52/src/codegeneration/AlphaRenamer").AlphaRenamer; var FindInFunctionScope = System.get("traceur@0.0.52/src/codegeneration/FindInFunctionScope").FindInFunctionScope; var FindThisOrArguments = function FindThisOrArguments(tree) { this.foundThis = false; this.foundArguments = false; $traceurRuntime.superCall(this, $FindThisOrArguments.prototype, "constructor", [tree]); }; var $FindThisOrArguments = FindThisOrArguments; ($traceurRuntime.createClass)(FindThisOrArguments, { visitThisExpression: function(tree) { this.foundThis = true; this.found = this.foundArguments; }, visitIdentifierExpression: function(tree) { if (tree.identifierToken.value === ARGUMENTS) { this.foundArguments = true; this.found = this.foundThis; } } }, {}, FindInFunctionScope); function alphaRenameThisAndArguments(tempVarTransformer, tree) { var finder = new FindThisOrArguments(tree); if (finder.foundArguments) { var argumentsTempName = tempVarTransformer.addTempVarForArguments(); tree = AlphaRenamer.rename(tree, ARGUMENTS, argumentsTempName); } if (finder.foundThis) { var thisTempName = tempVarTransformer.addTempVarForThis(); tree = AlphaRenamer.rename(tree, THIS, thisTempName); } return tree; } var $__default = alphaRenameThisAndArguments; return {get default() { return $__default; }}; }); System.register("traceur@0.0.52/src/codegeneration/ComprehensionTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/ComprehensionTransformer"; var alphaRenameThisAndArguments = System.get("traceur@0.0.52/src/codegeneration/alphaRenameThisAndArguments").default; var FunctionExpression = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees").FunctionExpression; var TempVarTransformer = System.get("traceur@0.0.52/src/codegeneration/TempVarTransformer").TempVarTransformer; var $__286 = System.get("traceur@0.0.52/src/syntax/TokenType"), LET = $__286.LET, STAR = $__286.STAR, VAR = $__286.VAR; var $__287 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), COMPREHENSION_FOR = $__287.COMPREHENSION_FOR, COMPREHENSION_IF = $__287.COMPREHENSION_IF; var Token = System.get("traceur@0.0.52/src/syntax/Token").Token; var $__289 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createCallExpression = $__289.createCallExpression, createEmptyParameterList = $__289.createEmptyParameterList, createForOfStatement = $__289.createForOfStatement, createFunctionBody = $__289.createFunctionBody, createIfStatement = $__289.createIfStatement, createParenExpression = $__289.createParenExpression, createVariableDeclarationList = $__289.createVariableDeclarationList; var options = System.get("traceur@0.0.52/src/Options").options; var ComprehensionTransformer = function ComprehensionTransformer() { $traceurRuntime.defaultSuperCall(this, $ComprehensionTransformer.prototype, arguments); }; var $ComprehensionTransformer = ComprehensionTransformer; ($traceurRuntime.createClass)(ComprehensionTransformer, {transformComprehension: function(tree, statement, isGenerator) { var prefix = arguments[3]; var suffix = arguments[4]; var bindingKind = isGenerator || !options.blockBinding ? VAR : LET; var statements = prefix ? [prefix] : []; for (var i = tree.comprehensionList.length - 1; i >= 0; i--) { var item = tree.comprehensionList[i]; switch (item.type) { case COMPREHENSION_IF: var expression = this.transformAny(item.expression); statement = createIfStatement(expression, statement); break; case COMPREHENSION_FOR: var left = this.transformAny(item.left); var iterator = this.transformAny(item.iterator); var initializer = createVariableDeclarationList(bindingKind, left, null); statement = createForOfStatement(initializer, iterator, statement); break; default: throw new Error('Unreachable.'); } } statement = alphaRenameThisAndArguments(this, statement); statements.push(statement); if (suffix) statements.push(suffix); var functionKind = isGenerator ? new Token(STAR, null) : null; var func = new FunctionExpression(null, null, functionKind, createEmptyParameterList(), null, [], createFunctionBody(statements)); return createParenExpression(createCallExpression(func)); }}, {}, TempVarTransformer); return {get ComprehensionTransformer() { return ComprehensionTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/ArrayComprehensionTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/ArrayComprehensionTransformer"; var $__292 = Object.freeze(Object.defineProperties(["var ", " = 0, ", " = [];"], {raw: {value: Object.freeze(["var ", " = 0, ", " = [];"])}})), $__293 = Object.freeze(Object.defineProperties(["", "[", "++] = ", ";"], {raw: {value: Object.freeze(["", "[", "++] = ", ";"])}})), $__294 = Object.freeze(Object.defineProperties(["return ", ";"], {raw: {value: Object.freeze(["return ", ";"])}})); var ComprehensionTransformer = System.get("traceur@0.0.52/src/codegeneration/ComprehensionTransformer").ComprehensionTransformer; var createIdentifierExpression = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory").createIdentifierExpression; var parseStatement = System.get("traceur@0.0.52/src/codegeneration/PlaceholderParser").parseStatement; var ArrayComprehensionTransformer = function ArrayComprehensionTransformer() { $traceurRuntime.defaultSuperCall(this, $ArrayComprehensionTransformer.prototype, arguments); }; var $ArrayComprehensionTransformer = ArrayComprehensionTransformer; ($traceurRuntime.createClass)(ArrayComprehensionTransformer, {transformArrayComprehension: function(tree) { this.pushTempScope(); var expression = this.transformAny(tree.expression); var index = createIdentifierExpression(this.getTempIdentifier()); var result = createIdentifierExpression(this.getTempIdentifier()); var tempVarsStatatement = parseStatement($__292, index, result); var statement = parseStatement($__293, result, index, expression); var returnStatement = parseStatement($__294, result); var functionKind = null; var result = this.transformComprehension(tree, statement, functionKind, tempVarsStatatement, returnStatement); this.popTempScope(); return result; }}, {}, ComprehensionTransformer); return {get ArrayComprehensionTransformer() { return ArrayComprehensionTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/ArrowFunctionTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/ArrowFunctionTransformer"; var FunctionExpression = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees").FunctionExpression; var TempVarTransformer = System.get("traceur@0.0.52/src/codegeneration/TempVarTransformer").TempVarTransformer; var FUNCTION_BODY = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType").FUNCTION_BODY; var alphaRenameThisAndArguments = System.get("traceur@0.0.52/src/codegeneration/alphaRenameThisAndArguments").default; var $__303 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createFunctionBody = $__303.createFunctionBody, createParenExpression = $__303.createParenExpression, createReturnStatement = $__303.createReturnStatement; function convertConciseBody(tree) { if (tree.type !== FUNCTION_BODY) return createFunctionBody([createReturnStatement(tree)]); return tree; } var ArrowFunctionTransformer = function ArrowFunctionTransformer() { $traceurRuntime.defaultSuperCall(this, $ArrowFunctionTransformer.prototype, arguments); }; var $ArrowFunctionTransformer = ArrowFunctionTransformer; ($traceurRuntime.createClass)(ArrowFunctionTransformer, {transformArrowFunctionExpression: function(tree) { var alphaRenamed = alphaRenameThisAndArguments(this, tree); var parameterList = this.transformAny(alphaRenamed.parameterList); var body = this.transformAny(alphaRenamed.body); body = convertConciseBody(body); var functionExpression = new FunctionExpression(tree.location, null, tree.functionKind, parameterList, null, [], body); return createParenExpression(functionExpression); }}, {transform: function(tempVarTransformer, tree) { tree = alphaRenameThisAndArguments(tempVarTransformer, tree); var body = convertConciseBody(tree.body); return new FunctionExpression(tree.location, null, tree.functionKind, tree.parameterList, null, [], body); }}, TempVarTransformer); return {get ArrowFunctionTransformer() { return ArrowFunctionTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/BlockBindingTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/BlockBindingTransformer"; var AlphaRenamer = System.get("traceur@0.0.52/src/codegeneration/AlphaRenamer").AlphaRenamer; var $__306 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), BINDING_IDENTIFIER = $__306.BINDING_IDENTIFIER, BLOCK = $__306.BLOCK, VARIABLE_DECLARATION_LIST = $__306.VARIABLE_DECLARATION_LIST; var $__307 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), FunctionDeclaration = $__307.FunctionDeclaration, FunctionExpression = $__307.FunctionExpression; var ParseTreeTransformer = System.get("traceur@0.0.52/src/codegeneration/ParseTreeTransformer").ParseTreeTransformer; var $__309 = System.get("traceur@0.0.52/src/syntax/TokenType"), CONST = $__309.CONST, LET = $__309.LET, VAR = $__309.VAR; var $__310 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createAssignmentExpression = $__310.createAssignmentExpression, createBindingIdentifier = $__310.createBindingIdentifier, createBlock = $__310.createBlock, createCatch = $__310.createCatch, createEmptyStatement = $__310.createEmptyStatement, createExpressionStatement = $__310.createExpressionStatement, createFinally = $__310.createFinally, createForInStatement = $__310.createForInStatement, createForStatement = $__310.createForStatement, createFunctionBody = $__310.createFunctionBody, createIdentifierExpression = $__310.createIdentifierExpression, createIdentifierToken = $__310.createIdentifierToken, createThrowStatement = $__310.createThrowStatement, createTryStatement = $__310.createTryStatement, createUndefinedExpression = $__310.createUndefinedExpression, createVariableDeclaration = $__310.createVariableDeclaration, createVariableDeclarationList = $__310.createVariableDeclarationList, createVariableStatement = $__310.createVariableStatement; var ScopeType = { SCRIPT: 'SCRIPT', FUNCTION: 'FUNCTION', BLOCK: 'BLOCK' }; var Scope = function Scope(parent, type) { this.parent = parent; this.type = type; this.blockVariables = null; }; ($traceurRuntime.createClass)(Scope, {addBlockScopedVariable: function(value) { if (!this.blockVariables) { this.blockVariables = Object.create(null); } this.blockVariables[value] = true; }}, {}); ; var Rename = function Rename(oldName, newName) { this.oldName = oldName; this.newName = newName; }; ($traceurRuntime.createClass)(Rename, {}, {}); function renameAll(renames, tree) { renames.forEach((function(rename) { tree = AlphaRenamer.rename(tree, rename.oldName, rename.newName); })); return tree; } function toBlock(statement) { return statement.type == BLOCK ? statement : createBlock([statement]); } var BlockBindingTransformer = function BlockBindingTransformer(stateAllocator) { $traceurRuntime.superCall(this, $BlockBindingTransformer.prototype, "constructor", []); this.scope_ = null; }; var $BlockBindingTransformer = BlockBindingTransformer; ($traceurRuntime.createClass)(BlockBindingTransformer, { createScriptScope_: function() { return new Scope(this.scope_, ScopeType.SCRIPT); }, createFunctionScope_: function() { if (this.scope_ == null) { throw new Error('Top level function scope found.'); } return new Scope(this.scope_, ScopeType.FUNCTION); }, createBlockScope_: function() { if (this.scope_ == null) { throw new Error('Top level block scope found.'); } return new Scope(this.scope_, ScopeType.BLOCK); }, push_: function(scope) { this.scope_ = scope; return scope; }, pop_: function(scope) { if (this.scope_ != scope) { throw new Error('BlockBindingTransformer scope mismatch'); } this.scope_ = scope.parent; }, transformBlock: function(tree) { var scope = this.push_(this.createBlockScope_()); var statements = this.transformList(tree.statements); if (scope.blockVariables != null) { tree = createBlock([this.rewriteAsCatch_(scope.blockVariables, createBlock(statements))]); } else if (statements != tree.statements) { tree = createBlock(statements); } this.pop_(scope); return tree; }, rewriteAsCatch_: function(blockVariables, statement) { for (var variable in blockVariables) { statement = createTryStatement(createBlock([createThrowStatement(createUndefinedExpression())]), createCatch(createBindingIdentifier(variable), createBlock([statement])), null); } return statement; }, transformClassDeclaration: function(tree) { throw new Error('ClassDeclaration should be transformed away.'); }, transformForInStatement: function(tree) { var treeBody = tree.body; var initializer; if (tree.initializer != null && tree.initializer.type == VARIABLE_DECLARATION_LIST) { var variables = tree.initializer; if (variables.declarations.length != 1) { throw new Error('for .. in has != 1 variables'); } var variable = variables.declarations[0]; var variableName = this.getVariableName_(variable); switch (variables.declarationType) { case LET: case CONST: { if (variable.initializer != null) { throw new Error('const/let in for-in may not have an initializer'); } initializer = createVariableDeclarationList(VAR, ("$" + variableName), null); treeBody = this.prependToBlock_(createVariableStatement(LET, variableName, createIdentifierExpression(("$" + variableName))), treeBody); break; } case VAR: initializer = this.transformVariables_(variables); break; default: throw new Error('Unreachable.'); } } else { initializer = this.transformAny(tree.initializer); } var result = tree; var collection = this.transformAny(tree.collection); var body = this.transformAny(treeBody); if (initializer != tree.initializer || collection != tree.collection || body != tree.body) { result = createForInStatement(initializer, collection, body); } return result; }, prependToBlock_: function(statement, body) { if (body.type == BLOCK) { return createBlock($traceurRuntime.spread([statement], body.statements)); } else { return createBlock([statement, body]); } }, transformForStatement: function(tree) { var initializer; if (tree.initializer != null && tree.initializer.type == VARIABLE_DECLARATION_LIST) { var variables = tree.initializer; switch (variables.declarationType) { case LET: case CONST: return this.transformForLet_(tree, variables); case VAR: initializer = this.transformVariables_(variables); break; default: throw new Error('Reached unreachable.'); } } else { initializer = this.transformAny(tree.initializer); } var condition = this.transformAny(tree.condition); var increment = this.transformAny(tree.increment); var body = this.transformAny(tree.body); var result = tree; if (initializer != tree.initializer || condition != tree.condition || increment != tree.increment || body != tree.body) { result = createForStatement(initializer, condition, increment, body); } return result; }, transformForLet_: function(tree, variables) { var $__311 = this; var copyFwd = []; var copyBak = []; var hoisted = []; var renames = []; variables.declarations.forEach((function(variable) { var variableName = $__311.getVariableName_(variable); var hoistedName = ("$" + variableName); var initializer = renameAll(renames, variable.initializer); hoisted.push(createVariableDeclaration(hoistedName, initializer)); copyFwd.push(createVariableDeclaration(variableName, createIdentifierExpression(hoistedName))); copyBak.push(createExpressionStatement(createAssignmentExpression(createIdentifierExpression(hoistedName), createIdentifierExpression(variableName)))); renames.push(new Rename(variableName, hoistedName)); })); var condition = renameAll(renames, tree.condition); var increment = renameAll(renames, tree.increment); var transformedForLoop = createBlock([createVariableStatement(createVariableDeclarationList(LET, hoisted)), createForStatement(null, condition, increment, createBlock([createVariableStatement(createVariableDeclarationList(LET, copyFwd)), createTryStatement(toBlock(tree.body), null, createFinally(createBlock(copyBak)))]))]); return this.transformAny(transformedForLoop); }, transformFunctionDeclaration: function(tree) { var body = this.transformFunctionBody(tree.body); var parameterList = this.transformAny(tree.parameterList); if (this.scope_.type === ScopeType.BLOCK) { this.scope_.addBlockScopedVariable(tree.name.identifierToken.value); return createExpressionStatement(createAssignmentExpression(createIdentifierExpression(tree.name.identifierToken), new FunctionExpression(tree.location, null, tree.functionKind, parameterList, tree.typeAnnotation, tree.annotations, body))); } if (body === tree.body && parameterList === tree.parameterList) { return tree; } return new FunctionDeclaration(tree.location, tree.name, tree.functionKind, parameterList, tree.typeAnnotation, tree.annotations, body); }, transformScript: function(tree) { var scope = this.push_(this.createScriptScope_()); var result = $traceurRuntime.superCall(this, $BlockBindingTransformer.prototype, "transformScript", [tree]); this.pop_(scope); return result; }, transformVariableDeclaration: function(tree) { throw new Error('Should never see variable declaration tree.'); }, transformVariableDeclarationList: function(tree) { throw new Error('Should never see variable declaration list.'); }, transformVariableStatement: function(tree) { if (this.scope_.type == ScopeType.BLOCK) { switch (tree.declarations.declarationType) { case CONST: case LET: return this.transformBlockVariables_(tree.declarations); default: break; } } var variables = this.transformVariables_(tree.declarations); if (variables != tree.declarations) { tree = createVariableStatement(variables); } return tree; }, transformBlockVariables_: function(tree) { var $__311 = this; var variables = tree.declarations; var commaExpressions = []; variables.forEach((function(variable) { switch (tree.declarationType) { case LET: case CONST: break; default: throw new Error('Only let/const allowed here.'); } var variableName = $__311.getVariableName_(variable); $__311.scope_.addBlockScopedVariable(variableName); var initializer = $__311.transformAny(variable.initializer); if (initializer != null) { commaExpressions.push(createAssignmentExpression(createIdentifierExpression(variableName), initializer)); } })); switch (commaExpressions.length) { case 0: return createEmptyStatement(); case 1: return createExpressionStatement(commaExpressions[0]); default: for (var i = 0; i < commaExpressions.length; i++) { commaExpressions[i] = createExpressionStatement(commaExpressions[i]); } return createBlock(commaExpressions); } }, transformVariables_: function(tree) { var variables = tree.declarations; var transformed = null; for (var index = 0; index < variables.length; index++) { var variable = variables[index]; var variableName = this.getVariableName_(variable); var initializer = this.transformAny(variable.initializer); if (transformed != null || initializer != variable.initializer) { if (transformed == null) { transformed = variables.slice(0, index); } transformed.push(createVariableDeclaration(createIdentifierToken(variableName), initializer)); } } if (transformed != null || tree.declarationType != VAR) { var declarations = transformed != null ? transformed : tree.declarations; var declarationType = tree.declarationType != VAR ? VAR : tree.declarationType; tree = createVariableDeclarationList(declarationType, declarations); } return tree; }, transformFunctionBody: function(body) { var scope = this.push_(this.createFunctionScope_()); body = this.transformFunctionBodyStatements_(body); this.pop_(scope); return body; }, transformFunctionBodyStatements_: function(tree) { var statements = this.transformList(tree.statements); if (this.scope_.blockVariables != null) { tree = this.rewriteAsCatch_(this.scope_.blockVariables, createBlock(statements)); } else if (statements != tree.statements) { tree = createFunctionBody(statements); } return tree; }, getVariableName_: function(variable) { var lvalue = variable.lvalue; if (lvalue.type == BINDING_IDENTIFIER) { return lvalue.identifierToken.value; } throw new Error('Unexpected destructuring declaration found.'); } }, {}, ParseTreeTransformer); return {get BlockBindingTransformer() { return BlockBindingTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/MakeStrictTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/MakeStrictTransformer"; var $__313 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), FunctionBody = $__313.FunctionBody, Script = $__313.Script; var ParseTreeTransformer = System.get("traceur@0.0.52/src/codegeneration/ParseTreeTransformer").ParseTreeTransformer; var createUseStrictDirective = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory").createUseStrictDirective; var hasUseStrict = System.get("traceur@0.0.52/src/semantics/util").hasUseStrict; function prepend(statements) { return $traceurRuntime.spread([createUseStrictDirective()], statements); } var MakeStrictTransformer = function MakeStrictTransformer() { $traceurRuntime.defaultSuperCall(this, $MakeStrictTransformer.prototype, arguments); }; var $MakeStrictTransformer = MakeStrictTransformer; ($traceurRuntime.createClass)(MakeStrictTransformer, { transformScript: function(tree) { if (hasUseStrict(tree.scriptItemList)) return tree; return new Script(tree.location, prepend(tree.scriptItemList)); }, transformFunctionBody: function(tree) { if (hasUseStrict(tree.statements)) return tree; return new FunctionBody(tree.location, prepend(tree.statements)); } }, {transformTree: function(tree) { return new $MakeStrictTransformer().transformAny(tree); }}, ParseTreeTransformer); return {get MakeStrictTransformer() { return MakeStrictTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/assignmentOperatorToBinaryOperator", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/assignmentOperatorToBinaryOperator"; var $__318 = System.get("traceur@0.0.52/src/syntax/TokenType"), AMPERSAND = $__318.AMPERSAND, AMPERSAND_EQUAL = $__318.AMPERSAND_EQUAL, BAR = $__318.BAR, BAR_EQUAL = $__318.BAR_EQUAL, CARET = $__318.CARET, CARET_EQUAL = $__318.CARET_EQUAL, LEFT_SHIFT = $__318.LEFT_SHIFT, LEFT_SHIFT_EQUAL = $__318.LEFT_SHIFT_EQUAL, MINUS = $__318.MINUS, MINUS_EQUAL = $__318.MINUS_EQUAL, PERCENT = $__318.PERCENT, PERCENT_EQUAL = $__318.PERCENT_EQUAL, PLUS = $__318.PLUS, PLUS_EQUAL = $__318.PLUS_EQUAL, RIGHT_SHIFT = $__318.RIGHT_SHIFT, RIGHT_SHIFT_EQUAL = $__318.RIGHT_SHIFT_EQUAL, SLASH = $__318.SLASH, SLASH_EQUAL = $__318.SLASH_EQUAL, STAR = $__318.STAR, STAR_EQUAL = $__318.STAR_EQUAL, UNSIGNED_RIGHT_SHIFT = $__318.UNSIGNED_RIGHT_SHIFT, UNSIGNED_RIGHT_SHIFT_EQUAL = $__318.UNSIGNED_RIGHT_SHIFT_EQUAL; function assignmentOperatorToBinaryOperator(type) { switch (type) { case STAR_EQUAL: return STAR; case SLASH_EQUAL: return SLASH; case PERCENT_EQUAL: return PERCENT; case PLUS_EQUAL: return PLUS; case MINUS_EQUAL: return MINUS; case LEFT_SHIFT_EQUAL: return LEFT_SHIFT; case RIGHT_SHIFT_EQUAL: return RIGHT_SHIFT; case UNSIGNED_RIGHT_SHIFT_EQUAL: return UNSIGNED_RIGHT_SHIFT; case AMPERSAND_EQUAL: return AMPERSAND; case CARET_EQUAL: return CARET; case BAR_EQUAL: return BAR; default: throw Error('unreachable'); } } var $__default = assignmentOperatorToBinaryOperator; return {get default() { return $__default; }}; }); System.register("traceur@0.0.52/src/codegeneration/ExplodeExpressionTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/ExplodeExpressionTransformer"; var ParseTreeTransformer = System.get("traceur@0.0.52/src/codegeneration/ParseTreeTransformer").ParseTreeTransformer; var $__320 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createAssignmentExpression = $__320.createAssignmentExpression, createCommaExpression = $__320.createCommaExpression, id = $__320.createIdentifierExpression, createMemberExpression = $__320.createMemberExpression, createNumberLiteral = $__320.createNumberLiteral, createOperatorToken = $__320.createOperatorToken, createParenExpression = $__320.createParenExpression; var $__321 = System.get("traceur@0.0.52/src/syntax/TokenType"), AND = $__321.AND, EQUAL = $__321.EQUAL, MINUS = $__321.MINUS, MINUS_EQUAL = $__321.MINUS_EQUAL, MINUS_MINUS = $__321.MINUS_MINUS, OR = $__321.OR, PLUS = $__321.PLUS, PLUS_EQUAL = $__321.PLUS_EQUAL, PLUS_PLUS = $__321.PLUS_PLUS; var $__322 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), COMMA_EXPRESSION = $__322.COMMA_EXPRESSION, IDENTIFIER_EXPRESSION = $__322.IDENTIFIER_EXPRESSION, MEMBER_EXPRESSION = $__322.MEMBER_EXPRESSION, MEMBER_LOOKUP_EXPRESSION = $__322.MEMBER_LOOKUP_EXPRESSION, PROPERTY_NAME_ASSIGNMENT = $__322.PROPERTY_NAME_ASSIGNMENT, SPREAD_EXPRESSION = $__322.SPREAD_EXPRESSION, TEMPLATE_LITERAL_PORTION = $__322.TEMPLATE_LITERAL_PORTION; var $__323 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), ArgumentList = $__323.ArgumentList, ArrayLiteralExpression = $__323.ArrayLiteralExpression, AwaitExpression = $__323.AwaitExpression, BinaryExpression = $__323.BinaryExpression, CallExpression = $__323.CallExpression, ConditionalExpression = $__323.ConditionalExpression, MemberExpression = $__323.MemberExpression, MemberLookupExpression = $__323.MemberLookupExpression, NewExpression = $__323.NewExpression, ObjectLiteralExpression = $__323.ObjectLiteralExpression, PropertyNameAssignment = $__323.PropertyNameAssignment, SpreadExpression = $__323.SpreadExpression, TemplateLiteralExpression = $__323.TemplateLiteralExpression, TemplateSubstitution = $__323.TemplateSubstitution, UnaryExpression = $__323.UnaryExpression, YieldExpression = $__323.YieldExpression; var assert = System.get("traceur@0.0.52/src/util/assert").assert; var assignmentOperatorToBinaryOperator = System.get("traceur@0.0.52/src/codegeneration/assignmentOperatorToBinaryOperator").default; var CommaExpressionBuilder = function CommaExpressionBuilder(tempVar) { this.tempVar = tempVar; this.expressions = []; }; ($traceurRuntime.createClass)(CommaExpressionBuilder, { add: function(tree) { var $__327; if (tree.type === COMMA_EXPRESSION) ($__327 = this.expressions).push.apply($__327, $traceurRuntime.spread(getExpressions(tree))); return this; }, build: function(tree) { var tempVar = this.tempVar; this.expressions.push(createAssignmentExpression(tempVar, tree), tempVar); return createCommaExpression(this.expressions); } }, {}); function getResult(tree) { if (tree.type === COMMA_EXPRESSION) return tree.expressions[tree.expressions.length - 1]; return tree; } function getExpressions(tree) { if (tree.type === COMMA_EXPRESSION) return tree.expressions.slice(0, -1); return []; } var ExplodeExpressionTransformer = function ExplodeExpressionTransformer(tempVarTransformer) { $traceurRuntime.superCall(this, $ExplodeExpressionTransformer.prototype, "constructor", []); this.tempVarTransformer_ = tempVarTransformer; }; var $ExplodeExpressionTransformer = ExplodeExpressionTransformer; ($traceurRuntime.createClass)(ExplodeExpressionTransformer, { addTempVar: function() { var tmpId = this.tempVarTransformer_.addTempVar(); return id(tmpId); }, transformUnaryExpression: function(tree) { if (tree.operator.type == PLUS_PLUS) return this.transformUnaryNumeric(tree, PLUS_EQUAL); if (tree.operator.type == MINUS_MINUS) return this.transformUnaryNumeric(tree, MINUS_EQUAL); var operand = this.transformAny(tree.operand); if (operand === tree.operand) return tree; var expressions = $traceurRuntime.spread(getExpressions(operand), [new UnaryExpression(tree.location, tree.operator, getResult(operand))]); return createCommaExpression(expressions); }, transformUnaryNumeric: function(tree, operator) { return this.transformAny(new BinaryExpression(tree.location, tree.operand, createOperatorToken(operator), createNumberLiteral(1))); }, transformPostfixExpression: function(tree) { if (tree.operand.type === MEMBER_EXPRESSION) return this.transformPostfixMemberExpression(tree); if (tree.operand.type === MEMBER_LOOKUP_EXPRESSION) return this.transformPostfixMemberLookupExpression(tree); assert(tree.operand.type === IDENTIFIER_EXPRESSION); var operand = tree.operand; var tmp = this.addTempVar(); var operator = tree.operator.type === PLUS_PLUS ? PLUS : MINUS; var expressions = [createAssignmentExpression(tmp, operand), createAssignmentExpression(operand, new BinaryExpression(tree.location, tmp, createOperatorToken(operator), createNumberLiteral(1))), tmp]; return createCommaExpression(expressions); }, transformPostfixMemberExpression: function(tree) { var memberName = tree.operand.memberName; var operand = this.transformAny(tree.operand.operand); var tmp = this.addTempVar(); var memberExpression = new MemberExpression(tree.operand.location, getResult(operand), memberName); var operator = tree.operator.type === PLUS_PLUS ? PLUS : MINUS; var expressions = $traceurRuntime.spread(getExpressions(operand), [createAssignmentExpression(tmp, memberExpression), createAssignmentExpression(memberExpression, new BinaryExpression(tree.location, tmp, createOperatorToken(operator), createNumberLiteral(1))), tmp]); return createCommaExpression(expressions); }, transformPostfixMemberLookupExpression: function(tree) { var memberExpression = this.transformAny(tree.operand.memberExpression); var operand = this.transformAny(tree.operand.operand); var tmp = this.addTempVar(); var memberLookupExpression = new MemberLookupExpression(null, getResult(operand), getResult(memberExpression)); var operator = tree.operator.type === PLUS_PLUS ? PLUS : MINUS; var expressions = $traceurRuntime.spread(getExpressions(operand), getExpressions(memberExpression), [createAssignmentExpression(tmp, memberLookupExpression), createAssignmentExpression(memberLookupExpression, new BinaryExpression(tree.location, tmp, createOperatorToken(operator), createNumberLiteral(1))), tmp]); return createCommaExpression(expressions); }, transformYieldExpression: function(tree) { var expression = this.transformAny(tree.expression); return this.createCommaExpressionBuilder().add(expression).build(new YieldExpression(tree.location, getResult(expression), tree.isYieldFor)); }, transformAwaitExpression: function(tree) { var expression = this.transformAny(tree.expression); return this.createCommaExpressionBuilder().add(expression).build(new AwaitExpression(tree.location, getResult(expression))); }, transformParenExpression: function(tree) { var expression = this.transformAny(tree.expression); if (expression === tree.expression) return tree; var result = getResult(expression); if (result.type === IDENTIFIER_EXPRESSION) return expression; return this.createCommaExpressionBuilder().add(expression).build(result); }, transformCommaExpression: function(tree) { var expressions = this.transformList(tree.expressions); if (expressions === tree.expressions) return tree; var builder = new CommaExpressionBuilder(null); for (var i = 0; i < expressions.length; i++) { builder.add(expressions[i]); } return createCommaExpression($traceurRuntime.spread(builder.expressions, [getResult(expressions[expressions.length - 1])])); }, transformMemberExpression: function(tree) { var operand = this.transformAny(tree.operand); return this.createCommaExpressionBuilder().add(operand).build(new MemberExpression(tree.location, getResult(operand), tree.memberName)); }, transformMemberLookupExpression: function(tree) { var operand = this.transformAny(tree.operand); var memberExpression = this.transformAny(tree.memberExpression); return this.createCommaExpressionBuilder().add(operand).add(memberExpression).build(new MemberLookupExpression(tree.location, getResult(operand), getResult(memberExpression))); }, transformBinaryExpression: function(tree) { if (tree.operator.isAssignmentOperator()) return this.transformAssignmentExpression(tree); var left = this.transformAny(tree.left); var right = this.transformAny(tree.right); if (left === tree.left && right === tree.right) return tree; if (tree.operator.type === OR) return this.transformOr(left, right); if (tree.operator.type === AND) return this.transformAnd(left, right); var expressions = $traceurRuntime.spread(getExpressions(left), getExpressions(right), [new BinaryExpression(tree.location, getResult(left), tree.operator, getResult(right))]); return createCommaExpression(expressions); }, transformAssignmentExpression: function(tree) { var left = tree.left; if (left.type === MEMBER_EXPRESSION) return this.transformAssignMemberExpression(tree); if (left.type === MEMBER_LOOKUP_EXPRESSION) return this.transformAssignMemberLookupExpression(tree); assert(tree.left.type === IDENTIFIER_EXPRESSION); if (tree.operator.type === EQUAL) { var left = this.transformAny(left); var right = this.transformAny(tree.right); var expressions = $traceurRuntime.spread(getExpressions(right), [createAssignmentExpression(left, getResult(right)), getResult(right)]); return createCommaExpression(expressions); } var right = this.transformAny(tree.right); var tmp = this.addTempVar(); var binop = createOperatorToken(assignmentOperatorToBinaryOperator(tree.operator.type)); var expressions = $traceurRuntime.spread(getExpressions(right), [createAssignmentExpression(tmp, new BinaryExpression(tree.location, left, binop, getResult(right))), createAssignmentExpression(left, tmp), tmp]); return createCommaExpression(expressions); }, transformAssignMemberExpression: function(tree) { var left = tree.left; if (tree.operator.type === EQUAL) { var operand = this.transformAny(left.operand); var right = this.transformAny(tree.right); var expressions = $traceurRuntime.spread(getExpressions(operand), getExpressions(right), [new BinaryExpression(tree.location, new MemberExpression(left.location, getResult(operand), left.memberName), tree.operator, getResult(right)), getResult(right)]); return createCommaExpression(expressions); } var operand = this.transformAny(left.operand); var right = this.transformAny(tree.right); var tmp = this.addTempVar(); var memberExpression = new MemberExpression(left.location, getResult(operand), left.memberName); var tmp2 = this.addTempVar(); var binop = createOperatorToken(assignmentOperatorToBinaryOperator(tree.operator.type)); var expressions = $traceurRuntime.spread(getExpressions(operand), getExpressions(right), [createAssignmentExpression(tmp, memberExpression), createAssignmentExpression(tmp2, new BinaryExpression(tree.location, tmp, binop, getResult(right))), createAssignmentExpression(memberExpression, tmp2), tmp2]); return createCommaExpression(expressions); }, transformAssignMemberLookupExpression: function(tree) { var left = tree.left; if (tree.operator.type === EQUAL) { var operand = this.transformAny(left.operand); var memberExpression = this.transformAny(left.memberExpression); var right = this.transformAny(tree.right); var expressions = $traceurRuntime.spread(getExpressions(operand), getExpressions(memberExpression), getExpressions(right), [new BinaryExpression(tree.location, new MemberLookupExpression(left.location, getResult(operand), getResult(memberExpression)), tree.operator, getResult(right)), getResult(right)]); return createCommaExpression(expressions); } var operand = this.transformAny(left.operand); var memberExpression = this.transformAny(left.memberExpression); var right = this.transformAny(tree.right); var tmp = this.addTempVar(); var memberLookupExpression = new MemberLookupExpression(left.location, getResult(operand), getResult(memberExpression)); var tmp2 = this.addTempVar(); var binop = createOperatorToken(assignmentOperatorToBinaryOperator(tree.operator.type)); var expressions = $traceurRuntime.spread(getExpressions(operand), getExpressions(memberExpression), getExpressions(right), [createAssignmentExpression(tmp, memberLookupExpression), createAssignmentExpression(tmp2, new BinaryExpression(tree.location, tmp, binop, getResult(right))), createAssignmentExpression(memberLookupExpression, tmp2), tmp2]); return createCommaExpression(expressions); }, transformArrayLiteralExpression: function(tree) { var elements = this.transformList(tree.elements); if (elements === tree.elements) return tree; var builder = this.createCommaExpressionBuilder(); var results = []; for (var i = 0; i < elements.length; i++) { builder.add(elements[i]); results.push(getResult(elements[i])); } return builder.build(new ArrayLiteralExpression(tree.location, results)); }, transformObjectLiteralExpression: function(tree) { var propertyNameAndValues = this.transformList(tree.propertyNameAndValues); if (propertyNameAndValues === tree.propertyNameAndValues) return tree; var builder = this.createCommaExpressionBuilder(); var results = []; for (var i = 0; i < propertyNameAndValues.length; i++) { if (propertyNameAndValues[i].type === PROPERTY_NAME_ASSIGNMENT) { builder.add(propertyNameAndValues[i].value); results.push(new PropertyNameAssignment(propertyNameAndValues[i].location, propertyNameAndValues[i].name, getResult(propertyNameAndValues[i].value))); } else { results.push(propertyNameAndValues[i]); } } return builder.build(new ObjectLiteralExpression(tree.location, results)); }, transformTemplateLiteralExpression: function(tree) { var operand = this.transformAny(tree.operand); var elements = this.transformList(tree.elements); if (!operand && operand === tree.operand && elements === tree.elements) return tree; var builder = this.createCommaExpressionBuilder(); if (operand) builder.add(operand); var results = []; for (var i = 0; i < elements.length; i++) { if (elements[i].type === TEMPLATE_LITERAL_PORTION) { results.push(elements[i]); } else { var expression = elements[i].expression; builder.add(expression); var result = getResult(expression); results.push(new TemplateSubstitution(expression.location, result)); } } return builder.build(new TemplateLiteralExpression(tree.location, operand && getResult(operand), results)); }, transformCallExpression: function(tree) { if (tree.operand.type === MEMBER_EXPRESSION) return this.transformCallMemberExpression(tree); if (tree.operand.type === MEMBER_LOOKUP_EXPRESSION) return this.transformCallMemberLookupExpression(tree); return this.transformCallAndNew_(tree, CallExpression); }, transformNewExpression: function(tree) { return this.transformCallAndNew_(tree, NewExpression); }, transformCallAndNew_: function(tree, ctor) { var operand = this.transformAny(tree.operand); var args = this.transformAny(tree.args); var builder = this.createCommaExpressionBuilder().add(operand); var argResults = []; args.args.forEach((function(arg) { builder.add(arg); argResults.push(getResult(arg)); })); return builder.build(new ctor(tree.location, getResult(operand), new ArgumentList(args.location, argResults))); }, transformCallMemberExpression: function(tree) { var memberName = tree.operand.memberName; var operand = this.transformAny(tree.operand.operand); var tmp = this.addTempVar(); var memberExpresssion = new MemberExpression(tree.operand.location, getResult(operand), memberName); var args = this.transformAny(tree.args); var expressions = $traceurRuntime.spread(getExpressions(operand), [createAssignmentExpression(tmp, memberExpresssion)]); var argResults = [getResult(operand)]; args.args.forEach((function(arg) { var $__327; ($__327 = expressions).push.apply($__327, $traceurRuntime.spread(getExpressions(arg))); argResults.push(getResult(arg)); })); var callExpression = new CallExpression(tree.location, createMemberExpression(tmp, 'call'), new ArgumentList(args.location, argResults)); var tmp2 = this.addTempVar(); expressions.push(createAssignmentExpression(tmp2, callExpression), tmp2); return createCommaExpression(expressions); }, transformCallMemberLookupExpression: function(tree) { var operand = this.transformAny(tree.operand.operand); var memberExpression = this.transformAny(tree.operand.memberExpression); var tmp = this.addTempVar(); var lookupExpresssion = new MemberLookupExpression(tree.operand.location, getResult(operand), getResult(memberExpression)); var args = this.transformAny(tree.args); var expressions = $traceurRuntime.spread(getExpressions(operand), getExpressions(memberExpression), [createAssignmentExpression(tmp, lookupExpresssion)]); var argResults = [getResult(operand)]; args.args.forEach((function(arg, i) { var $__327; ($__327 = expressions).push.apply($__327, $traceurRuntime.spread(getExpressions(arg))); var result = getResult(arg); if (tree.args.args[i].type === SPREAD_EXPRESSION) result = new SpreadExpression(arg.location, result); argResults.push(result); })); var callExpression = new CallExpression(tree.location, createMemberExpression(tmp, 'call'), new ArgumentList(args.location, argResults)); var tmp2 = this.addTempVar(); expressions.push(createAssignmentExpression(tmp2, callExpression), tmp2); return createCommaExpression(expressions); }, transformConditionalExpression: function(tree) { var condition = this.transformAny(tree.condition); var left = this.transformAny(tree.left); var right = this.transformAny(tree.right); if (condition === tree.condition && left === tree.left && right === tree.right) return tree; var res = this.addTempVar(); var leftTree = createCommaExpression($traceurRuntime.spread(getExpressions(left), [createAssignmentExpression(res, getResult(left))])); var rightTree = createCommaExpression($traceurRuntime.spread(getExpressions(right), [createAssignmentExpression(res, getResult(right))])); var expressions = $traceurRuntime.spread(getExpressions(condition), [new ConditionalExpression(tree.location, getResult(condition), createParenExpression(leftTree), createParenExpression(rightTree)), res]); return createCommaExpression(expressions); }, transformOr: function(left, right) { var res = this.addTempVar(); var leftTree = createCommaExpression([createAssignmentExpression(res, getResult(left))]); var rightTree = createCommaExpression($traceurRuntime.spread(getExpressions(right), [createAssignmentExpression(res, getResult(right))])); var expressions = $traceurRuntime.spread(getExpressions(left), [new ConditionalExpression(left.location, getResult(left), createParenExpression(leftTree), createParenExpression(rightTree)), res]); return createCommaExpression(expressions); }, transformAnd: function(left, right) { var res = this.addTempVar(); var leftTree = createCommaExpression($traceurRuntime.spread(getExpressions(right), [createAssignmentExpression(res, getResult(right))])); var rightTree = createCommaExpression([createAssignmentExpression(res, getResult(left))]); var expressions = $traceurRuntime.spread(getExpressions(left), [new ConditionalExpression(left.location, getResult(left), createParenExpression(leftTree), createParenExpression(rightTree)), res]); return createCommaExpression(expressions); }, transformSpreadExpression: function(tree) { var expression = this.transformAny(tree.expression); if (expression === tree.expression) return tree; var result = getResult(expression); if (result.type !== SPREAD_EXPRESSION) result = new SpreadExpression(result.location, result); var expressions = $traceurRuntime.spread(getExpressions(expression), [result]); return createCommaExpression(expressions); }, createCommaExpressionBuilder: function() { return new CommaExpressionBuilder(this.addTempVar()); } }, {}, ParseTreeTransformer); return {get ExplodeExpressionTransformer() { return ExplodeExpressionTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/SuperTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/SuperTransformer"; var $__328 = Object.freeze(Object.defineProperties(["$traceurRuntime.superCall(", ", ", ", ", ",\n ", ")"], {raw: {value: Object.freeze(["$traceurRuntime.superCall(", ", ", ", ", ",\n ", ")"])}})), $__329 = Object.freeze(Object.defineProperties(["$traceurRuntime.superGet(", ", ", ", ", ")"], {raw: {value: Object.freeze(["$traceurRuntime.superGet(", ", ", ", ", ")"])}})), $__330 = Object.freeze(Object.defineProperties(["$traceurRuntime.superSet(", ", ", ", ", ",\n ", ")"], {raw: {value: Object.freeze(["$traceurRuntime.superSet(", ", ", ", ", ",\n ", ")"])}})); var ExplodeExpressionTransformer = System.get("traceur@0.0.52/src/codegeneration/ExplodeExpressionTransformer").ExplodeExpressionTransformer; var $__332 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), FunctionDeclaration = $__332.FunctionDeclaration, FunctionExpression = $__332.FunctionExpression; var $__333 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), LITERAL_PROPERTY_NAME = $__333.LITERAL_PROPERTY_NAME, MEMBER_EXPRESSION = $__333.MEMBER_EXPRESSION, MEMBER_LOOKUP_EXPRESSION = $__333.MEMBER_LOOKUP_EXPRESSION, SUPER_EXPRESSION = $__333.SUPER_EXPRESSION; var ParseTreeTransformer = System.get("traceur@0.0.52/src/codegeneration/ParseTreeTransformer").ParseTreeTransformer; var $__335 = System.get("traceur@0.0.52/src/syntax/TokenType"), EQUAL = $__335.EQUAL, MINUS_MINUS = $__335.MINUS_MINUS, PLUS_PLUS = $__335.PLUS_PLUS; var assert = System.get("traceur@0.0.52/src/util/assert").assert; var $__337 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createArrayLiteralExpression = $__337.createArrayLiteralExpression, createIdentifierExpression = $__337.createIdentifierExpression, createParenExpression = $__337.createParenExpression, createStringLiteral = $__337.createStringLiteral, createThisExpression = $__337.createThisExpression; var parseExpression = System.get("traceur@0.0.52/src/codegeneration/PlaceholderParser").parseExpression; var ExplodeSuperExpression = function ExplodeSuperExpression() { $traceurRuntime.defaultSuperCall(this, $ExplodeSuperExpression.prototype, arguments); }; var $ExplodeSuperExpression = ExplodeSuperExpression; ($traceurRuntime.createClass)(ExplodeSuperExpression, { transformArrowFunctionExpression: function(tree) { return tree; }, transformClassExpression: function(tree) { return tree; }, transformFunctionBody: function(tree) { return tree; } }, {}, ExplodeExpressionTransformer); var SuperTransformer = function SuperTransformer(tempVarTransformer, protoName, methodTree, thisName) { this.tempVarTransformer_ = tempVarTransformer; this.protoName_ = protoName; this.method_ = methodTree; this.superCount_ = 0; this.thisVar_ = createIdentifierExpression(thisName); this.inNestedFunc_ = 0; this.nestedSuperCount_ = 0; }; var $SuperTransformer = SuperTransformer; ($traceurRuntime.createClass)(SuperTransformer, { get hasSuper() { return this.superCount_ > 0; }, get nestedSuper() { return this.nestedSuperCount_ > 0; }, transformFunctionDeclaration: function(tree) { return this.transformFunction_(tree, FunctionDeclaration); }, transformFunctionExpression: function(tree) { return this.transformFunction_(tree, FunctionExpression); }, transformFunction_: function(tree, constructor) { var oldSuperCount = this.superCount_; this.inNestedFunc_++; var transformedTree = constructor === FunctionExpression ? $traceurRuntime.superCall(this, $SuperTransformer.prototype, "transformFunctionExpression", [tree]) : $traceurRuntime.superCall(this, $SuperTransformer.prototype, "transformFunctionDeclaration", [tree]); this.inNestedFunc_--; if (oldSuperCount !== this.superCount_) this.nestedSuperCount_ += this.superCount_ - oldSuperCount; return transformedTree; }, transformGetAccessor: function(tree) { return tree; }, transformSetAccessor: function(tree) { return tree; }, transformPropertyMethodAssignMent: function(tree) { return tree; }, transformCallExpression: function(tree) { if (this.method_ && tree.operand.type == SUPER_EXPRESSION) { this.superCount_++; assert(this.method_.name.type === LITERAL_PROPERTY_NAME); var methodName = this.method_.name.literalToken.value; return this.createSuperCallExpression_(methodName, tree); } if (hasSuperMemberExpression(tree.operand)) { this.superCount_++; var name; if (tree.operand.type == MEMBER_EXPRESSION) name = tree.operand.memberName.value; else name = tree.operand.memberExpression; return this.createSuperCallExpression_(name, tree); } return $traceurRuntime.superCall(this, $SuperTransformer.prototype, "transformCallExpression", [tree]); }, createSuperCallExpression_: function(methodName, tree) { var thisExpr = this.inNestedFunc_ ? this.thisVar_ : createThisExpression(); var args = createArrayLiteralExpression(tree.args.args); return this.createSuperCallExpression(thisExpr, this.protoName_, methodName, args); }, createSuperCallExpression: function(thisExpr, protoName, methodName, args) { return parseExpression($__328, thisExpr, protoName, methodName, args); }, transformMemberShared_: function(tree, name) { var thisExpr = this.inNestedFunc_ ? this.thisVar_ : createThisExpression(); return parseExpression($__329, thisExpr, this.protoName_, name); }, transformMemberExpression: function(tree) { if (tree.operand.type === SUPER_EXPRESSION) { this.superCount_++; return this.transformMemberShared_(tree, createStringLiteral(tree.memberName.value)); } return $traceurRuntime.superCall(this, $SuperTransformer.prototype, "transformMemberExpression", [tree]); }, transformMemberLookupExpression: function(tree) { if (tree.operand.type === SUPER_EXPRESSION) return this.transformMemberShared_(tree, tree.memberExpression); return $traceurRuntime.superCall(this, $SuperTransformer.prototype, "transformMemberLookupExpression", [tree]); }, transformBinaryExpression: function(tree) { if (tree.operator.isAssignmentOperator() && hasSuperMemberExpression(tree.left)) { if (tree.operator.type !== EQUAL) { var exploded = new ExplodeSuperExpression(this.tempVarTransformer_).transformAny(tree); return this.transformAny(createParenExpression(exploded)); } this.superCount_++; var name = tree.left.type === MEMBER_LOOKUP_EXPRESSION ? tree.left.memberExpression : createStringLiteral(tree.left.memberName.value); var thisExpr = this.inNestedFunc_ ? this.thisVar_ : createThisExpression(); var right = this.transformAny(tree.right); return parseExpression($__330, thisExpr, this.protoName_, name, right); } return $traceurRuntime.superCall(this, $SuperTransformer.prototype, "transformBinaryExpression", [tree]); }, transformUnaryExpression: function(tree) { var transformed = this.transformIncrementDecrement_(tree); if (transformed) return transformed; return $traceurRuntime.superCall(this, $SuperTransformer.prototype, "transformUnaryExpression", [tree]); }, transformPostfixExpression: function(tree) { var transformed = this.transformIncrementDecrement_(tree); if (transformed) return transformed; return $traceurRuntime.superCall(this, $SuperTransformer.prototype, "transformPostfixExpression", [tree]); }, transformIncrementDecrement_: function(tree) { var operator = tree.operator; var operand = tree.operand; if ((operator.type === PLUS_PLUS || operator.type === MINUS_MINUS) && hasSuperMemberExpression(operand)) { var exploded = new ExplodeSuperExpression(this.tempVarTransformer_).transformAny(tree); if (exploded !== tree) exploded = createParenExpression(exploded); return this.transformAny(exploded); } return null; } }, {}, ParseTreeTransformer); function hasSuperMemberExpression(tree) { if (tree.type !== MEMBER_EXPRESSION && tree.type !== MEMBER_LOOKUP_EXPRESSION) return false; return tree.operand.type === SUPER_EXPRESSION; } return {get SuperTransformer() { return SuperTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/ClassTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/ClassTransformer"; var $__340 = Object.freeze(Object.defineProperties(["($traceurRuntime.createClass)(", ", ", ", ", ",\n ", ")"], {raw: {value: Object.freeze(["($traceurRuntime.createClass)(", ", ", ", ", ",\n ", ")"])}})), $__341 = Object.freeze(Object.defineProperties(["($traceurRuntime.createClass)(", ", ", ", ", ")"], {raw: {value: Object.freeze(["($traceurRuntime.createClass)(", ", ", ", ", ")"])}})), $__342 = Object.freeze(Object.defineProperties(["var ", " = ", ""], {raw: {value: Object.freeze(["var ", " = ", ""])}})), $__343 = Object.freeze(Object.defineProperties(["var ", " = ", ""], {raw: {value: Object.freeze(["var ", " = ", ""])}})), $__344 = Object.freeze(Object.defineProperties(["function($__super) {\n var ", " = ", ";\n return ($traceurRuntime.createClass)(", ", ", ",\n ", ", $__super);\n }(", ")"], {raw: {value: Object.freeze(["function($__super) {\n var ", " = ", ";\n return ($traceurRuntime.createClass)(", ", ", ",\n ", ", $__super);\n }(", ")"])}})), $__345 = Object.freeze(Object.defineProperties(["function() {\n var ", " = ", ";\n return ($traceurRuntime.createClass)(", ", ", ",\n ", ");\n }()"], {raw: {value: Object.freeze(["function() {\n var ", " = ", ";\n return ($traceurRuntime.createClass)(", ", ", ",\n ", ");\n }()"])}})), $__346 = Object.freeze(Object.defineProperties(["$traceurRuntime.defaultSuperCall(this,\n ", ".prototype, arguments)"], {raw: {value: Object.freeze(["$traceurRuntime.defaultSuperCall(this,\n ", ".prototype, arguments)"])}})); var AlphaRenamer = System.get("traceur@0.0.52/src/codegeneration/AlphaRenamer").AlphaRenamer; var CONSTRUCTOR = System.get("traceur@0.0.52/src/syntax/PredefinedName").CONSTRUCTOR; var $__349 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), AnonBlock = $__349.AnonBlock, ExportDeclaration = $__349.ExportDeclaration, FunctionExpression = $__349.FunctionExpression, GetAccessor = $__349.GetAccessor, PropertyMethodAssignment = $__349.PropertyMethodAssignment, SetAccessor = $__349.SetAccessor; var $__350 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), GET_ACCESSOR = $__350.GET_ACCESSOR, PROPERTY_METHOD_ASSIGNMENT = $__350.PROPERTY_METHOD_ASSIGNMENT, SET_ACCESSOR = $__350.SET_ACCESSOR; var SuperTransformer = System.get("traceur@0.0.52/src/codegeneration/SuperTransformer").SuperTransformer; var TempVarTransformer = System.get("traceur@0.0.52/src/codegeneration/TempVarTransformer").TempVarTransformer; var VAR = System.get("traceur@0.0.52/src/syntax/TokenType").VAR; var MakeStrictTransformer = System.get("traceur@0.0.52/src/codegeneration/MakeStrictTransformer").MakeStrictTransformer; var $__355 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createEmptyParameterList = $__355.createEmptyParameterList, createExpressionStatement = $__355.createExpressionStatement, createFunctionBody = $__355.createFunctionBody, id = $__355.createIdentifierExpression, createMemberExpression = $__355.createMemberExpression, createObjectLiteralExpression = $__355.createObjectLiteralExpression, createParenExpression = $__355.createParenExpression, createThisExpression = $__355.createThisExpression, createVariableStatement = $__355.createVariableStatement; var hasUseStrict = System.get("traceur@0.0.52/src/semantics/util").hasUseStrict; var $__357 = System.get("traceur@0.0.52/src/codegeneration/PlaceholderParser"), parseExpression = $__357.parseExpression, parseStatement = $__357.parseStatement, parseStatements = $__357.parseStatements; var propName = System.get("traceur@0.0.52/src/staticsemantics/PropName").propName; function classCall(func, object, staticObject, superClass) { if (superClass) { return parseExpression($__340, func, object, staticObject, superClass); } return parseExpression($__341, func, object, staticObject); } var ClassTransformer = function ClassTransformer(identifierGenerator) { $traceurRuntime.superCall(this, $ClassTransformer.prototype, "constructor", [identifierGenerator]); this.strictCount_ = 0; this.state_ = null; }; var $ClassTransformer = ClassTransformer; ($traceurRuntime.createClass)(ClassTransformer, { transformExportDeclaration: function(tree) { var transformed = $traceurRuntime.superCall(this, $ClassTransformer.prototype, "transformExportDeclaration", [tree]); if (transformed === tree) return tree; var declaration = transformed.declaration; if (declaration instanceof AnonBlock) { var statements = $traceurRuntime.spread([new ExportDeclaration(null, declaration.statements[0], [])], declaration.statements.slice(1)); return new AnonBlock(null, statements); } return transformed; }, transformModule: function(tree) { this.strictCount_ = 1; return $traceurRuntime.superCall(this, $ClassTransformer.prototype, "transformModule", [tree]); }, transformScript: function(tree) { this.strictCount_ = +hasUseStrict(tree.scriptItemList); return $traceurRuntime.superCall(this, $ClassTransformer.prototype, "transformScript", [tree]); }, transformFunctionBody: function(tree) { var useStrict = +hasUseStrict(tree.statements); this.strictCount_ += useStrict; var result = $traceurRuntime.superCall(this, $ClassTransformer.prototype, "transformFunctionBody", [tree]); this.strictCount_ -= useStrict; return result; }, makeStrict_: function(tree) { if (this.strictCount_) return tree; return MakeStrictTransformer.transformTree(tree); }, transformClassElements_: function(tree, internalName) { var $__359 = this; var oldState = this.state_; this.state_ = {hasSuper: false}; var superClass = this.transformAny(tree.superClass); var hasConstructor = false; var protoElements = [], staticElements = []; var constructorBody, constructorParams; tree.elements.forEach((function(tree) { var elements, homeObject; if (tree.isStatic) { elements = staticElements; homeObject = internalName; } else { elements = protoElements; homeObject = createMemberExpression(internalName, 'prototype'); } switch (tree.type) { case GET_ACCESSOR: elements.push($__359.transformGetAccessor_(tree, homeObject)); break; case SET_ACCESSOR: elements.push($__359.transformSetAccessor_(tree, homeObject)); break; case PROPERTY_METHOD_ASSIGNMENT: var transformed = $__359.transformPropertyMethodAssignment_(tree, homeObject); if (!tree.isStatic && propName(tree) === CONSTRUCTOR) { hasConstructor = true; constructorParams = transformed.parameterList; constructorBody = transformed.body; } else { elements.push(transformed); } break; default: throw new Error(("Unexpected class element: " + tree.type)); } })); var object = createObjectLiteralExpression(protoElements); var staticObject = createObjectLiteralExpression(staticElements); var func; if (!hasConstructor) { func = this.getDefaultConstructor_(tree, internalName); } else { func = new FunctionExpression(tree.location, tree.name, false, constructorParams, null, [], constructorBody); } var state = this.state_; this.state_ = oldState; return { func: func, superClass: superClass, object: object, staticObject: staticObject, hasSuper: state.hasSuper }; }, transformClassDeclaration: function(tree) { var name = tree.name.identifierToken; var internalName = id(("$" + name)); var renamed = AlphaRenamer.rename(tree, name.value, internalName.identifierToken.value); var referencesClassName = renamed !== tree; var tree = renamed; var $__361 = $traceurRuntime.assertObject(this.transformClassElements_(tree, internalName)), func = $__361.func, hasSuper = $__361.hasSuper, object = $__361.object, staticObject = $__361.staticObject, superClass = $__361.superClass; var statements = parseStatements($__342, name, func); var expr = classCall(name, object, staticObject, superClass); if (hasSuper || referencesClassName) { statements.push(parseStatement($__343, internalName, name)); } statements.push(createExpressionStatement(expr)); var anonBlock = new AnonBlock(null, statements); return this.makeStrict_(anonBlock); }, transformClassExpression: function(tree) { this.pushTempScope(); var name; if (tree.name) name = tree.name.identifierToken; else name = id(this.getTempIdentifier()); var $__361 = $traceurRuntime.assertObject(this.transformClassElements_(tree, name)), func = $__361.func, hasSuper = $__361.hasSuper, object = $__361.object, staticObject = $__361.staticObject, superClass = $__361.superClass; var expression; if (hasSuper || tree.name) { if (superClass) { expression = parseExpression($__344, name, func, name, object, staticObject, superClass); } else { expression = parseExpression($__345, name, func, name, object, staticObject); } } else { expression = classCall(func, object, staticObject, superClass); } this.popTempScope(); return createParenExpression(this.makeStrict_(expression)); }, transformPropertyMethodAssignment_: function(tree, internalName) { var parameterList = this.transformAny(tree.parameterList); var body = this.transformSuperInFunctionBody_(tree, tree.body, internalName); if (!tree.isStatic && parameterList === tree.parameterList && body === tree.body) { return tree; } var isStatic = false; return new PropertyMethodAssignment(tree.location, isStatic, tree.functionKind, tree.name, parameterList, tree.typeAnnotation, tree.annotations, body); }, transformGetAccessor_: function(tree, internalName) { var body = this.transformSuperInFunctionBody_(tree, tree.body, internalName); if (!tree.isStatic && body === tree.body) return tree; return new GetAccessor(tree.location, false, tree.name, tree.typeAnnotation, tree.annotations, body); }, transformSetAccessor_: function(tree, internalName) { var parameterList = this.transformAny(tree.parameterList); var body = this.transformSuperInFunctionBody_(tree, tree.body, internalName); if (!tree.isStatic && body === tree.body) return tree; return new SetAccessor(tree.location, false, tree.name, parameterList, tree.annotations, body); }, transformSuperInFunctionBody_: function(methodTree, tree, internalName) { this.pushTempScope(); var thisName = this.getTempIdentifier(); var thisDecl = createVariableStatement(VAR, thisName, createThisExpression()); var superTransformer = new SuperTransformer(this, internalName, methodTree, thisName); var transformedTree = superTransformer.transformFunctionBody(this.transformFunctionBody(tree)); if (superTransformer.hasSuper) this.state_.hasSuper = true; this.popTempScope(); if (superTransformer.nestedSuper) return createFunctionBody([thisDecl].concat(transformedTree.statements)); return transformedTree; }, getDefaultConstructor_: function(tree, internalName) { var constructorParams = createEmptyParameterList(); var constructorBody; if (tree.superClass) { var statement = parseStatement($__346, internalName); constructorBody = createFunctionBody([statement]); this.state_.hasSuper = true; } else { constructorBody = createFunctionBody([]); } return new FunctionExpression(tree.location, tree.name, false, constructorParams, null, [], constructorBody); } }, {}, TempVarTransformer); return {get ClassTransformer() { return ClassTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/CommonJsModuleTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/CommonJsModuleTransformer"; var $__362 = Object.freeze(Object.defineProperties(["module.exports = function() {\n ", "\n }.call(", ");"], {raw: {value: Object.freeze(["module.exports = function() {\n ", "\n }.call(", ");"])}})), $__363 = Object.freeze(Object.defineProperties(["Object.defineProperties(exports, ", ");"], {raw: {value: Object.freeze(["Object.defineProperties(exports, ", ");"])}})), $__364 = Object.freeze(Object.defineProperties(["{get: ", "}"], {raw: {value: Object.freeze(["{get: ", "}"])}})), $__365 = Object.freeze(Object.defineProperties(["{value: ", "}"], {raw: {value: Object.freeze(["{value: ", "}"])}})), $__366 = Object.freeze(Object.defineProperties(["require(", ")"], {raw: {value: Object.freeze(["require(", ")"])}})), $__367 = Object.freeze(Object.defineProperties(["__esModule: true"], {raw: {value: Object.freeze(["__esModule: true"])}})); var ModuleTransformer = System.get("traceur@0.0.52/src/codegeneration/ModuleTransformer").ModuleTransformer; var $__369 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), GET_ACCESSOR = $__369.GET_ACCESSOR, OBJECT_LITERAL_EXPRESSION = $__369.OBJECT_LITERAL_EXPRESSION, PROPERTY_NAME_ASSIGNMENT = $__369.PROPERTY_NAME_ASSIGNMENT, RETURN_STATEMENT = $__369.RETURN_STATEMENT; var assert = System.get("traceur@0.0.52/src/util/assert").assert; var globalThis = System.get("traceur@0.0.52/src/codegeneration/globalThis").default; var $__372 = System.get("traceur@0.0.52/src/codegeneration/PlaceholderParser"), parseExpression = $__372.parseExpression, parsePropertyDefinition = $__372.parsePropertyDefinition, parseStatement = $__372.parseStatement, parseStatements = $__372.parseStatements; var scopeContainsThis = System.get("traceur@0.0.52/src/codegeneration/scopeContainsThis").default; var $__374 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createEmptyParameterList = $__374.createEmptyParameterList, createFunctionExpression = $__374.createFunctionExpression, createObjectLiteralExpression = $__374.createObjectLiteralExpression, createPropertyNameAssignment = $__374.createPropertyNameAssignment; var prependStatements = System.get("traceur@0.0.52/src/codegeneration/PrependStatements").prependStatements; var CommonJsModuleTransformer = function CommonJsModuleTransformer() { $traceurRuntime.defaultSuperCall(this, $CommonJsModuleTransformer.prototype, arguments); }; var $CommonJsModuleTransformer = CommonJsModuleTransformer; ($traceurRuntime.createClass)(CommonJsModuleTransformer, { wrapModule: function(statements) { var needsIife = statements.some(scopeContainsThis); if (needsIife) { return parseStatements($__362, statements, globalThis()); } var last = statements[statements.length - 1]; statements = statements.slice(0, -1); assert(last.type === RETURN_STATEMENT); var exportObject = last.expression; if (this.hasExports()) { var descriptors = this.transformObjectLiteralToDescriptors(exportObject); var exportStatement = parseStatement($__363, descriptors); statements = prependStatements(statements, exportStatement); } return statements; }, transformObjectLiteralToDescriptors: function(literalTree) { assert(literalTree.type === OBJECT_LITERAL_EXPRESSION); var props = literalTree.propertyNameAndValues.map((function(exp) { var descriptor; switch (exp.type) { case GET_ACCESSOR: var getterFunction = createFunctionExpression(createEmptyParameterList(), exp.body); descriptor = parseExpression($__364, getterFunction); break; case PROPERTY_NAME_ASSIGNMENT: descriptor = parseExpression($__365, exp.value); break; default: throw new Error(("Unexpected property type " + exp.type)); } return createPropertyNameAssignment(exp.name, descriptor); })); return createObjectLiteralExpression(props); }, transformModuleSpecifier: function(tree) { return parseExpression($__366, tree.token); }, getExportProperties: function() { var properties = $traceurRuntime.superCall(this, $CommonJsModuleTransformer.prototype, "getExportProperties", []); if (this.exportVisitor_.hasExports()) properties.push(parsePropertyDefinition($__367)); return properties; } }, {}, ModuleTransformer); return {get CommonJsModuleTransformer() { return CommonJsModuleTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/ParameterTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/ParameterTransformer"; var FunctionBody = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees").FunctionBody; var TempVarTransformer = System.get("traceur@0.0.52/src/codegeneration/TempVarTransformer").TempVarTransformer; var prependStatements = System.get("traceur@0.0.52/src/codegeneration/PrependStatements").prependStatements; var stack = []; var ParameterTransformer = function ParameterTransformer() { $traceurRuntime.defaultSuperCall(this, $ParameterTransformer.prototype, arguments); }; var $ParameterTransformer = ParameterTransformer; ($traceurRuntime.createClass)(ParameterTransformer, { transformArrowFunctionExpression: function(tree) { stack.push([]); return $traceurRuntime.superCall(this, $ParameterTransformer.prototype, "transformArrowFunctionExpression", [tree]); }, transformFunctionDeclaration: function(tree) { stack.push([]); return $traceurRuntime.superCall(this, $ParameterTransformer.prototype, "transformFunctionDeclaration", [tree]); }, transformFunctionExpression: function(tree) { stack.push([]); return $traceurRuntime.superCall(this, $ParameterTransformer.prototype, "transformFunctionExpression", [tree]); }, transformGetAccessor: function(tree) { stack.push([]); return $traceurRuntime.superCall(this, $ParameterTransformer.prototype, "transformGetAccessor", [tree]); }, transformSetAccessor: function(tree) { stack.push([]); return $traceurRuntime.superCall(this, $ParameterTransformer.prototype, "transformSetAccessor", [tree]); }, transformPropertyMethodAssignment: function(tree) { stack.push([]); return $traceurRuntime.superCall(this, $ParameterTransformer.prototype, "transformPropertyMethodAssignment", [tree]); }, transformFunctionBody: function(tree) { var transformedTree = $traceurRuntime.superCall(this, $ParameterTransformer.prototype, "transformFunctionBody", [tree]); var statements = stack.pop(); if (!statements.length) return transformedTree; statements = prependStatements.apply(null, $traceurRuntime.spread([transformedTree.statements], statements)); return new FunctionBody(transformedTree.location, statements); }, get parameterStatements() { return stack[stack.length - 1]; } }, {}, TempVarTransformer); return {get ParameterTransformer() { return ParameterTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/DefaultParametersTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/DefaultParametersTransformer"; var $__381 = System.get("traceur@0.0.52/src/semantics/util"), isUndefined = $__381.isUndefined, isVoidExpression = $__381.isVoidExpression; var FormalParameterList = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees").FormalParameterList; var ParameterTransformer = System.get("traceur@0.0.52/src/codegeneration/ParameterTransformer").ParameterTransformer; var ARGUMENTS = System.get("traceur@0.0.52/src/syntax/PredefinedName").ARGUMENTS; var $__385 = System.get("traceur@0.0.52/src/syntax/TokenType"), NOT_EQUAL_EQUAL = $__385.NOT_EQUAL_EQUAL, VAR = $__385.VAR; var $__386 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createBinaryExpression = $__386.createBinaryExpression, createConditionalExpression = $__386.createConditionalExpression, createIdentifierExpression = $__386.createIdentifierExpression, createMemberLookupExpression = $__386.createMemberLookupExpression, createNumberLiteral = $__386.createNumberLiteral, createOperatorToken = $__386.createOperatorToken, createVariableStatement = $__386.createVariableStatement, createVoid0 = $__386.createVoid0; function createDefaultAssignment(index, binding, initializer) { var argumentsExpression = createMemberLookupExpression(createIdentifierExpression(ARGUMENTS), createNumberLiteral(index)); var assignmentExpression; if (initializer === null || isUndefined(initializer) || isVoidExpression(initializer)) { assignmentExpression = argumentsExpression; } else { assignmentExpression = createConditionalExpression(createBinaryExpression(argumentsExpression, createOperatorToken(NOT_EQUAL_EQUAL), createVoid0()), argumentsExpression, initializer); } return createVariableStatement(VAR, binding, assignmentExpression); } var DefaultParametersTransformer = function DefaultParametersTransformer() { $traceurRuntime.defaultSuperCall(this, $DefaultParametersTransformer.prototype, arguments); }; var $DefaultParametersTransformer = DefaultParametersTransformer; ($traceurRuntime.createClass)(DefaultParametersTransformer, {transformFormalParameterList: function(tree) { var parameters = []; var changed = false; var defaultToUndefined = false; for (var i = 0; i < tree.parameters.length; i++) { var param = this.transformAny(tree.parameters[i]); if (param !== tree.parameters[i]) changed = true; if (param.isRestParameter() || !param.parameter.initializer && !defaultToUndefined) { parameters.push(param); } else { defaultToUndefined = true; changed = true; this.parameterStatements.push(createDefaultAssignment(i, param.parameter.binding, param.parameter.initializer)); } } if (!changed) return tree; return new FormalParameterList(tree.location, parameters); }}, {}, ParameterTransformer); return {get DefaultParametersTransformer() { return DefaultParametersTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/ForOfTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/ForOfTransformer"; var $__388 = Object.freeze(Object.defineProperties(["", " = ", ".value;"], {raw: {value: Object.freeze(["", " = ", ".value;"])}})), $__389 = Object.freeze(Object.defineProperties(["\n for (var ", " =\n ", "[Symbol.iterator](),\n ", ";\n !(", " = ", ".next()).done; ) {\n ", ";\n ", ";\n }"], {raw: {value: Object.freeze(["\n for (var ", " =\n ", "[Symbol.iterator](),\n ", ";\n !(", " = ", ".next()).done; ) {\n ", ";\n ", ";\n }"])}})); var VARIABLE_DECLARATION_LIST = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType").VARIABLE_DECLARATION_LIST; var TempVarTransformer = System.get("traceur@0.0.52/src/codegeneration/TempVarTransformer").TempVarTransformer; var $__392 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), id = $__392.createIdentifierExpression, createMemberExpression = $__392.createMemberExpression, createVariableStatement = $__392.createVariableStatement; var parseStatement = System.get("traceur@0.0.52/src/codegeneration/PlaceholderParser").parseStatement; var ForOfTransformer = function ForOfTransformer() { $traceurRuntime.defaultSuperCall(this, $ForOfTransformer.prototype, arguments); }; var $ForOfTransformer = ForOfTransformer; ($traceurRuntime.createClass)(ForOfTransformer, {transformForOfStatement: function(original) { var tree = $traceurRuntime.superCall(this, $ForOfTransformer.prototype, "transformForOfStatement", [original]); var iter = id(this.getTempIdentifier()); var result = id(this.getTempIdentifier()); var assignment; if (tree.initializer.type === VARIABLE_DECLARATION_LIST) { assignment = createVariableStatement(tree.initializer.declarationType, tree.initializer.declarations[0].lvalue, createMemberExpression(result, 'value')); } else { assignment = parseStatement($__388, tree.initializer, result); } return parseStatement($__389, iter, tree.collection, result, result, iter, assignment, tree.body); }}, {}, TempVarTransformer); return {get ForOfTransformer() { return ForOfTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/GeneratorComprehensionTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/GeneratorComprehensionTransformer"; var ComprehensionTransformer = System.get("traceur@0.0.52/src/codegeneration/ComprehensionTransformer").ComprehensionTransformer; var createYieldStatement = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory").createYieldStatement; var GeneratorComprehensionTransformer = function GeneratorComprehensionTransformer() { $traceurRuntime.defaultSuperCall(this, $GeneratorComprehensionTransformer.prototype, arguments); }; var $GeneratorComprehensionTransformer = GeneratorComprehensionTransformer; ($traceurRuntime.createClass)(GeneratorComprehensionTransformer, {transformGeneratorComprehension: function(tree) { var expression = this.transformAny(tree.expression); var statement = createYieldStatement(expression); var isGenerator = true; return this.transformComprehension(tree, statement, isGenerator); }}, {}, ComprehensionTransformer); return {get GeneratorComprehensionTransformer() { return GeneratorComprehensionTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/generator/State", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/generator/State"; var $__398 = Object.freeze(Object.defineProperties(["$ctx.finallyFallThrough = ", ""], {raw: {value: Object.freeze(["$ctx.finallyFallThrough = ", ""])}})); var $__399 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createAssignStateStatement = $__399.createAssignStateStatement, createBreakStatement = $__399.createBreakStatement, createCaseClause = $__399.createCaseClause, createNumberLiteral = $__399.createNumberLiteral; var parseStatement = System.get("traceur@0.0.52/src/codegeneration/PlaceholderParser").parseStatement; var State = function State(id) { this.id = id; }; ($traceurRuntime.createClass)(State, { transformMachineState: function(enclosingFinally, machineEndState, reporter) { return createCaseClause(createNumberLiteral(this.id), this.transform(enclosingFinally, machineEndState, reporter)); }, transformBreak: function(labelSet, breakState) { return this; }, transformBreakOrContinue: function(labelSet) { var breakState = arguments[1]; var continueState = arguments[2]; return this; } }, {}); State.START_STATE = 0; State.INVALID_STATE = -1; State.END_STATE = -2; State.RETHROW_STATE = -3; State.generateJump = function(enclosingFinally, fallThroughState) { return $traceurRuntime.spread(State.generateAssignState(enclosingFinally, fallThroughState), [createBreakStatement()]); }; State.generateAssignState = function(enclosingFinally, fallThroughState) { var assignState; if (State.isFinallyExit(enclosingFinally, fallThroughState)) { assignState = generateAssignStateOutOfFinally(enclosingFinally, fallThroughState); } else { assignState = [createAssignStateStatement(fallThroughState)]; } return assignState; }; State.isFinallyExit = function(enclosingFinally, destination) { return enclosingFinally != null && enclosingFinally.tryStates.indexOf(destination) < 0; }; function generateAssignStateOutOfFinally(enclosingFinally, destination) { var finallyState = enclosingFinally.finallyState; return [createAssignStateStatement(finallyState), parseStatement($__398, destination)]; } State.replaceStateList = function(oldStates, oldState, newState) { var states = []; for (var i = 0; i < oldStates.length; i++) { states.push(State.replaceStateId(oldStates[i], oldState, newState)); } return states; }; State.replaceStateId = function(current, oldState, newState) { return current == oldState ? newState : current; }; State.replaceAllStates = function(exceptionBlocks, oldState, newState) { var result = []; for (var i = 0; i < exceptionBlocks.length; i++) { result.push(exceptionBlocks[i].replaceState(oldState, newState)); } return result; }; return {get State() { return State; }}; }); System.register("traceur@0.0.52/src/codegeneration/generator/TryState", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/generator/TryState"; var State = System.get("traceur@0.0.52/src/codegeneration/generator/State").State; var Kind = { CATCH: 'catch', FINALLY: 'finally' }; var TryState = function TryState(kind, tryStates, nestedTrys) { this.kind = kind; this.tryStates = tryStates; this.nestedTrys = nestedTrys; }; ($traceurRuntime.createClass)(TryState, { replaceAllStates: function(oldState, newState) { return State.replaceStateList(this.tryStates, oldState, newState); }, replaceNestedTrys: function(oldState, newState) { var states = []; for (var i = 0; i < this.nestedTrys.length; i++) { states.push(this.nestedTrys[i].replaceState(oldState, newState)); } return states; } }, {}); TryState.Kind = Kind; return {get TryState() { return TryState; }}; }); System.register("traceur@0.0.52/src/syntax/trees/StateMachine", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/syntax/trees/StateMachine"; var ParseTree = System.get("traceur@0.0.52/src/syntax/trees/ParseTree").ParseTree; var STATE_MACHINE = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType").STATE_MACHINE; var State = System.get("traceur@0.0.52/src/codegeneration/generator/State").State; var TryState = System.get("traceur@0.0.52/src/codegeneration/generator/TryState").TryState; function addCatchOrFinallyStates(kind, enclosingMap, tryStates) { for (var i = 0; i < tryStates.length; i++) { var tryState = tryStates[i]; if (tryState.kind == kind) { for (var j = 0; j < tryState.tryStates.length; j++) { var id = tryState.tryStates[j]; enclosingMap[id] = tryState; } } addCatchOrFinallyStates(kind, enclosingMap, tryState.nestedTrys); } } function addAllCatchStates(tryStates, catches) { for (var i = 0; i < tryStates.length; i++) { var tryState = tryStates[i]; if (tryState.kind == TryState.Kind.CATCH) { catches.push(tryState); } addAllCatchStates(tryState.nestedTrys, catches); } } var StateMachine = function StateMachine(startState, fallThroughState, states, exceptionBlocks) { this.location = null; this.startState = startState; this.fallThroughState = fallThroughState; this.states = states; this.exceptionBlocks = exceptionBlocks; }; var $StateMachine = StateMachine; ($traceurRuntime.createClass)(StateMachine, { get type() { return STATE_MACHINE; }, transform: function(transformer) { return transformer.transformStateMachine(this); }, visit: function(visitor) { visitor.visitStateMachine(this); }, getAllStateIDs: function() { var result = []; for (var i = 0; i < this.states.length; i++) { result.push(this.states[i].id); } return result; }, getEnclosingFinallyMap: function() { var enclosingMap = Object.create(null); addCatchOrFinallyStates(TryState.Kind.FINALLY, enclosingMap, this.exceptionBlocks); return enclosingMap; }, allCatchStates: function() { var catches = []; addAllCatchStates(this.exceptionBlocks, catches); return catches; }, replaceStateId: function(oldState, newState) { return new $StateMachine(State.replaceStateId(this.startState, oldState, newState), State.replaceStateId(this.fallThroughState, oldState, newState), State.replaceAllStates(this.states, oldState, newState), State.replaceAllStates(this.exceptionBlocks, oldState, newState)); }, replaceStartState: function(newState) { return this.replaceStateId(this.startState, newState); }, replaceFallThroughState: function(newState) { return this.replaceStateId(this.fallThroughState, newState); }, append: function(nextMachine) { var states = $traceurRuntime.spread(this.states); for (var i = 0; i < nextMachine.states.length; i++) { var otherState = nextMachine.states[i]; states.push(otherState.replaceState(nextMachine.startState, this.fallThroughState)); } var exceptionBlocks = $traceurRuntime.spread(this.exceptionBlocks); for (var i = 0; i < nextMachine.exceptionBlocks.length; i++) { var tryState = nextMachine.exceptionBlocks[i]; exceptionBlocks.push(tryState.replaceState(nextMachine.startState, this.fallThroughState)); } return new $StateMachine(this.startState, nextMachine.fallThroughState, states, exceptionBlocks); } }, {}, ParseTree); return {get StateMachine() { return StateMachine; }}; }); System.register("traceur@0.0.52/src/codegeneration/generator/AwaitState", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/generator/AwaitState"; var $__409 = Object.freeze(Object.defineProperties(["Promise.resolve(", ").then(\n $ctx.createCallback(", "), $ctx.errback);\n return"], {raw: {value: Object.freeze(["Promise.resolve(", ").then(\n $ctx.createCallback(", "), $ctx.errback);\n return"])}})); var State = System.get("traceur@0.0.52/src/codegeneration/generator/State").State; var parseStatements = System.get("traceur@0.0.52/src/codegeneration/PlaceholderParser").parseStatements; var AwaitState = function AwaitState(id, callbackState, expression) { $traceurRuntime.superCall(this, $AwaitState.prototype, "constructor", [id]), this.callbackState = callbackState; this.expression = expression; this.statements_ = null; }; var $AwaitState = AwaitState; ($traceurRuntime.createClass)(AwaitState, { get statements() { if (!this.statements_) { this.statements_ = parseStatements($__409, this.expression, this.callbackState); } return this.statements_; }, replaceState: function(oldState, newState) { return new $AwaitState(State.replaceStateId(this.id, oldState, newState), State.replaceStateId(this.callbackState, oldState, newState), this.expression); }, transform: function(enclosingFinally, machineEndState, reporter) { return this.statements; } }, {}, State); return {get AwaitState() { return AwaitState; }}; }); System.register("traceur@0.0.52/src/codegeneration/HoistVariablesTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/HoistVariablesTransformer"; var $__413 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), AnonBlock = $__413.AnonBlock, Catch = $__413.Catch, FunctionBody = $__413.FunctionBody, ForInStatement = $__413.ForInStatement, ForOfStatement = $__413.ForOfStatement, ForStatement = $__413.ForStatement, VariableDeclarationList = $__413.VariableDeclarationList, VariableStatement = $__413.VariableStatement; var $__414 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), OBJECT_PATTERN = $__414.OBJECT_PATTERN, VARIABLE_DECLARATION_LIST = $__414.VARIABLE_DECLARATION_LIST; var ParseTreeTransformer = System.get("traceur@0.0.52/src/codegeneration/ParseTreeTransformer").ParseTreeTransformer; var VAR = System.get("traceur@0.0.52/src/syntax/TokenType").VAR; var $__417 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createAssignmentExpression = $__417.createAssignmentExpression, createCommaExpression = $__417.createCommaExpression, createExpressionStatement = $__417.createExpressionStatement, id = $__417.createIdentifierExpression, createParenExpression = $__417.createParenExpression, createVariableDeclaration = $__417.createVariableDeclaration; var prependStatements = System.get("traceur@0.0.52/src/codegeneration/PrependStatements").prependStatements; var HoistVariablesTransformer = function HoistVariablesTransformer() { $traceurRuntime.superCall(this, $HoistVariablesTransformer.prototype, "constructor", []); this.hoistedVariables_ = Object.create(null); this.keepBindingIdentifiers_ = false; this.inBlockOrFor_ = false; }; var $HoistVariablesTransformer = HoistVariablesTransformer; ($traceurRuntime.createClass)(HoistVariablesTransformer, { transformFunctionBody: function(tree) { var statements = this.transformList(tree.statements); if (statements === tree.statements) return tree; var prepended = this.prependVariables(statements); return new FunctionBody(tree.location, prepended); }, addVariable: function(name) { this.hoistedVariables_[name] = true; }, hasVariables: function() { for (var key in this.hoistedVariables_) { return true; } return false; }, getVariableNames: function() { return Object.keys(this.hoistedVariables_); }, getVariableStatement: function() { if (!this.hasVariables()) return null; var declarations = this.getVariableNames().map((function(name) { return createVariableDeclaration(name, null); })); return new VariableStatement(null, new VariableDeclarationList(null, VAR, declarations)); }, prependVariables: function(statements) { if (!this.hasVariables()) return statements; return prependStatements(statements, this.getVariableStatement()); }, transformVariableStatement: function(tree) { var declarations = this.transformAny(tree.declarations); if (declarations == tree.declarations) return tree; if (declarations === null) return new AnonBlock(null, []); if (declarations.type === VARIABLE_DECLARATION_LIST) return new VariableStatement(tree.location, declarations); return createExpressionStatement(declarations); }, transformVariableDeclaration: function(tree) { var lvalue = this.transformAny(tree.lvalue); var initializer = this.transformAny(tree.initializer); if (initializer) { var expression = createAssignmentExpression(lvalue, initializer); if (lvalue.type === OBJECT_PATTERN) expression = createParenExpression(expression); return expression; } return null; }, transformObjectPattern: function(tree) { var keepBindingIdentifiers = this.keepBindingIdentifiers_; this.keepBindingIdentifiers_ = true; var transformed = $traceurRuntime.superCall(this, $HoistVariablesTransformer.prototype, "transformObjectPattern", [tree]); this.keepBindingIdentifiers_ = keepBindingIdentifiers; return transformed; }, transformArrayPattern: function(tree) { var keepBindingIdentifiers = this.keepBindingIdentifiers_; this.keepBindingIdentifiers_ = true; var transformed = $traceurRuntime.superCall(this, $HoistVariablesTransformer.prototype, "transformArrayPattern", [tree]); this.keepBindingIdentifiers_ = keepBindingIdentifiers; return transformed; }, transformBindingIdentifier: function(tree) { var idToken = tree.identifierToken; this.addVariable(idToken.value); if (this.keepBindingIdentifiers_) return tree; return id(idToken); }, transformVariableDeclarationList: function(tree) { if (tree.declarationType === VAR || !this.inBlockOrFor_) { var expressions = this.transformList(tree.declarations); expressions = expressions.filter((function(tree) { return tree; })); if (expressions.length === 0) return null; if (expressions.length == 1) return expressions[0]; return createCommaExpression(expressions); } return tree; }, transformCatch: function(tree) { var catchBody = this.transformAny(tree.catchBody); if (catchBody === tree.catchBody) return tree; return new Catch(tree.location, tree.binding, catchBody); }, transformForInStatement: function(tree) { return this.transformLoop_(tree, ForInStatement); }, transformForOfStatement: function(tree) { return this.transformLoop_(tree, ForOfStatement); }, transformLoop_: function(tree, ctor) { var initializer = this.transformLoopIninitaliser_(tree.initializer); var collection = this.transformAny(tree.collection); var body = this.transformAny(tree.body); if (initializer === tree.initializer && collection === tree.collection && body === tree.body) { return tree; } return new ctor(tree.location, initializer, collection, body); }, transformLoopIninitaliser_: function(tree) { if (tree.type !== VARIABLE_DECLARATION_LIST || tree.declarationType !== VAR) return tree; return this.transformAny(tree.declarations[0].lvalue); }, transformForStatement: function(tree) { var inBlockOrFor = this.inBlockOrFor_; this.inBlockOrFor_ = true; var initializer = this.transformAny(tree.initializer); this.inBlockOrFor_ = inBlockOrFor; var condition = this.transformAny(tree.condition); var increment = this.transformAny(tree.increment); var body = this.transformAny(tree.body); if (initializer === tree.initializer && condition === tree.condition && increment === tree.increment && body === tree.body) { return tree; } return new ForStatement(tree.location, initializer, condition, increment, body); }, transformBlock: function(tree) { var inBlockOrFor = this.inBlockOrFor_; this.inBlockOrFor_ = true; tree = $traceurRuntime.superCall(this, $HoistVariablesTransformer.prototype, "transformBlock", [tree]); this.inBlockOrFor_ = inBlockOrFor; return tree; }, addMachineVariable: function(name) { this.machineVariables_[name] = true; }, transformClassDeclaration: function(tree) { return tree; }, transformClassExpression: function(tree) { return tree; }, transformFunctionDeclaration: function(tree) { return tree; }, transformFunctionExpression: function(tree) { return tree; }, transformGetAccessor: function(tree) { return tree; }, transformSetAccessor: function(tree) { return tree; }, transformPropertyMethodAssignment: function(tree) { return tree; }, transformArrowFunctionExpression: function(tree) { return tree; }, transformComprehensionFor: function(tree) { return tree; } }, {}, ParseTreeTransformer); var $__default = HoistVariablesTransformer; return {get default() { return $__default; }}; }); System.register("traceur@0.0.52/src/codegeneration/generator/FallThroughState", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/generator/FallThroughState"; var State = System.get("traceur@0.0.52/src/codegeneration/generator/State").State; var FallThroughState = function FallThroughState(id, fallThroughState, statements) { $traceurRuntime.superCall(this, $FallThroughState.prototype, "constructor", [id]); this.fallThroughState = fallThroughState; this.statements = statements; }; var $FallThroughState = FallThroughState; ($traceurRuntime.createClass)(FallThroughState, { replaceState: function(oldState, newState) { return new $FallThroughState(State.replaceStateId(this.id, oldState, newState), State.replaceStateId(this.fallThroughState, oldState, newState), this.statements); }, transform: function(enclosingFinally, machineEndState, reporter) { return $traceurRuntime.spread(this.statements, State.generateJump(enclosingFinally, this.fallThroughState)); } }, {}, State); return {get FallThroughState() { return FallThroughState; }}; }); System.register("traceur@0.0.52/src/codegeneration/generator/BreakState", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/generator/BreakState"; var FallThroughState = System.get("traceur@0.0.52/src/codegeneration/generator/FallThroughState").FallThroughState; var State = System.get("traceur@0.0.52/src/codegeneration/generator/State").State; var BreakState = function BreakState(id, label) { $traceurRuntime.superCall(this, $BreakState.prototype, "constructor", [id]); this.label = label; }; var $BreakState = BreakState; ($traceurRuntime.createClass)(BreakState, { replaceState: function(oldState, newState) { return new $BreakState(State.replaceStateId(this.id, oldState, newState), this.label); }, transform: function(enclosingFinally, machineEndState, reporter) { throw new Error('These should be removed before the transform step'); }, transformBreak: function(labelSet) { var breakState = arguments[1]; if (this.label == null) return new FallThroughState(this.id, breakState, []); if (this.label in labelSet) { return new FallThroughState(this.id, labelSet[this.label].fallThroughState, []); } return this; }, transformBreakOrContinue: function(labelSet) { var breakState = arguments[1]; var continueState = arguments[2]; return this.transformBreak(labelSet, breakState); } }, {}, State); return {get BreakState() { return BreakState; }}; }); System.register("traceur@0.0.52/src/codegeneration/generator/ContinueState", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/generator/ContinueState"; var FallThroughState = System.get("traceur@0.0.52/src/codegeneration/generator/FallThroughState").FallThroughState; var State = System.get("traceur@0.0.52/src/codegeneration/generator/State").State; var ContinueState = function ContinueState(id, label) { $traceurRuntime.superCall(this, $ContinueState.prototype, "constructor", [id]); this.label = label; }; var $ContinueState = ContinueState; ($traceurRuntime.createClass)(ContinueState, { replaceState: function(oldState, newState) { return new $ContinueState(State.replaceStateId(this.id, oldState, newState), this.label); }, transform: function(enclosingFinally, machineEndState, reporter) { throw new Error('These should be removed before the transform step'); }, transformBreakOrContinue: function(labelSet) { var breakState = arguments[1]; var continueState = arguments[2]; if (this.label == null) return new FallThroughState(this.id, continueState, []); if (this.label in labelSet) { return new FallThroughState(this.id, labelSet[this.label].continueState, []); } return this; } }, {}, State); return {get ContinueState() { return ContinueState; }}; }); System.register("traceur@0.0.52/src/codegeneration/generator/BreakContinueTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/generator/BreakContinueTransformer"; var BreakState = System.get("traceur@0.0.52/src/codegeneration/generator/BreakState").BreakState; var ContinueState = System.get("traceur@0.0.52/src/codegeneration/generator/ContinueState").ContinueState; var ParseTreeTransformer = System.get("traceur@0.0.52/src/codegeneration/ParseTreeTransformer").ParseTreeTransformer; var StateMachine = System.get("traceur@0.0.52/src/syntax/trees/StateMachine").StateMachine; function safeGetLabel(tree) { return tree.name ? tree.name.value : null; } var BreakContinueTransformer = function BreakContinueTransformer(stateAllocator) { $traceurRuntime.superCall(this, $BreakContinueTransformer.prototype, "constructor", []); this.transformBreaks_ = true; this.stateAllocator_ = stateAllocator; }; var $BreakContinueTransformer = BreakContinueTransformer; ($traceurRuntime.createClass)(BreakContinueTransformer, { allocateState_: function() { return this.stateAllocator_.allocateState(); }, stateToStateMachine_: function(newState) { var fallThroughState = this.allocateState_(); return new StateMachine(newState.id, fallThroughState, [newState], []); }, transformBreakStatement: function(tree) { return this.transformBreaks_ || tree.name ? this.stateToStateMachine_(new BreakState(this.allocateState_(), safeGetLabel(tree))) : tree; }, transformContinueStatement: function(tree) { return this.stateToStateMachine_(new ContinueState(this.allocateState_(), safeGetLabel(tree))); }, transformDoWhileStatement: function(tree) { return tree; }, transformForOfStatement: function(tree) { return tree; }, transformForStatement: function(tree) { return tree; }, transformFunctionDeclaration: function(tree) { return tree; }, transformFunctionExpression: function(tree) { return tree; }, transformStateMachine: function(tree) { return tree; }, transformSwitchStatement: function(tree) { var oldState = this.transformBreaks_; this.transformBreaks_ = false; var result = $traceurRuntime.superCall(this, $BreakContinueTransformer.prototype, "transformSwitchStatement", [tree]); this.transformBreaks_ = oldState; return result; }, transformWhileStatement: function(tree) { return tree; } }, {}, ParseTreeTransformer); return {get BreakContinueTransformer() { return BreakContinueTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/generator/CatchState", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/generator/CatchState"; var State = System.get("traceur@0.0.52/src/codegeneration/generator/State").State; var TryState = System.get("traceur@0.0.52/src/codegeneration/generator/TryState").TryState; var CatchState = function CatchState(identifier, catchState, fallThroughState, allStates, nestedTrys) { $traceurRuntime.superCall(this, $CatchState.prototype, "constructor", [TryState.Kind.CATCH, allStates, nestedTrys]); this.identifier = identifier; this.catchState = catchState; this.fallThroughState = fallThroughState; }; var $CatchState = CatchState; ($traceurRuntime.createClass)(CatchState, {replaceState: function(oldState, newState) { return new $CatchState(this.identifier, State.replaceStateId(this.catchState, oldState, newState), State.replaceStateId(this.fallThroughState, oldState, newState), this.replaceAllStates(oldState, newState), this.replaceNestedTrys(oldState, newState)); }}, {}, TryState); return {get CatchState() { return CatchState; }}; }); System.register("traceur@0.0.52/src/codegeneration/generator/ConditionalState", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/generator/ConditionalState"; var $__436 = Object.freeze(Object.defineProperties(["$ctx.state = (", ") ? ", " : ", ";\n break"], {raw: {value: Object.freeze(["$ctx.state = (", ") ? ", " : ", ";\n break"])}})); var State = System.get("traceur@0.0.52/src/codegeneration/generator/State").State; var $__438 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createBlock = $__438.createBlock, createIfStatement = $__438.createIfStatement; var parseStatements = System.get("traceur@0.0.52/src/codegeneration/PlaceholderParser").parseStatements; var ConditionalState = function ConditionalState(id, ifState, elseState, condition) { $traceurRuntime.superCall(this, $ConditionalState.prototype, "constructor", [id]); this.ifState = ifState; this.elseState = elseState; this.condition = condition; }; var $ConditionalState = ConditionalState; ($traceurRuntime.createClass)(ConditionalState, { replaceState: function(oldState, newState) { return new $ConditionalState(State.replaceStateId(this.id, oldState, newState), State.replaceStateId(this.ifState, oldState, newState), State.replaceStateId(this.elseState, oldState, newState), this.condition); }, transform: function(enclosingFinally, machineEndState, reporter) { if (State.isFinallyExit(enclosingFinally, this.ifState) || State.isFinallyExit(enclosingFinally, this.elseState)) { return [createIfStatement(this.condition, createBlock(State.generateJump(enclosingFinally, this.ifState)), createBlock(State.generateJump(enclosingFinally, this.elseState)))]; } return parseStatements($__436, this.condition, this.ifState, this.elseState); } }, {}, State); return {get ConditionalState() { return ConditionalState; }}; }); System.register("traceur@0.0.52/src/codegeneration/generator/FinallyFallThroughState", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/generator/FinallyFallThroughState"; var State = System.get("traceur@0.0.52/src/codegeneration/generator/State").State; var FinallyFallThroughState = function FinallyFallThroughState() { $traceurRuntime.defaultSuperCall(this, $FinallyFallThroughState.prototype, arguments); }; var $FinallyFallThroughState = FinallyFallThroughState; ($traceurRuntime.createClass)(FinallyFallThroughState, { replaceState: function(oldState, newState) { return new $FinallyFallThroughState(State.replaceStateId(this.id, oldState, newState)); }, transformMachineState: function(enclosingFinally, machineEndState, reporter) { return null; }, transform: function(enclosingFinally, machineEndState, reporter) { throw new Error('these are generated in addFinallyFallThroughDispatches'); } }, {}, State); return {get FinallyFallThroughState() { return FinallyFallThroughState; }}; }); System.register("traceur@0.0.52/src/codegeneration/generator/FinallyState", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/generator/FinallyState"; var State = System.get("traceur@0.0.52/src/codegeneration/generator/State").State; var TryState = System.get("traceur@0.0.52/src/codegeneration/generator/TryState").TryState; var FinallyState = function FinallyState(finallyState, fallThroughState, allStates, nestedTrys) { $traceurRuntime.superCall(this, $FinallyState.prototype, "constructor", [TryState.Kind.FINALLY, allStates, nestedTrys]); this.finallyState = finallyState; this.fallThroughState = fallThroughState; }; var $FinallyState = FinallyState; ($traceurRuntime.createClass)(FinallyState, {replaceState: function(oldState, newState) { return new $FinallyState(State.replaceStateId(this.finallyState, oldState, newState), State.replaceStateId(this.fallThroughState, oldState, newState), this.replaceAllStates(oldState, newState), this.replaceNestedTrys(oldState, newState)); }}, {}, TryState); return {get FinallyState() { return FinallyState; }}; }); System.register("traceur@0.0.52/src/codegeneration/generator/StateAllocator", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/generator/StateAllocator"; var State = System.get("traceur@0.0.52/src/codegeneration/generator/State").State; var StateAllocator = function StateAllocator() { this.nextState_ = State.START_STATE + 1; }; ($traceurRuntime.createClass)(StateAllocator, {allocateState: function() { return this.nextState_++; }}, {}); return {get StateAllocator() { return StateAllocator; }}; }); System.register("traceur@0.0.52/src/codegeneration/generator/SwitchState", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/generator/SwitchState"; var $__448 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), CaseClause = $__448.CaseClause, DefaultClause = $__448.DefaultClause, SwitchStatement = $__448.SwitchStatement; var State = System.get("traceur@0.0.52/src/codegeneration/generator/State").State; var createBreakStatement = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory").createBreakStatement; var SwitchClause = function SwitchClause(first, second) { this.first = first; this.second = second; }; ($traceurRuntime.createClass)(SwitchClause, {}, {}); var SwitchState = function SwitchState(id, expression, clauses) { $traceurRuntime.superCall(this, $SwitchState.prototype, "constructor", [id]); this.expression = expression; this.clauses = clauses; }; var $SwitchState = SwitchState; ($traceurRuntime.createClass)(SwitchState, { replaceState: function(oldState, newState) { var clauses = this.clauses.map((function(clause) { return new SwitchClause(clause.first, State.replaceStateId(clause.second, oldState, newState)); })); return new $SwitchState(State.replaceStateId(this.id, oldState, newState), this.expression, clauses); }, transform: function(enclosingFinally, machineEndState, reporter) { var clauses = []; for (var i = 0; i < this.clauses.length; i++) { var clause = this.clauses[i]; if (clause.first == null) { clauses.push(new DefaultClause(null, State.generateJump(enclosingFinally, clause.second))); } else { clauses.push(new CaseClause(null, clause.first, State.generateJump(enclosingFinally, clause.second))); } } return [new SwitchStatement(null, this.expression, clauses), createBreakStatement()]; } }, {}, State); return { get SwitchClause() { return SwitchClause; }, get SwitchState() { return SwitchState; } }; }); System.register("traceur@0.0.52/src/codegeneration/generator/CPSTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/generator/CPSTransformer"; var $__452 = Object.freeze(Object.defineProperties(["$ctx.pushTry(\n ", ",\n ", ");"], {raw: {value: Object.freeze(["$ctx.pushTry(\n ", ",\n ", ");"])}})), $__453 = Object.freeze(Object.defineProperties(["$ctx.popTry();"], {raw: {value: Object.freeze(["$ctx.popTry();"])}})), $__454 = Object.freeze(Object.defineProperties(["\n $ctx.popTry();\n ", " = $ctx.storedException;"], {raw: {value: Object.freeze(["\n $ctx.popTry();\n ", " = $ctx.storedException;"])}})), $__455 = Object.freeze(Object.defineProperties(["$ctx.popTry();"], {raw: {value: Object.freeze(["$ctx.popTry();"])}})), $__456 = Object.freeze(Object.defineProperties(["function($ctx) {\n while (true) ", "\n }"], {raw: {value: Object.freeze(["function($ctx) {\n while (true) ", "\n }"])}})), $__457 = Object.freeze(Object.defineProperties(["var $arguments = arguments;"], {raw: {value: Object.freeze(["var $arguments = arguments;"])}})), $__458 = Object.freeze(Object.defineProperties(["return ", "(\n ", ",\n ", ", this);"], {raw: {value: Object.freeze(["return ", "(\n ", ",\n ", ", this);"])}})), $__459 = Object.freeze(Object.defineProperties(["return ", "(\n ", ", this);"], {raw: {value: Object.freeze(["return ", "(\n ", ", this);"])}})), $__460 = Object.freeze(Object.defineProperties(["return $ctx.end()"], {raw: {value: Object.freeze(["return $ctx.end()"])}})), $__461 = Object.freeze(Object.defineProperties(["\n $ctx.state = $ctx.finallyFallThrough;\n $ctx.finallyFallThrough = ", ";\n break;"], {raw: {value: Object.freeze(["\n $ctx.state = $ctx.finallyFallThrough;\n $ctx.finallyFallThrough = ", ";\n break;"])}})), $__462 = Object.freeze(Object.defineProperties(["\n $ctx.state = $ctx.finallyFallThrough;\n break;"], {raw: {value: Object.freeze(["\n $ctx.state = $ctx.finallyFallThrough;\n break;"])}})); var AlphaRenamer = System.get("traceur@0.0.52/src/codegeneration/AlphaRenamer").AlphaRenamer; var BreakContinueTransformer = System.get("traceur@0.0.52/src/codegeneration/generator/BreakContinueTransformer").BreakContinueTransformer; var $__465 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), BLOCK = $__465.BLOCK, CASE_CLAUSE = $__465.CASE_CLAUSE, CONDITIONAL_EXPRESSION = $__465.CONDITIONAL_EXPRESSION, EXPRESSION_STATEMENT = $__465.EXPRESSION_STATEMENT, PAREN_EXPRESSION = $__465.PAREN_EXPRESSION, STATE_MACHINE = $__465.STATE_MACHINE; var $__466 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), AnonBlock = $__466.AnonBlock, Block = $__466.Block, CaseClause = $__466.CaseClause, IfStatement = $__466.IfStatement, SwitchStatement = $__466.SwitchStatement; var CatchState = System.get("traceur@0.0.52/src/codegeneration/generator/CatchState").CatchState; var ConditionalState = System.get("traceur@0.0.52/src/codegeneration/generator/ConditionalState").ConditionalState; var ExplodeExpressionTransformer = System.get("traceur@0.0.52/src/codegeneration/ExplodeExpressionTransformer").ExplodeExpressionTransformer; var FallThroughState = System.get("traceur@0.0.52/src/codegeneration/generator/FallThroughState").FallThroughState; var FinallyFallThroughState = System.get("traceur@0.0.52/src/codegeneration/generator/FinallyFallThroughState").FinallyFallThroughState; var FinallyState = System.get("traceur@0.0.52/src/codegeneration/generator/FinallyState").FinallyState; var FindInFunctionScope = System.get("traceur@0.0.52/src/codegeneration/FindInFunctionScope").FindInFunctionScope; var ParseTreeTransformer = System.get("traceur@0.0.52/src/codegeneration/ParseTreeTransformer").ParseTreeTransformer; var TempVarTransformer = System.get("traceur@0.0.52/src/codegeneration/TempVarTransformer").TempVarTransformer; var assert = System.get("traceur@0.0.52/src/util/assert").assert; var $__477 = System.get("traceur@0.0.52/src/codegeneration/PlaceholderParser"), parseExpression = $__477.parseExpression, parseStatement = $__477.parseStatement, parseStatements = $__477.parseStatements; var State = System.get("traceur@0.0.52/src/codegeneration/generator/State").State; var StateAllocator = System.get("traceur@0.0.52/src/codegeneration/generator/StateAllocator").StateAllocator; var StateMachine = System.get("traceur@0.0.52/src/syntax/trees/StateMachine").StateMachine; var $__481 = System.get("traceur@0.0.52/src/codegeneration/generator/SwitchState"), SwitchClause = $__481.SwitchClause, SwitchState = $__481.SwitchState; var TryState = System.get("traceur@0.0.52/src/codegeneration/generator/TryState").TryState; var $__483 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createAssignStateStatement = $__483.createAssignStateStatement, createBreakStatement = $__483.createBreakStatement, createCaseClause = $__483.createCaseClause, createDefaultClause = $__483.createDefaultClause, createExpressionStatement = $__483.createExpressionStatement, createFunctionBody = $__483.createFunctionBody, id = $__483.createIdentifierExpression, createMemberExpression = $__483.createMemberExpression, createNumberLiteral = $__483.createNumberLiteral, createSwitchStatement = $__483.createSwitchStatement; var HoistVariablesTransformer = System.get("traceur@0.0.52/src/codegeneration/HoistVariablesTransformer").default; var LabelState = function LabelState(name, continueState, fallThroughState) { this.name = name; this.continueState = continueState; this.fallThroughState = fallThroughState; }; ($traceurRuntime.createClass)(LabelState, {}, {}); var NeedsStateMachine = function NeedsStateMachine() { $traceurRuntime.defaultSuperCall(this, $NeedsStateMachine.prototype, arguments); }; var $NeedsStateMachine = NeedsStateMachine; ($traceurRuntime.createClass)(NeedsStateMachine, { visitBreakStatement: function(tree) { this.found = true; }, visitContinueStatement: function(tree) { this.found = true; }, visitStateMachine: function(tree) { this.found = true; }, visitYieldExpression: function(tee) { this.found = true; } }, {}, FindInFunctionScope); function needsStateMachine(tree) { var visitor = new NeedsStateMachine(tree); return visitor.found; } var HoistVariables = function HoistVariables() { $traceurRuntime.defaultSuperCall(this, $HoistVariables.prototype, arguments); }; var $HoistVariables = HoistVariables; ($traceurRuntime.createClass)(HoistVariables, {prependVariables: function(statements) { return statements; }}, {}, HoistVariablesTransformer); var CPSTransformer = function CPSTransformer(identifierGenerator, reporter) { $traceurRuntime.superCall(this, $CPSTransformer.prototype, "constructor", [identifierGenerator]); this.reporter = reporter; this.stateAllocator_ = new StateAllocator(); this.labelSet_ = Object.create(null); this.currentLabel_ = null; this.hoistVariablesTransformer_ = new HoistVariables(); }; var $CPSTransformer = CPSTransformer; ($traceurRuntime.createClass)(CPSTransformer, { expressionNeedsStateMachine: function(tree) { return false; }, allocateState: function() { return this.stateAllocator_.allocateState(); }, transformBlock: function(tree) { var labels = this.getLabels_(); var label = this.clearCurrentLabel_(); var transformedTree = $traceurRuntime.superCall(this, $CPSTransformer.prototype, "transformBlock", [tree]); var machine = this.transformStatementList_(transformedTree.statements); if (machine === null) return transformedTree; if (label) { var states = []; for (var i = 0; i < machine.states.length; i++) { var state = machine.states[i]; states.push(state.transformBreakOrContinue(labels)); } machine = new StateMachine(machine.startState, machine.fallThroughState, states, machine.exceptionBlocks); } return machine; }, transformFunctionBody: function(tree) { this.pushTempScope(); var oldLabels = this.clearLabels_(); var transformedTree = $traceurRuntime.superCall(this, $CPSTransformer.prototype, "transformFunctionBody", [tree]); var machine = this.transformStatementList_(transformedTree.statements); this.restoreLabels_(oldLabels); this.popTempScope(); return machine == null ? transformedTree : machine; }, transformStatementList_: function(trees) { var groups = []; var newMachine; for (var i = 0; i < trees.length; i++) { if (trees[i].type === STATE_MACHINE) { groups.push(trees[i]); } else if (needsStateMachine(trees[i])) { newMachine = this.ensureTransformed_(trees[i]); groups.push(newMachine); } else { var last = groups[groups.length - 1]; if (!(last instanceof Array)) groups.push(last = []); last.push(trees[i]); } } if (groups.length === 1 && groups[0] instanceof Array) return null; var machine = null; for (var i = 0; i < groups.length; i++) { if (groups[i] instanceof Array) { newMachine = this.statementsToStateMachine_(groups[i]); } else { newMachine = groups[i]; } if (i === 0) machine = newMachine; else machine = machine.append(newMachine); } return machine; }, needsStateMachine_: function(statements) { if (statements instanceof Array) { for (var i = 0; i < statements.length; i++) { if (needsStateMachine(statements[i])) return true; } return false; } assert(statements instanceof SwitchStatement); return needsStateMachine(statements); }, transformCaseClause: function(tree) { var result = $traceurRuntime.superCall(this, $CPSTransformer.prototype, "transformCaseClause", [tree]); var machine = this.transformStatementList_(result.statements); return machine == null ? result : new CaseClause(null, result.expression, [machine]); }, transformDoWhileStatement: function(tree) { var $__489; var $__487, $__488; var labels = this.getLabels_(); var label = this.clearCurrentLabel_(); var machine, condition, body; if (this.expressionNeedsStateMachine(tree.condition)) { (($__487 = $traceurRuntime.assertObject(this.expressionToStateMachine(tree.condition)), machine = $__487.machine, condition = $__487.expression, $__487)); body = this.transformAny(tree.body); } else { var result = $traceurRuntime.superCall(this, $CPSTransformer.prototype, "transformDoWhileStatement", [tree]); (($__488 = $traceurRuntime.assertObject(result), condition = $__488.condition, body = $__488.body, $__488)); if (body.type != STATE_MACHINE) return result; } var loopBodyMachine = this.ensureTransformed_(body); var startState = loopBodyMachine.startState; var conditionState = loopBodyMachine.fallThroughState; var fallThroughState = this.allocateState(); var states = []; this.addLoopBodyStates_(loopBodyMachine, conditionState, fallThroughState, labels, states); if (machine) { machine = machine.replaceStartState(conditionState); conditionState = machine.fallThroughState; ($__489 = states).push.apply($__489, $traceurRuntime.spread(machine.states)); } states.push(new ConditionalState(conditionState, startState, fallThroughState, condition)); var machine = new StateMachine(startState, fallThroughState, states, loopBodyMachine.exceptionBlocks); if (label) machine = machine.replaceStateId(conditionState, label.continueState); return machine; }, addLoopBodyStates_: function(loopBodyMachine, continueState, breakState, labels, states) { for (var i = 0; i < loopBodyMachine.states.length; i++) { var state = loopBodyMachine.states[i]; states.push(state.transformBreakOrContinue(labels, breakState, continueState)); } }, transformForStatement: function(tree) { var $__489, $__490, $__491; var labels = this.getLabels_(); var label = this.clearCurrentLabel_(); var tmp; var initializer = null, initializerMachine; if (tree.initializer) { if (this.expressionNeedsStateMachine(tree.initializer)) { tmp = this.expressionToStateMachine(tree.initializer); initializer = tmp.expression; initializerMachine = tmp.machine; } else { initializer = this.transformAny(tree.initializer); } } var condition = null, conditionMachine; if (tree.condition) { if (this.expressionNeedsStateMachine(tree.condition)) { tmp = this.expressionToStateMachine(tree.condition); condition = tmp.expression; conditionMachine = tmp.machine; } else { condition = this.transformAny(tree.condition); } } var increment = null, incrementMachine; if (tree.increment) { if (this.expressionNeedsStateMachine(tree.increment)) { tmp = this.expressionToStateMachine(tree.increment); increment = tmp.expression; incrementMachine = tmp.machine; } else { increment = this.transformAny(tree.increment); } } var body = this.transformAny(tree.body); if (initializer === tree.initializer && condition === tree.condition && increment === tree.increment && body === tree.body) { return tree; } if (!initializerMachine && !conditionMachine && !incrementMachine && body.type !== STATE_MACHINE) { return new ForStatement(tree.location, initializer, condition, increment, body); } var loopBodyMachine = this.ensureTransformed_(body); var bodyFallThroughId = loopBodyMachine.fallThroughState; var fallThroughId = this.allocateState(); var startId; var initializerStartId = initializer ? this.allocateState() : State.INVALID_STATE; var conditionStartId = increment ? this.allocateState() : bodyFallThroughId; var loopStartId = loopBodyMachine.startState; var incrementStartId = bodyFallThroughId; var states = []; if (initializer) { startId = initializerStartId; var initialiserFallThroughId; if (condition) initialiserFallThroughId = conditionStartId; else initialiserFallThroughId = loopStartId; var tmpId = initializerStartId; if (initializerMachine) { initializerMachine = initializerMachine.replaceStartState(initializerStartId); tmpId = initializerMachine.fallThroughState; ($__489 = states).push.apply($__489, $traceurRuntime.spread(initializerMachine.states)); } states.push(new FallThroughState(tmpId, initialiserFallThroughId, [createExpressionStatement(initializer)])); } if (condition) { if (!initializer) startId = conditionStartId; var tmpId = conditionStartId; if (conditionMachine) { conditionMachine = conditionMachine.replaceStartState(conditionStartId); tmpId = conditionMachine.fallThroughState; ($__490 = states).push.apply($__490, $traceurRuntime.spread(conditionMachine.states)); } states.push(new ConditionalState(tmpId, loopStartId, fallThroughId, condition)); } if (increment) { var incrementFallThroughId; if (condition) incrementFallThroughId = conditionStartId; else incrementFallThroughId = loopStartId; var tmpId = incrementStartId; if (incrementMachine) { incrementMachine = incrementMachine.replaceStartState(incrementStartId); tmpId = incrementMachine.fallThroughState; ($__491 = states).push.apply($__491, $traceurRuntime.spread(incrementMachine.states)); } states.push(new FallThroughState(tmpId, incrementFallThroughId, [createExpressionStatement(increment)])); } if (!initializer && !condition) startId = loopStartId; var continueId; if (increment) continueId = incrementStartId; else if (condition) continueId = conditionStartId; else continueId = loopStartId; if (!increment && !condition) { loopBodyMachine = loopBodyMachine.replaceFallThroughState(loopBodyMachine.startState); } this.addLoopBodyStates_(loopBodyMachine, continueId, fallThroughId, labels, states); var machine = new StateMachine(startId, fallThroughId, states, loopBodyMachine.exceptionBlocks); if (label) machine = machine.replaceStateId(continueId, label.continueState); return machine; }, transformForInStatement: function(tree) { return tree; }, transformForOfStatement: function(tree) { throw new Error('for of statements should be transformed before this pass'); }, transformIfStatement: function(tree) { var $__489, $__490, $__491; var $__487, $__488; var machine, condition, ifClause, elseClause; if (this.expressionNeedsStateMachine(tree.condition)) { (($__487 = $traceurRuntime.assertObject(this.expressionToStateMachine(tree.condition)), machine = $__487.machine, condition = $__487.expression, $__487)); ifClause = this.transformAny(tree.ifClause); elseClause = this.transformAny(tree.elseClause); } else { var result = $traceurRuntime.superCall(this, $CPSTransformer.prototype, "transformIfStatement", [tree]); (($__488 = $traceurRuntime.assertObject(result), condition = $__488.condition, ifClause = $__488.ifClause, elseClause = $__488.elseClause, $__488)); if (ifClause.type !== STATE_MACHINE && (elseClause === null || elseClause.type !== STATE_MACHINE)) { return result; } } ifClause = this.ensureTransformed_(ifClause); elseClause = this.ensureTransformed_(elseClause); var startState = this.allocateState(); var fallThroughState = ifClause.fallThroughState; var ifState = ifClause.startState; var elseState = elseClause == null ? fallThroughState : elseClause.startState; var states = []; var exceptionBlocks = []; states.push(new ConditionalState(startState, ifState, elseState, condition)); ($__489 = states).push.apply($__489, $traceurRuntime.spread(ifClause.states)); ($__490 = exceptionBlocks).push.apply($__490, $traceurRuntime.spread(ifClause.exceptionBlocks)); if (elseClause != null) { this.replaceAndAddStates_(elseClause.states, elseClause.fallThroughState, fallThroughState, states); ($__491 = exceptionBlocks).push.apply($__491, $traceurRuntime.spread(State.replaceAllStates(elseClause.exceptionBlocks, elseClause.fallThroughState, fallThroughState))); } var ifMachine = new StateMachine(startState, fallThroughState, states, exceptionBlocks); if (machine) ifMachine = machine.append(ifMachine); return ifMachine; }, removeEmptyStates: function(oldStates) { var emptyStates = [], newStates = []; for (var i = 0; i < oldStates.length; i++) { if (oldStates[i] instanceof FallThroughState && oldStates[i].statements.length === 0) { emptyStates.push(oldStates[i]); } else { newStates.push(oldStates[i]); } } for (i = 0; i < newStates.length; i++) { newStates[i] = emptyStates.reduce((function(state, $__487) { var $__488 = $traceurRuntime.assertObject($__487), id = $__488.id, fallThroughState = $__488.fallThroughState; return state.replaceState(id, fallThroughState); }), newStates[i]); } return newStates; }, replaceAndAddStates_: function(oldStates, oldState, newState, newStates) { for (var i = 0; i < oldStates.length; i++) { newStates.push(oldStates[i].replaceState(oldState, newState)); } }, transformLabelledStatement: function(tree) { var startState = this.allocateState(); var continueState = this.allocateState(); var fallThroughState = this.allocateState(); var label = new LabelState(tree.name.value, continueState, fallThroughState); var oldLabels = this.addLabel_(label); this.currentLabel_ = label; var result = this.transformAny(tree.statement); if (result === tree.statement) { result = tree; } else if (result.type === STATE_MACHINE) { result = result.replaceStartState(startState); result = result.replaceFallThroughState(fallThroughState); } this.restoreLabels_(oldLabels); return result; }, getLabels_: function() { return this.labelSet_; }, restoreLabels_: function(oldLabels) { this.labelSet_ = oldLabels; }, addLabel_: function(label) { var oldLabels = this.labelSet_; var labelSet = Object.create(null); for (var k in this.labelSet_) { labelSet[k] = this.labelSet_[k]; } labelSet[label.name] = label; this.labelSet_ = labelSet; return oldLabels; }, clearLabels_: function() { var result = this.labelSet_; this.labelSet_ = Object.create(null); return result; }, clearCurrentLabel_: function() { var result = this.currentLabel_; this.currentLabel_ = null; return result; }, transformSwitchStatement: function(tree) { var $__487, $__488; var labels = this.getLabels_(); var expression, machine, caseClauses; if (this.expressionNeedsStateMachine(tree.expression)) { (($__487 = $traceurRuntime.assertObject(this.expressionToStateMachine(tree.expression)), expression = $__487.expression, machine = $__487.machine, $__487)); caseClauses = this.transformList(tree.caseClauses); } else { var result = $traceurRuntime.superCall(this, $CPSTransformer.prototype, "transformSwitchStatement", [tree]); if (!needsStateMachine(result)) return result; (($__488 = $traceurRuntime.assertObject(result), expression = $__488.expression, caseClauses = $__488.caseClauses, $__488)); } var startState = this.allocateState(); var fallThroughState = this.allocateState(); var nextState = fallThroughState; var states = []; var clauses = []; var tryStates = []; var hasDefault = false; for (var index = caseClauses.length - 1; index >= 0; index--) { var clause = caseClauses[index]; if (clause.type == CASE_CLAUSE) { var caseClause = clause; nextState = this.addSwitchClauseStates_(nextState, fallThroughState, labels, caseClause.statements, states, tryStates); clauses.push(new SwitchClause(caseClause.expression, nextState)); } else { hasDefault = true; var defaultClause = clause; nextState = this.addSwitchClauseStates_(nextState, fallThroughState, labels, defaultClause.statements, states, tryStates); clauses.push(new SwitchClause(null, nextState)); } } if (!hasDefault) { clauses.push(new SwitchClause(null, fallThroughState)); } states.push(new SwitchState(startState, expression, clauses.reverse())); var switchMachine = new StateMachine(startState, fallThroughState, states.reverse(), tryStates); if (machine) switchMachine = machine.append(switchMachine); return switchMachine; }, addSwitchClauseStates_: function(nextState, fallThroughState, labels, statements, states, tryStates) { var $__489; var machine = this.ensureTransformedList_(statements); for (var i = 0; i < machine.states.length; i++) { var state = machine.states[i]; var transformedState = state.transformBreak(labels, fallThroughState); states.push(transformedState.replaceState(machine.fallThroughState, nextState)); } ($__489 = tryStates).push.apply($__489, $traceurRuntime.spread(machine.exceptionBlocks)); return machine.startState; }, transformTryStatement: function(tree) { var result = $traceurRuntime.superCall(this, $CPSTransformer.prototype, "transformTryStatement", [tree]); var $__487 = $traceurRuntime.assertObject(result), body = $__487.body, catchBlock = $__487.catchBlock, finallyBlock = $__487.finallyBlock; if (body.type != STATE_MACHINE && (catchBlock == null || catchBlock.catchBody.type != STATE_MACHINE) && (finallyBlock == null || finallyBlock.block.type != STATE_MACHINE)) { return result; } var outerCatchState = this.allocateState(); var outerFinallyState = this.allocateState(); var pushTryState = this.statementToStateMachine_(parseStatement($__452, (catchBlock && outerCatchState), (finallyBlock && outerFinallyState))); var tryMachine = this.ensureTransformed_(body); tryMachine = pushTryState.append(tryMachine); if (catchBlock !== null) { var popTry = this.statementToStateMachine_(parseStatement($__453)); tryMachine = tryMachine.append(popTry); var exceptionName = catchBlock.binding.identifierToken.value; var catchMachine = this.ensureTransformed_(catchBlock.catchBody); var catchStart = this.allocateState(); this.addMachineVariable(exceptionName); var states = $traceurRuntime.spread(tryMachine.states, [new FallThroughState(catchStart, catchMachine.startState, parseStatements($__454, id(exceptionName)))]); this.replaceAndAddStates_(catchMachine.states, catchMachine.fallThroughState, tryMachine.fallThroughState, states); tryMachine = new StateMachine(tryMachine.startState, tryMachine.fallThroughState, states, [new CatchState(exceptionName, catchStart, tryMachine.fallThroughState, tryMachine.getAllStateIDs(), tryMachine.exceptionBlocks)]); tryMachine = tryMachine.replaceStateId(catchStart, outerCatchState); } if (finallyBlock != null) { var finallyMachine = this.ensureTransformed_(finallyBlock.block); var popTry = this.statementToStateMachine_(parseStatement($__455)); finallyMachine = popTry.append(finallyMachine); var states = $traceurRuntime.spread(tryMachine.states, finallyMachine.states, [new FinallyFallThroughState(finallyMachine.fallThroughState)]); tryMachine = new StateMachine(tryMachine.startState, tryMachine.fallThroughState, states, [new FinallyState(finallyMachine.startState, finallyMachine.fallThroughState, tryMachine.getAllStateIDs(), tryMachine.exceptionBlocks)]); tryMachine = tryMachine.replaceStateId(finallyMachine.startState, outerFinallyState); } return tryMachine; }, transformWhileStatement: function(tree) { var $__489; var $__487, $__488; var labels = this.getLabels_(); var label = this.clearCurrentLabel_(); var condition, machine, body; if (this.expressionNeedsStateMachine(tree.condition)) { (($__487 = $traceurRuntime.assertObject(this.expressionToStateMachine(tree.condition)), machine = $__487.machine, condition = $__487.expression, $__487)); body = this.transformAny(tree.body); } else { var result = $traceurRuntime.superCall(this, $CPSTransformer.prototype, "transformWhileStatement", [tree]); (($__488 = $traceurRuntime.assertObject(result), condition = $__488.condition, body = $__488.body, $__488)); if (body.type !== STATE_MACHINE) return result; } var loopBodyMachine = this.ensureTransformed_(body); var startState = loopBodyMachine.fallThroughState; var fallThroughState = this.allocateState(); var states = []; var conditionStart = startState; if (machine) { machine = machine.replaceStartState(startState); conditionStart = machine.fallThroughState; ($__489 = states).push.apply($__489, $traceurRuntime.spread(machine.states)); } states.push(new ConditionalState(conditionStart, loopBodyMachine.startState, fallThroughState, condition)); this.addLoopBodyStates_(loopBodyMachine, startState, fallThroughState, labels, states); var machine = new StateMachine(startState, fallThroughState, states, loopBodyMachine.exceptionBlocks); if (label) machine = machine.replaceStateId(startState, label.continueState); return machine; }, transformWithStatement: function(tree) { var result = $traceurRuntime.superCall(this, $CPSTransformer.prototype, "transformWithStatement", [tree]); if (result.body.type != STATE_MACHINE) { return result; } throw new Error('Unreachable - with statement not allowed in strict mode/harmony'); }, generateMachineInnerFunction: function(machine) { var enclosingFinallyState = machine.getEnclosingFinallyMap(); var SwitchStatement = createSwitchStatement(createMemberExpression('$ctx', 'state'), this.transformMachineStates(machine, State.END_STATE, State.RETHROW_STATE, enclosingFinallyState)); return parseExpression($__456, SwitchStatement); }, addTempVar: function() { var name = this.getTempIdentifier(); this.addMachineVariable(name); return name; }, addMachineVariable: function(name) { this.hoistVariablesTransformer_.addVariable(name); }, transformCpsFunctionBody: function(tree, runtimeMethod) { var functionRef = arguments[2]; var alphaRenamedTree = AlphaRenamer.rename(tree, 'arguments', '$arguments'); var hasArguments = alphaRenamedTree !== tree; var hoistedTree = this.hoistVariablesTransformer_.transformAny(alphaRenamedTree); var maybeMachine = this.transformAny(hoistedTree); if (this.reporter.hadError()) return tree; var machine; if (maybeMachine.type !== STATE_MACHINE) { machine = this.statementsToStateMachine_(maybeMachine.statements); } else { machine = new StateMachine(maybeMachine.startState, maybeMachine.fallThroughState, this.removeEmptyStates(maybeMachine.states), maybeMachine.exceptionBlocks); } machine = machine.replaceFallThroughState(State.END_STATE).replaceStartState(State.START_STATE); var statements = []; if (this.hoistVariablesTransformer_.hasVariables()) statements.push(this.hoistVariablesTransformer_.getVariableStatement()); if (hasArguments) statements.push(parseStatement($__457)); if (functionRef) { statements.push(parseStatement($__458, runtimeMethod, this.generateMachineInnerFunction(machine), functionRef)); } else { statements.push(parseStatement($__459, runtimeMethod, this.generateMachineInnerFunction(machine))); } return createFunctionBody(statements); }, transformFunctionDeclaration: function(tree) { return tree; }, transformFunctionExpression: function(tree) { return tree; }, transformGetAccessor: function(tree) { return tree; }, transformSetAccessor: function(tree) { return tree; }, transformArrowFunctionExpression: function(tree) { return tree; }, transformStateMachine: function(tree) { return tree; }, statementToStateMachine_: function(statement) { var statements; if (statement.type === BLOCK) statements = statement.statements; else statements = [statement]; return this.statementsToStateMachine_(statements); }, statementsToStateMachine_: function(statements) { var startState = this.allocateState(); var fallThroughState = this.allocateState(); return this.stateToStateMachine_(new FallThroughState(startState, fallThroughState, statements), fallThroughState); }, stateToStateMachine_: function(newState, fallThroughState) { return new StateMachine(newState.id, fallThroughState, [newState], []); }, transformMachineStates: function(machine, machineEndState, rethrowState, enclosingFinallyState) { var cases = []; for (var i = 0; i < machine.states.length; i++) { var state = machine.states[i]; var stateCase = state.transformMachineState(enclosingFinallyState[state.id], machineEndState, this.reporter); if (stateCase != null) { cases.push(stateCase); } } this.addFinallyFallThroughDispatches(null, machine.exceptionBlocks, cases); cases.push(createDefaultClause(parseStatements($__460))); return cases; }, addFinallyFallThroughDispatches: function(enclosingFinallyState, tryStates, cases) { for (var i = 0; i < tryStates.length; i++) { var tryState = tryStates[i]; if (tryState.kind == TryState.Kind.FINALLY) { var finallyState = tryState; if (enclosingFinallyState != null) { var caseClauses = []; var index = 0; for (var j = 0; j < enclosingFinallyState.tryStates.length; j++) { var destination = enclosingFinallyState.tryStates[j]; index++; var statements; if (index < enclosingFinallyState.tryStates.length) { statements = []; } else { statements = parseStatements($__461, State.INVALID_STATE); } caseClauses.push(createCaseClause(createNumberLiteral(destination), statements)); } caseClauses.push(createDefaultClause([createAssignStateStatement(enclosingFinallyState.finallyState), createBreakStatement()])); cases.push(createCaseClause(createNumberLiteral(finallyState.fallThroughState), [createSwitchStatement(createMemberExpression('$ctx', 'finallyFallThrough'), caseClauses), createBreakStatement()])); } else { cases.push(createCaseClause(createNumberLiteral(finallyState.fallThroughState), parseStatements($__462))); } this.addFinallyFallThroughDispatches(finallyState, finallyState.nestedTrys, cases); } else { this.addFinallyFallThroughDispatches(enclosingFinallyState, tryState.nestedTrys, cases); } } }, transformVariableDeclarationList: function(tree) { this.reporter.reportError(tree.location && tree.location.start, 'Traceur: const/let declarations in a block containing a yield are ' + 'not yet implemented'); return tree; }, maybeTransformStatement_: function(maybeTransformedStatement) { var breakContinueTransformed = new BreakContinueTransformer(this.stateAllocator_).transformAny(maybeTransformedStatement); if (breakContinueTransformed != maybeTransformedStatement) { breakContinueTransformed = this.transformAny(breakContinueTransformed); } return breakContinueTransformed; }, ensureTransformed_: function(statement) { if (statement == null) { return null; } var maybeTransformed = this.maybeTransformStatement_(statement); return maybeTransformed.type == STATE_MACHINE ? maybeTransformed : this.statementToStateMachine_(maybeTransformed); }, ensureTransformedList_: function(statements) { var maybeTransformedStatements = []; var foundMachine = false; for (var i = 0; i < statements.length; i++) { var statement = statements[i]; var maybeTransformedStatement = this.maybeTransformStatement_(statement); maybeTransformedStatements.push(maybeTransformedStatement); if (maybeTransformedStatement.type == STATE_MACHINE) { foundMachine = true; } } if (!foundMachine) { return this.statementsToStateMachine_(statements); } return this.transformStatementList_(maybeTransformedStatements); }, expressionToStateMachine: function(tree) { var commaExpression = new ExplodeExpressionTransformer(this).transformAny(tree); var statements = $traceurRuntime.assertObject(new NormalizeCommaExpressionToStatementTransformer().transformAny(commaExpression)).statements; var lastStatement = statements.pop(); assert(lastStatement.type === EXPRESSION_STATEMENT); var expression = lastStatement.expression; statements = $traceurRuntime.superCall(this, $CPSTransformer.prototype, "transformList", [statements]); var machine = this.transformStatementList_(statements); return { expression: expression, machine: machine }; } }, {}, TempVarTransformer); var NormalizeCommaExpressionToStatementTransformer = function NormalizeCommaExpressionToStatementTransformer() { $traceurRuntime.defaultSuperCall(this, $NormalizeCommaExpressionToStatementTransformer.prototype, arguments); }; var $NormalizeCommaExpressionToStatementTransformer = NormalizeCommaExpressionToStatementTransformer; ($traceurRuntime.createClass)(NormalizeCommaExpressionToStatementTransformer, { transformCommaExpression: function(tree) { var $__485 = this; var statements = tree.expressions.map((function(expr) { if (expr.type === CONDITIONAL_EXPRESSION) return $__485.transformAny(expr); return createExpressionStatement(expr); })); return new AnonBlock(tree.location, statements); }, transformConditionalExpression: function(tree) { var ifBlock = this.transformAny(tree.left); var elseBlock = this.transformAny(tree.right); return new IfStatement(tree.location, tree.condition, anonBlockToBlock(ifBlock), anonBlockToBlock(elseBlock)); } }, {}, ParseTreeTransformer); function anonBlockToBlock(tree) { if (tree.type === PAREN_EXPRESSION) return anonBlockToBlock(tree.expression); return new Block(tree.location, tree.statements); } return {get CPSTransformer() { return CPSTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/generator/EndState", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/generator/EndState"; var State = System.get("traceur@0.0.52/src/codegeneration/generator/State").State; var EndState = function EndState() { $traceurRuntime.defaultSuperCall(this, $EndState.prototype, arguments); }; var $EndState = EndState; ($traceurRuntime.createClass)(EndState, { replaceState: function(oldState, newState) { return new $EndState(State.replaceStateId(this.id, oldState, newState)); }, transform: function(enclosingFinally, machineEndState, reporter) { return State.generateJump(enclosingFinally, machineEndState); } }, {}, State); return {get EndState() { return EndState; }}; }); System.register("traceur@0.0.52/src/codegeneration/generator/AsyncTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/generator/AsyncTransformer"; var $__494 = Object.freeze(Object.defineProperties(["$ctx.value"], {raw: {value: Object.freeze(["$ctx.value"])}})), $__495 = Object.freeze(Object.defineProperties(["$ctx.returnValue = ", ""], {raw: {value: Object.freeze(["$ctx.returnValue = ", ""])}})), $__496 = Object.freeze(Object.defineProperties(["$ctx.resolve(", ")"], {raw: {value: Object.freeze(["$ctx.resolve(", ")"])}})), $__497 = Object.freeze(Object.defineProperties(["$traceurRuntime.asyncWrap"], {raw: {value: Object.freeze(["$traceurRuntime.asyncWrap"])}})); var AwaitState = System.get("traceur@0.0.52/src/codegeneration/generator/AwaitState").AwaitState; var $__499 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), BinaryExpression = $__499.BinaryExpression, ExpressionStatement = $__499.ExpressionStatement; var CPSTransformer = System.get("traceur@0.0.52/src/codegeneration/generator/CPSTransformer").CPSTransformer; var EndState = System.get("traceur@0.0.52/src/codegeneration/generator/EndState").EndState; var FallThroughState = System.get("traceur@0.0.52/src/codegeneration/generator/FallThroughState").FallThroughState; var $__503 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), AWAIT_EXPRESSION = $__503.AWAIT_EXPRESSION, BINARY_EXPRESSION = $__503.BINARY_EXPRESSION, STATE_MACHINE = $__503.STATE_MACHINE; var $__504 = System.get("traceur@0.0.52/src/codegeneration/PlaceholderParser"), parseExpression = $__504.parseExpression, parseStatement = $__504.parseStatement, parseStatements = $__504.parseStatements; var StateMachine = System.get("traceur@0.0.52/src/syntax/trees/StateMachine").StateMachine; var FindInFunctionScope = System.get("traceur@0.0.52/src/codegeneration/FindInFunctionScope").FindInFunctionScope; var createUndefinedExpression = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory").createUndefinedExpression; function isAwaitAssign(tree) { return tree.type === BINARY_EXPRESSION && tree.operator.isAssignmentOperator() && tree.right.type === AWAIT_EXPRESSION && tree.left.isLeftHandSideExpression(); } var AwaitFinder = function AwaitFinder() { $traceurRuntime.defaultSuperCall(this, $AwaitFinder.prototype, arguments); }; var $AwaitFinder = AwaitFinder; ($traceurRuntime.createClass)(AwaitFinder, {visitAwaitExpression: function(tree) { this.found = true; }}, {}, FindInFunctionScope); function scopeContainsAwait(tree) { return new AwaitFinder(tree).found; } var AsyncTransformer = function AsyncTransformer() { $traceurRuntime.defaultSuperCall(this, $AsyncTransformer.prototype, arguments); }; var $AsyncTransformer = AsyncTransformer; ($traceurRuntime.createClass)(AsyncTransformer, { expressionNeedsStateMachine: function(tree) { if (tree === null) return false; return scopeContainsAwait(tree); }, transformExpressionStatement: function(tree) { var expression = tree.expression; if (expression.type === AWAIT_EXPRESSION) return this.transformAwaitExpression_(expression); if (isAwaitAssign(expression)) return this.transformAwaitAssign_(expression); if (this.expressionNeedsStateMachine(expression)) { return this.expressionToStateMachine(expression).machine; } return $traceurRuntime.superCall(this, $AsyncTransformer.prototype, "transformExpressionStatement", [tree]); }, transformAwaitExpression: function(tree) { throw new Error('Internal error'); }, transformAwaitExpression_: function(tree) { return this.transformAwait_(tree, tree.expression, null, null); }, transformAwaitAssign_: function(tree) { return this.transformAwait_(tree, tree.right.expression, tree.left, tree.operator); }, transformAwait_: function(tree, inExpression, left, operator) { var $__509; var expression, machine; if (this.expressionNeedsStateMachine(inExpression)) { (($__509 = $traceurRuntime.assertObject(this.expressionToStateMachine(inExpression)), expression = $__509.expression, machine = $__509.machine, $__509)); } else { expression = this.transformAny(inExpression); } var createTaskState = this.allocateState(); var callbackState = this.allocateState(); var fallThroughState = this.allocateState(); if (!left) callbackState = fallThroughState; var states = []; var expression = this.transformAny(expression); states.push(new AwaitState(createTaskState, callbackState, expression)); if (left) { var statement = new ExpressionStatement(tree.location, new BinaryExpression(tree.location, left, operator, parseExpression($__494))); var assignment = [statement]; states.push(new FallThroughState(callbackState, fallThroughState, assignment)); } var awaitMachine = new StateMachine(createTaskState, fallThroughState, states, []); if (machine) { awaitMachine = machine.append(awaitMachine); } return awaitMachine; }, transformFinally: function(tree) { var result = $traceurRuntime.superCall(this, $AsyncTransformer.prototype, "transformFinally", [tree]); if (result.block.type != STATE_MACHINE) { return result; } this.reporter.reportError(tree.location.start, 'await not permitted within a finally block.'); return result; }, transformReturnStatement: function(tree) { var $__509; var expression, machine; if (this.expressionNeedsStateMachine(tree.expression)) { (($__509 = $traceurRuntime.assertObject(this.expressionToStateMachine(tree.expression)), expression = $__509.expression, machine = $__509.machine, $__509)); } else { expression = tree.expression || createUndefinedExpression(); } var startState = this.allocateState(); var endState = this.allocateState(); var completeState = new FallThroughState(startState, endState, parseStatements($__495, expression)); var end = new EndState(endState); var returnMachine = new StateMachine(startState, this.allocateState(), [completeState, end], []); if (machine) returnMachine = machine.append(returnMachine); return returnMachine; }, createCompleteTask_: function(result) { return parseStatement($__496, result); }, transformAsyncBody: function(tree) { var runtimeFunction = parseExpression($__497); return this.transformCpsFunctionBody(tree, runtimeFunction); } }, {transformAsyncBody: function(identifierGenerator, reporter, body) { return new $AsyncTransformer(identifierGenerator, reporter).transformAsyncBody(body); }}, CPSTransformer); ; return {get AsyncTransformer() { return AsyncTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/generator/ForInTransformPass", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/generator/ForInTransformPass"; var $__510 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), BLOCK = $__510.BLOCK, VARIABLE_DECLARATION_LIST = $__510.VARIABLE_DECLARATION_LIST, IDENTIFIER_EXPRESSION = $__510.IDENTIFIER_EXPRESSION; var $__511 = System.get("traceur@0.0.52/src/syntax/PredefinedName"), LENGTH = $__511.LENGTH, PUSH = $__511.PUSH; var TempVarTransformer = System.get("traceur@0.0.52/src/codegeneration/TempVarTransformer").TempVarTransformer; var $__513 = System.get("traceur@0.0.52/src/syntax/TokenType"), BANG = $__513.BANG, IN = $__513.IN, OPEN_ANGLE = $__513.OPEN_ANGLE, PLUS_PLUS = $__513.PLUS_PLUS, VAR = $__513.VAR; var $__514 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createArgumentList = $__514.createArgumentList, createAssignmentStatement = $__514.createAssignmentStatement, createBinaryExpression = $__514.createBinaryExpression, createBlock = $__514.createBlock, createCallStatement = $__514.createCallStatement, createContinueStatement = $__514.createContinueStatement, createEmptyArrayLiteralExpression = $__514.createEmptyArrayLiteralExpression, createForInStatement = $__514.createForInStatement, createForStatement = $__514.createForStatement, createIdentifierExpression = $__514.createIdentifierExpression, createIfStatement = $__514.createIfStatement, createMemberExpression = $__514.createMemberExpression, createMemberLookupExpression = $__514.createMemberLookupExpression, createNumberLiteral = $__514.createNumberLiteral, createOperatorToken = $__514.createOperatorToken, createParenExpression = $__514.createParenExpression, createPostfixExpression = $__514.createPostfixExpression, createUnaryExpression = $__514.createUnaryExpression, createVariableDeclarationList = $__514.createVariableDeclarationList, createVariableStatement = $__514.createVariableStatement; var ForInTransformPass = function ForInTransformPass() { $traceurRuntime.defaultSuperCall(this, $ForInTransformPass.prototype, arguments); }; var $ForInTransformPass = ForInTransformPass; ($traceurRuntime.createClass)(ForInTransformPass, {transformForInStatement: function(original) { var $__516, $__517; var tree = original; var bodyStatements = []; var body = this.transformAny(tree.body); if (body.type == BLOCK) { ($__516 = bodyStatements).push.apply($__516, $traceurRuntime.spread(body.statements)); } else { bodyStatements.push(body); } var elements = []; var keys = this.getTempIdentifier(); elements.push(createVariableStatement(VAR, keys, createEmptyArrayLiteralExpression())); var collection = this.getTempIdentifier(); elements.push(createVariableStatement(VAR, collection, tree.collection)); var p = this.getTempIdentifier(); elements.push(createForInStatement(createVariableDeclarationList(VAR, p, null), createIdentifierExpression(collection), createCallStatement(createMemberExpression(keys, PUSH), createArgumentList([createIdentifierExpression(p)])))); var i = this.getTempIdentifier(); var lookup = createMemberLookupExpression(createIdentifierExpression(keys), createIdentifierExpression(i)); var originalKey, assignOriginalKey; if (tree.initializer.type == VARIABLE_DECLARATION_LIST) { var decList = tree.initializer; originalKey = createIdentifierExpression(decList.declarations[0].lvalue); assignOriginalKey = createVariableStatement(decList.declarationType, originalKey.identifierToken, lookup); } else if (tree.initializer.type == IDENTIFIER_EXPRESSION) { originalKey = tree.initializer; assignOriginalKey = createAssignmentStatement(tree.initializer, lookup); } else { throw new Error('Invalid left hand side of for in loop'); } var innerBlock = []; innerBlock.push(assignOriginalKey); innerBlock.push(createIfStatement(createUnaryExpression(createOperatorToken(BANG), createParenExpression(createBinaryExpression(originalKey, createOperatorToken(IN), createIdentifierExpression(collection)))), createContinueStatement(), null)); ($__517 = innerBlock).push.apply($__517, $traceurRuntime.spread(bodyStatements)); elements.push(createForStatement(createVariableDeclarationList(VAR, i, createNumberLiteral(0)), createBinaryExpression(createIdentifierExpression(i), createOperatorToken(OPEN_ANGLE), createMemberExpression(keys, LENGTH)), createPostfixExpression(createIdentifierExpression(i), createOperatorToken(PLUS_PLUS)), createBlock(innerBlock))); return createBlock(elements); }}, {}, TempVarTransformer); return {get ForInTransformPass() { return ForInTransformPass; }}; }); System.register("traceur@0.0.52/src/codegeneration/generator/YieldState", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/generator/YieldState"; var $__518 = Object.freeze(Object.defineProperties(["return ", ""], {raw: {value: Object.freeze(["return ", ""])}})); var State = System.get("traceur@0.0.52/src/codegeneration/generator/State").State; var parseStatement = System.get("traceur@0.0.52/src/codegeneration/PlaceholderParser").parseStatement; var YieldState = function YieldState(id, fallThroughState, expression) { $traceurRuntime.superCall(this, $YieldState.prototype, "constructor", [id]); this.fallThroughState = fallThroughState; this.expression = expression; }; var $YieldState = YieldState; ($traceurRuntime.createClass)(YieldState, { replaceState: function(oldState, newState) { return new this.constructor(State.replaceStateId(this.id, oldState, newState), State.replaceStateId(this.fallThroughState, oldState, newState), this.expression); }, transform: function(enclosingFinally, machineEndState, reporter) { return $traceurRuntime.spread(State.generateAssignState(enclosingFinally, this.fallThroughState), [parseStatement($__518, this.expression)]); } }, {}, State); return {get YieldState() { return YieldState; }}; }); System.register("traceur@0.0.52/src/codegeneration/generator/ReturnState", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/generator/ReturnState"; var $__522 = Object.freeze(Object.defineProperties(["$ctx.returnValue = ", ""], {raw: {value: Object.freeze(["$ctx.returnValue = ", ""])}})); var $__523 = System.get("traceur@0.0.52/src/semantics/util"), isUndefined = $__523.isUndefined, isVoidExpression = $__523.isVoidExpression; var YieldState = System.get("traceur@0.0.52/src/codegeneration/generator/YieldState").YieldState; var State = System.get("traceur@0.0.52/src/codegeneration/generator/State").State; var parseStatement = System.get("traceur@0.0.52/src/codegeneration/PlaceholderParser").parseStatement; var ReturnState = function ReturnState() { $traceurRuntime.defaultSuperCall(this, $ReturnState.prototype, arguments); }; var $ReturnState = ReturnState; ($traceurRuntime.createClass)(ReturnState, {transform: function(enclosingFinally, machineEndState, reporter) { var $__528; var e = this.expression; var statements = []; if (e && !isUndefined(e) && !isVoidExpression(e)) statements.push(parseStatement($__522, this.expression)); ($__528 = statements).push.apply($__528, $traceurRuntime.spread(State.generateJump(enclosingFinally, machineEndState))); return statements; }}, {}, YieldState); return {get ReturnState() { return ReturnState; }}; }); System.register("traceur@0.0.52/src/codegeneration/generator/GeneratorTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/generator/GeneratorTransformer"; var $__529 = Object.freeze(Object.defineProperties(["\n ", " = ", "[Symbol.iterator]();\n // received = void 0;\n $ctx.sent = void 0;\n // send = true; // roughly equivalent\n $ctx.action = 'next';\n\n for (;;) {\n ", " = ", "[$ctx.action]($ctx.sentIgnoreThrow);\n if (", ".done) {\n $ctx.sent = ", ".value;\n break;\n }\n ", ";\n }"], {raw: {value: Object.freeze(["\n ", " = ", "[Symbol.iterator]();\n // received = void 0;\n $ctx.sent = void 0;\n // send = true; // roughly equivalent\n $ctx.action = 'next';\n\n for (;;) {\n ", " = ", "[$ctx.action]($ctx.sentIgnoreThrow);\n if (", ".done) {\n $ctx.sent = ", ".value;\n break;\n }\n ", ";\n }"])}})), $__530 = Object.freeze(Object.defineProperties(["$ctx.sentIgnoreThrow"], {raw: {value: Object.freeze(["$ctx.sentIgnoreThrow"])}})), $__531 = Object.freeze(Object.defineProperties(["$ctx.sent"], {raw: {value: Object.freeze(["$ctx.sent"])}})), $__532 = Object.freeze(Object.defineProperties(["$ctx.maybeThrow()"], {raw: {value: Object.freeze(["$ctx.maybeThrow()"])}})), $__533 = Object.freeze(Object.defineProperties(["$traceurRuntime.createGeneratorInstance"], {raw: {value: Object.freeze(["$traceurRuntime.createGeneratorInstance"])}})); var CPSTransformer = System.get("traceur@0.0.52/src/codegeneration/generator/CPSTransformer").CPSTransformer; var $__535 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), BINARY_EXPRESSION = $__535.BINARY_EXPRESSION, YIELD_EXPRESSION = $__535.YIELD_EXPRESSION; var $__536 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), BinaryExpression = $__536.BinaryExpression, ExpressionStatement = $__536.ExpressionStatement; var FindInFunctionScope = System.get("traceur@0.0.52/src/codegeneration/FindInFunctionScope").FindInFunctionScope; var ReturnState = System.get("traceur@0.0.52/src/codegeneration/generator/ReturnState").ReturnState; var YieldState = System.get("traceur@0.0.52/src/codegeneration/generator/YieldState").YieldState; var $__540 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), id = $__540.createIdentifierExpression, createMemberExpression = $__540.createMemberExpression, createUndefinedExpression = $__540.createUndefinedExpression, createYieldStatement = $__540.createYieldStatement; var $__541 = System.get("traceur@0.0.52/src/codegeneration/PlaceholderParser"), parseExpression = $__541.parseExpression, parseStatement = $__541.parseStatement, parseStatements = $__541.parseStatements; function isYieldAssign(tree) { return tree.type === BINARY_EXPRESSION && tree.operator.isAssignmentOperator() && tree.right.type === YIELD_EXPRESSION && tree.left.isLeftHandSideExpression(); } var YieldFinder = function YieldFinder() { $traceurRuntime.defaultSuperCall(this, $YieldFinder.prototype, arguments); }; var $YieldFinder = YieldFinder; ($traceurRuntime.createClass)(YieldFinder, {visitYieldExpression: function(tree) { this.found = true; }}, {}, FindInFunctionScope); function scopeContainsYield(tree) { return new YieldFinder(tree).found; } var GeneratorTransformer = function GeneratorTransformer(identifierGenerator, reporter) { $traceurRuntime.superCall(this, $GeneratorTransformer.prototype, "constructor", [identifierGenerator, reporter]); this.shouldAppendThrowCloseState_ = true; }; var $GeneratorTransformer = GeneratorTransformer; ($traceurRuntime.createClass)(GeneratorTransformer, { expressionNeedsStateMachine: function(tree) { if (tree === null) return false; return scopeContainsYield(tree); }, transformYieldExpression_: function(tree) { var $__543; var expression, machine; if (this.expressionNeedsStateMachine(tree.expression)) { (($__543 = $traceurRuntime.assertObject(this.expressionToStateMachine(tree.expression)), expression = $__543.expression, machine = $__543.machine, $__543)); } else { expression = this.transformAny(tree.expression); if (!expression) expression = createUndefinedExpression(); } if (tree.isYieldFor) return this.transformYieldForExpression_(expression, machine); var startState = this.allocateState(); var fallThroughState = this.allocateState(); var yieldMachine = this.stateToStateMachine_(new YieldState(startState, fallThroughState, this.transformAny(expression)), fallThroughState); if (machine) yieldMachine = machine.append(yieldMachine); if (this.shouldAppendThrowCloseState_) yieldMachine = yieldMachine.append(this.createThrowCloseState_()); return yieldMachine; }, transformYieldForExpression_: function(expression) { var machine = arguments[1]; var gName = this.getTempIdentifier(); this.addMachineVariable(gName); var g = id(gName); var nextName = this.getTempIdentifier(); this.addMachineVariable(nextName); var next = id(nextName); var statements = parseStatements($__529, g, expression, next, g, next, next, createYieldStatement(createMemberExpression(next, 'value'))); var shouldAppendThrowCloseState = this.shouldAppendThrowCloseState_; this.shouldAppendThrowCloseState_ = false; statements = this.transformList(statements); var yieldMachine = this.transformStatementList_(statements); this.shouldAppendThrowCloseState_ = shouldAppendThrowCloseState; if (machine) yieldMachine = machine.append(yieldMachine); return yieldMachine; }, transformYieldExpression: function(tree) { this.reporter.reportError(tree.location.start, 'Only \'a = yield b\' and \'var a = yield b\' currently supported.'); return tree; }, transformYieldAssign_: function(tree) { var shouldAppendThrowCloseState = this.shouldAppendThrowCloseState_; this.shouldAppendThrowCloseState_ = false; var machine = this.transformYieldExpression_(tree.right); var left = this.transformAny(tree.left); var sentExpression = tree.right.isYieldFor ? parseExpression($__530) : parseExpression($__531); var statement = new ExpressionStatement(tree.location, new BinaryExpression(tree.location, left, tree.operator, sentExpression)); var assignMachine = this.statementToStateMachine_(statement); this.shouldAppendThrowCloseState_ = shouldAppendThrowCloseState; return machine.append(assignMachine); }, createThrowCloseState_: function() { return this.statementToStateMachine_(parseStatement($__532)); }, transformExpressionStatement: function(tree) { var expression = tree.expression; if (expression.type === YIELD_EXPRESSION) return this.transformYieldExpression_(expression); if (isYieldAssign(expression)) return this.transformYieldAssign_(expression); if (this.expressionNeedsStateMachine(expression)) { return this.expressionToStateMachine(expression).machine; } return $traceurRuntime.superCall(this, $GeneratorTransformer.prototype, "transformExpressionStatement", [tree]); }, transformAwaitStatement: function(tree) { this.reporter.reportError(tree.location.start, 'Generator function may not have an await statement.'); return tree; }, transformReturnStatement: function(tree) { var $__543; var expression, machine; if (this.expressionNeedsStateMachine(tree.expression)) (($__543 = $traceurRuntime.assertObject(this.expressionToStateMachine(tree.expression)), expression = $__543.expression, machine = $__543.machine, $__543)); else expression = tree.expression; var startState = this.allocateState(); var fallThroughState = this.allocateState(); var returnMachine = this.stateToStateMachine_(new ReturnState(startState, fallThroughState, this.transformAny(expression)), fallThroughState); if (machine) return machine.append(returnMachine); return returnMachine; }, transformGeneratorBody: function(tree, name) { var runtimeFunction = parseExpression($__533); return this.transformCpsFunctionBody(tree, runtimeFunction, name); } }, {transformGeneratorBody: function(identifierGenerator, reporter, body, name) { return new $GeneratorTransformer(identifierGenerator, reporter).transformGeneratorBody(body, name); }}, CPSTransformer); ; return {get GeneratorTransformer() { return GeneratorTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/GeneratorTransformPass", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/GeneratorTransformPass"; var $__544 = Object.freeze(Object.defineProperties(["$traceurRuntime.initGeneratorFunction(", ")"], {raw: {value: Object.freeze(["$traceurRuntime.initGeneratorFunction(", ")"])}})), $__545 = Object.freeze(Object.defineProperties(["var ", " = ", ""], {raw: {value: Object.freeze(["var ", " = ", ""])}})), $__546 = Object.freeze(Object.defineProperties(["$traceurRuntime.initGeneratorFunction(", ")"], {raw: {value: Object.freeze(["$traceurRuntime.initGeneratorFunction(", ")"])}})); var ArrowFunctionTransformer = System.get("traceur@0.0.52/src/codegeneration/ArrowFunctionTransformer").ArrowFunctionTransformer; var AsyncTransformer = System.get("traceur@0.0.52/src/codegeneration/generator/AsyncTransformer").AsyncTransformer; var ForInTransformPass = System.get("traceur@0.0.52/src/codegeneration/generator/ForInTransformPass").ForInTransformPass; var GeneratorTransformer = System.get("traceur@0.0.52/src/codegeneration/generator/GeneratorTransformer").GeneratorTransformer; var $__551 = System.get("traceur@0.0.52/src/codegeneration/PlaceholderParser"), parseExpression = $__551.parseExpression, parseStatement = $__551.parseStatement; var TempVarTransformer = System.get("traceur@0.0.52/src/codegeneration/TempVarTransformer").TempVarTransformer; var FindInFunctionScope = System.get("traceur@0.0.52/src/codegeneration/FindInFunctionScope").FindInFunctionScope; var $__554 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), AnonBlock = $__554.AnonBlock, FunctionDeclaration = $__554.FunctionDeclaration, FunctionExpression = $__554.FunctionExpression; var $__555 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createBindingIdentifier = $__555.createBindingIdentifier, id = $__555.createIdentifierExpression, createIdentifierToken = $__555.createIdentifierToken; var transformOptions = System.get("traceur@0.0.52/src/Options").transformOptions; var ForInFinder = function ForInFinder() { $traceurRuntime.defaultSuperCall(this, $ForInFinder.prototype, arguments); }; var $ForInFinder = ForInFinder; ($traceurRuntime.createClass)(ForInFinder, {visitForInStatement: function(tree) { this.found = true; }}, {}, FindInFunctionScope); function needsTransform(tree) { return transformOptions.generators && tree.isGenerator() || transformOptions.asyncFunctions && tree.isAsyncFunction(); } var GeneratorTransformPass = function GeneratorTransformPass(identifierGenerator, reporter) { $traceurRuntime.superCall(this, $GeneratorTransformPass.prototype, "constructor", [identifierGenerator]); this.reporter_ = reporter; this.inBlock_ = false; }; var $GeneratorTransformPass = GeneratorTransformPass; ($traceurRuntime.createClass)(GeneratorTransformPass, { transformFunctionDeclaration: function(tree) { if (!needsTransform(tree)) return $traceurRuntime.superCall(this, $GeneratorTransformPass.prototype, "transformFunctionDeclaration", [tree]); if (tree.isGenerator()) return this.transformGeneratorDeclaration_(tree); return this.transformFunction_(tree, FunctionDeclaration, null); }, transformGeneratorDeclaration_: function(tree) { var nameIdExpression = id(tree.name.identifierToken); var setupPrototypeExpression = parseExpression($__544, nameIdExpression); var tmpVar = id(this.inBlock_ ? this.getTempIdentifier() : this.addTempVar(setupPrototypeExpression)); var funcDecl = this.transformFunction_(tree, FunctionDeclaration, tmpVar); if (!this.inBlock_) return funcDecl; return new AnonBlock(null, [funcDecl, parseStatement($__545, tmpVar, setupPrototypeExpression)]); }, transformFunctionExpression: function(tree) { if (!needsTransform(tree)) return $traceurRuntime.superCall(this, $GeneratorTransformPass.prototype, "transformFunctionExpression", [tree]); if (tree.isGenerator()) return this.transformGeneratorExpression_(tree); return this.transformFunction_(tree, FunctionExpression, null); }, transformGeneratorExpression_: function(tree) { var name; if (!tree.name) { name = createIdentifierToken(this.getTempIdentifier()); tree = new FunctionExpression(tree.location, createBindingIdentifier(name), tree.functionKind, tree.parameterList, tree.typeAnnotation, tree.annotations, tree.body); } else { name = tree.name.identifierToken; } var functionExpression = this.transformFunction_(tree, FunctionExpression, id(name)); return parseExpression($__546, functionExpression); }, transformFunction_: function(tree, constructor, nameExpression) { var body = $traceurRuntime.superCall(this, $GeneratorTransformPass.prototype, "transformAny", [tree.body]); var finder = new ForInFinder(body); if (finder.found) { body = new ForInTransformPass(this.identifierGenerator).transformAny(body); } if (transformOptions.generators && tree.isGenerator()) { body = GeneratorTransformer.transformGeneratorBody(this.identifierGenerator, this.reporter_, body, nameExpression); } else if (transformOptions.asyncFunctions && tree.isAsyncFunction()) { body = AsyncTransformer.transformAsyncBody(this.identifierGenerator, this.reporter_, body); } var functionKind = null; return new constructor(tree.location, tree.name, functionKind, tree.parameterList, tree.typeAnnotation || null, tree.annotations || null, body); }, transformArrowFunctionExpression: function(tree) { if (!tree.isAsyncFunction()) return $traceurRuntime.superCall(this, $GeneratorTransformPass.prototype, "transformArrowFunctionExpression", [tree]); return this.transformAny(ArrowFunctionTransformer.transform(this, tree)); }, transformBlock: function(tree) { var inBlock = this.inBlock_; this.inBlock_ = true; var rv = $traceurRuntime.superCall(this, $GeneratorTransformPass.prototype, "transformBlock", [tree]); this.inBlock_ = inBlock; return rv; } }, {}, TempVarTransformer); return {get GeneratorTransformPass() { return GeneratorTransformPass; }}; }); System.register("traceur@0.0.52/src/codegeneration/InlineModuleTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/InlineModuleTransformer"; var VAR = System.get("traceur@0.0.52/src/syntax/TokenType").VAR; var assert = System.get("traceur@0.0.52/src/util/assert").assert; var ModuleTransformer = System.get("traceur@0.0.52/src/codegeneration/ModuleTransformer").ModuleTransformer; var $__561 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createBindingIdentifier = $__561.createBindingIdentifier, createEmptyStatement = $__561.createEmptyStatement, createFunctionBody = $__561.createFunctionBody, createImmediatelyInvokedFunctionExpression = $__561.createImmediatelyInvokedFunctionExpression, createScopedExpression = $__561.createScopedExpression, createVariableStatement = $__561.createVariableStatement; var globalThis = System.get("traceur@0.0.52/src/codegeneration/globalThis").default; var scopeContainsThis = System.get("traceur@0.0.52/src/codegeneration/scopeContainsThis").default; var InlineModuleTransformer = function InlineModuleTransformer() { $traceurRuntime.defaultSuperCall(this, $InlineModuleTransformer.prototype, arguments); }; var $InlineModuleTransformer = InlineModuleTransformer; ($traceurRuntime.createClass)(InlineModuleTransformer, { wrapModule: function(statements) { assert(this.moduleName); var idName = this.getTempVarNameForModuleName(this.moduleName); var body = createFunctionBody(statements); var moduleExpression; if (statements.some(scopeContainsThis)) { moduleExpression = createScopedExpression(body, globalThis()); } else { moduleExpression = createImmediatelyInvokedFunctionExpression(body); } return [createVariableStatement(VAR, idName, moduleExpression)]; }, transformNamedExport: function(tree) { return createEmptyStatement(); }, transformModuleSpecifier: function(tree) { return createBindingIdentifier(this.getTempVarNameForModuleSpecifier(tree)); } }, {}, ModuleTransformer); return {get InlineModuleTransformer() { return InlineModuleTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/InstantiateModuleTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/InstantiateModuleTransformer"; var $__565 = Object.freeze(Object.defineProperties(["", " = ", ""], {raw: {value: Object.freeze(["", " = ", ""])}})), $__566 = Object.freeze(Object.defineProperties(["$__export(", ", ", ")"], {raw: {value: Object.freeze(["$__export(", ", ", ")"])}})), $__567 = Object.freeze(Object.defineProperties(["($__export(", ", ", " + 1), ", ")"], {raw: {value: Object.freeze(["($__export(", ", ", " + 1), ", ")"])}})), $__568 = Object.freeze(Object.defineProperties(["$__export(", ", ", ")}"], {raw: {value: Object.freeze(["$__export(", ", ", ")}"])}})), $__569 = Object.freeze(Object.defineProperties(["System.register(", ", ", ", function($__export) {\n ", "\n });"], {raw: {value: Object.freeze(["System.register(", ", ", ", function($__export) {\n ", "\n });"])}})), $__570 = Object.freeze(Object.defineProperties(["System.register(", ", function($__export) {\n ", "\n });"], {raw: {value: Object.freeze(["System.register(", ", function($__export) {\n ", "\n });"])}})), $__571 = Object.freeze(Object.defineProperties(["", " = m.", ";"], {raw: {value: Object.freeze(["", " = m.", ";"])}})), $__572 = Object.freeze(Object.defineProperties(["$__export(", ", m.", ");"], {raw: {value: Object.freeze(["$__export(", ", m.", ");"])}})), $__573 = Object.freeze(Object.defineProperties(["", " = m;"], {raw: {value: Object.freeze(["", " = m;"])}})), $__574 = Object.freeze(Object.defineProperties(["\n Object.keys(m).forEach(function(p) {\n $__export(p, m[p]);\n });\n "], {raw: {value: Object.freeze(["\n Object.keys(m).forEach(function(p) {\n $__export(p, m[p]);\n });\n "])}})), $__575 = Object.freeze(Object.defineProperties(["function(m) {\n ", "\n }"], {raw: {value: Object.freeze(["function(m) {\n ", "\n }"])}})), $__576 = Object.freeze(Object.defineProperties(["function(m) {}"], {raw: {value: Object.freeze(["function(m) {}"])}})), $__577 = Object.freeze(Object.defineProperties(["\n $__export(", ", ", ")\n "], {raw: {value: Object.freeze(["\n $__export(", ", ", ")\n "])}})), $__578 = Object.freeze(Object.defineProperties(["return {\n setters: ", ",\n execute: ", "\n }"], {raw: {value: Object.freeze(["return {\n setters: ", ",\n execute: ", "\n }"])}})), $__579 = Object.freeze(Object.defineProperties(["$__export(", ", ", ")"], {raw: {value: Object.freeze(["$__export(", ", ", ")"])}})), $__580 = Object.freeze(Object.defineProperties(["$__export(", ", ", ")"], {raw: {value: Object.freeze(["$__export(", ", ", ")"])}})), $__581 = Object.freeze(Object.defineProperties(["var ", " = $__export(", ", ", ");"], {raw: {value: Object.freeze(["var ", " = $__export(", ", ", ");"])}})), $__582 = Object.freeze(Object.defineProperties(["var ", ";"], {raw: {value: Object.freeze(["var ", ";"])}})), $__583 = Object.freeze(Object.defineProperties(["$__export('default', ", ");"], {raw: {value: Object.freeze(["$__export('default', ", ");"])}})), $__584 = Object.freeze(Object.defineProperties(["$__export(", ", ", ");"], {raw: {value: Object.freeze(["$__export(", ", ", ");"])}})), $__585 = Object.freeze(Object.defineProperties(["var ", ";"], {raw: {value: Object.freeze(["var ", ";"])}})); var $__586 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), AnonBlock = $__586.AnonBlock, ArrayLiteralExpression = $__586.ArrayLiteralExpression, ClassExpression = $__586.ClassExpression, CommaExpression = $__586.CommaExpression, ExpressionStatement = $__586.ExpressionStatement; var $__587 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), FUNCTION_DECLARATION = $__587.FUNCTION_DECLARATION, IDENTIFIER_EXPRESSION = $__587.IDENTIFIER_EXPRESSION, IMPORT_SPECIFIER_SET = $__587.IMPORT_SPECIFIER_SET; var ScopeTransformer = System.get("traceur@0.0.52/src/codegeneration/ScopeTransformer").ScopeTransformer; var $__589 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), id = $__589.createIdentifierExpression, createIdentifierToken = $__589.createIdentifierToken, createVariableStatement = $__589.createVariableStatement, createVariableDeclaration = $__589.createVariableDeclaration, createVariableDeclarationList = $__589.createVariableDeclarationList; var ModuleTransformer = System.get("traceur@0.0.52/src/codegeneration/ModuleTransformer").ModuleTransformer; var $__591 = System.get("traceur@0.0.52/src/syntax/TokenType"), MINUS_MINUS = $__591.MINUS_MINUS, PLUS_PLUS = $__591.PLUS_PLUS, VAR = $__591.VAR; var $__592 = System.get("traceur@0.0.52/src/codegeneration/PlaceholderParser"), parseExpression = $__592.parseExpression, parseStatement = $__592.parseStatement, parseStatements = $__592.parseStatements; var HoistVariablesTransformer = System.get("traceur@0.0.52/src/codegeneration/HoistVariablesTransformer").default; var $__594 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createFunctionExpression = $__594.createFunctionExpression, createEmptyParameterList = $__594.createEmptyParameterList, createFunctionBody = $__594.createFunctionBody; var DeclarationExtractionTransformer = function DeclarationExtractionTransformer() { $traceurRuntime.superCall(this, $DeclarationExtractionTransformer.prototype, "constructor", []); this.declarations_ = []; }; var $DeclarationExtractionTransformer = DeclarationExtractionTransformer; ($traceurRuntime.createClass)(DeclarationExtractionTransformer, { getDeclarationStatements: function() { return $traceurRuntime.spread([this.getVariableStatement()], this.declarations_); }, addDeclaration: function(tree) { this.declarations_.push(tree); }, transformFunctionDeclaration: function(tree) { this.addDeclaration(tree); return new AnonBlock(null, []); }, transformClassDeclaration: function(tree) { this.addVariable(tree.name.identifierToken.value); tree = new ClassExpression(tree.location, tree.name, tree.superClass, tree.elements, tree.annotations); return parseStatement($__565, tree.name.identifierToken, tree); } }, {}, HoistVariablesTransformer); var InsertBindingAssignmentTransformer = function InsertBindingAssignmentTransformer(exportName, bindingName) { $traceurRuntime.superCall(this, $InsertBindingAssignmentTransformer.prototype, "constructor", [bindingName]); this.bindingName_ = bindingName; this.exportName_ = exportName; }; var $InsertBindingAssignmentTransformer = InsertBindingAssignmentTransformer; ($traceurRuntime.createClass)(InsertBindingAssignmentTransformer, { matchesBindingName_: function(binding) { return binding.type === IDENTIFIER_EXPRESSION && binding.identifierToken.value == this.bindingName_; }, transformUnaryExpression: function(tree) { if (!this.matchesBindingName_(tree.operand)) return $traceurRuntime.superCall(this, $InsertBindingAssignmentTransformer.prototype, "transformUnaryExpression", [tree]); var operatorType = tree.operator.type; if (operatorType !== PLUS_PLUS && operatorType !== MINUS_MINUS) return $traceurRuntime.superCall(this, $InsertBindingAssignmentTransformer.prototype, "transformUnaryExpression", [tree]); var operand = this.transformAny(tree.operand); if (operand !== tree.operand) tree = new UnaryExpression(tree.location, tree.operator, operand); return parseExpression($__566, this.exportName_, tree); }, transformPostfixExpression: function(tree) { tree = $traceurRuntime.superCall(this, $InsertBindingAssignmentTransformer.prototype, "transformPostfixExpression", [tree]); if (!this.matchesBindingName_(tree.operand)) return tree; return parseExpression($__567, this.exportName_, tree.operand, tree); }, transformBinaryExpression: function(tree) { tree = $traceurRuntime.superCall(this, $InsertBindingAssignmentTransformer.prototype, "transformBinaryExpression", [tree]); if (!tree.operator.isAssignmentOperator()) return tree; if (!this.matchesBindingName_(tree.left)) return tree; return parseExpression($__568, this.exportName_, tree); } }, {}, ScopeTransformer); var InstantiateModuleTransformer = function InstantiateModuleTransformer(identifierGenerator) { $traceurRuntime.superCall(this, $InstantiateModuleTransformer.prototype, "constructor", [identifierGenerator]); this.inExport_ = false; this.curDepIndex_ = null; this.dependencies = []; this.externalExportBindings = []; this.importBindings = []; this.localExportBindings = []; this.functionDeclarations = []; this.moduleBindings = []; this.exportStarBindings = []; }; var $InstantiateModuleTransformer = InstantiateModuleTransformer; ($traceurRuntime.createClass)(InstantiateModuleTransformer, { wrapModule: function(statements) { if (this.moduleName) { return parseStatements($__569, this.moduleName, this.dependencies, statements); } else { return parseStatements($__570, this.dependencies, statements); } }, appendExportStatement: function(statements) { var $__595 = this; var declarationExtractionTransformer = new DeclarationExtractionTransformer(); this.localExportBindings.forEach((function(binding) { statements = new InsertBindingAssignmentTransformer(binding.exportName, binding.localName).transformList(statements); })); var executionStatements = statements.map((function(statement) { return declarationExtractionTransformer.transformAny(statement); })); var executionFunction = createFunctionExpression(createEmptyParameterList(), createFunctionBody(executionStatements)); var declarationStatements = declarationExtractionTransformer.getDeclarationStatements(); var setterFunctions = this.dependencies.map((function(dep, index) { var importBindings = $__595.importBindings[index]; var externalExportBindings = $__595.externalExportBindings[index]; var exportStarBinding = $__595.exportStarBindings[index]; var moduleBinding = $__595.moduleBindings[index]; var setterStatements = []; if (importBindings) { importBindings.forEach((function(binding) { setterStatements.push(parseStatement($__571, createIdentifierToken(binding.variableName), binding.exportName)); })); } if (externalExportBindings) { externalExportBindings.forEach((function(binding) { setterStatements.push(parseStatement($__572, binding.exportName, binding.importName)); })); } if (moduleBinding) { setterStatements.push(parseStatement($__573, id(moduleBinding))); } if (exportStarBinding) { setterStatements = setterStatements.concat(parseStatements($__574)); } if (setterStatements.length) { return parseExpression($__575, setterStatements); } else { return parseExpression($__576); } })); declarationStatements = declarationStatements.concat(this.functionDeclarations.map((function(binding) { return parseStatement($__577, binding.exportName, createIdentifierToken(binding.functionName)); }))); declarationStatements.push(parseStatement($__578, new ArrayLiteralExpression(null, setterFunctions), executionFunction)); return declarationStatements; }, addLocalExportBinding: function(exportName) { var localName = arguments[1] !== (void 0) ? arguments[1] : exportName; this.localExportBindings.push({ exportName: exportName, localName: localName }); }, addImportBinding: function(depIndex, variableName, exportName) { this.importBindings[depIndex] = this.importBindings[depIndex] || []; this.importBindings[depIndex].push({ variableName: variableName, exportName: exportName }); }, addExternalExportBinding: function(depIndex, exportName, importName) { this.externalExportBindings[depIndex] = this.externalExportBindings[depIndex] || []; this.externalExportBindings[depIndex].push({ exportName: exportName, importName: importName }); }, addExportStarBinding: function(depIndex) { this.exportStarBindings[depIndex] = true; }, addModuleBinding: function(depIndex, variableName) { this.moduleBindings[depIndex] = variableName; }, addExportFunction: function(exportName) { var functionName = arguments[1] !== (void 0) ? arguments[1] : exportName; this.functionDeclarations.push({ exportName: exportName, functionName: functionName }); }, getOrCreateDependencyIndex: function(moduleSpecifier) { var name = moduleSpecifier.token.processedValue; var depIndex = this.dependencies.indexOf(name); if (depIndex == -1) { depIndex = this.dependencies.length; this.dependencies.push(name); } return depIndex; }, transformExportDeclaration: function(tree) { this.inExport_ = true; if (tree.declaration.moduleSpecifier) { this.curDepIndex_ = this.getOrCreateDependencyIndex(tree.declaration.moduleSpecifier); } else { this.curDepIndex_ = null; } var transformed = this.transformAny(tree.declaration); this.inExport_ = false; return transformed; }, transformVariableStatement: function(tree) { var $__595 = this; if (!this.inExport_) return $traceurRuntime.superCall(this, $InstantiateModuleTransformer.prototype, "transformVariableStatement", [tree]); this.inExport_ = false; return createVariableStatement(createVariableDeclarationList(VAR, tree.declarations.declarations.map((function(declaration) { var varName = declaration.lvalue.identifierToken.value; var initializer; $__595.addLocalExportBinding(varName); if (declaration.initializer) initializer = parseExpression($__579, varName, $__595.transformAny(declaration.initializer)); else initializer = parseExpression($__580, varName, id(varName)); return createVariableDeclaration(varName, initializer); })))); }, transformExportStar: function(tree) { this.inExport_ = false; this.addExportStarBinding(this.curDepIndex_); return new AnonBlock(null, []); }, transformClassDeclaration: function(tree) { if (!this.inExport_) return $traceurRuntime.superCall(this, $InstantiateModuleTransformer.prototype, "transformClassDeclaration", [tree]); this.inExport_ = false; var name = this.transformAny(tree.name); var superClass = this.transformAny(tree.superClass); var elements = this.transformList(tree.elements); var annotations = this.transformList(tree.annotations); var varName = name.identifierToken.value; var classExpression = new ClassExpression(tree.location, name, superClass, elements, annotations); this.addLocalExportBinding(varName); return parseStatement($__581, varName, varName, classExpression); }, transformFunctionDeclaration: function(tree) { if (this.inExport_) { this.addLocalExportBinding(tree.name.identifierToken.value); this.addExportFunction(tree.name.identifierToken.value); this.inExport_ = false; } return $traceurRuntime.superCall(this, $InstantiateModuleTransformer.prototype, "transformFunctionDeclaration", [tree]); }, transformNamedExport: function(tree) { this.transformAny(tree.moduleSpecifier); var specifierSet = this.transformAny(tree.specifierSet); if (this.curDepIndex_ === null) { return specifierSet; } else { return new AnonBlock(null, []); } }, transformImportDeclaration: function(tree) { this.curDepIndex_ = this.getOrCreateDependencyIndex(tree.moduleSpecifier); var initializer = this.transformAny(tree.moduleSpecifier); if (!tree.importClause) return new AnonBlock(null, []); var importClause = this.transformAny(tree.importClause); if (tree.importClause.type === IMPORT_SPECIFIER_SET) { return importClause; } else { this.addImportBinding(this.curDepIndex_, tree.importClause.binding.identifierToken.value, 'default'); return parseStatement($__582, tree.importClause.binding.identifierToken.value); } return new AnonBlock(null, []); }, transformImportSpecifierSet: function(tree) { return createVariableStatement(createVariableDeclarationList(VAR, this.transformList(tree.specifiers))); }, transformExportDefault: function(tree) { var expression = this.transformAny(tree.expression); this.addLocalExportBinding('default'); if (expression.type === FUNCTION_DECLARATION) { this.addExportFunction('default', expression.name.identifierToken.value); return expression; } else { return parseStatement($__583, expression); } }, transformExportSpecifier: function(tree) { var exportName; var bindingName; if (tree.rhs) { exportName = tree.rhs.value; bindingName = tree.lhs.value; } else { exportName = tree.lhs.value; bindingName = tree.lhs.value; } if (this.curDepIndex_ !== null) { this.addExternalExportBinding(this.curDepIndex_, exportName, bindingName); } else { this.addLocalExportBinding(exportName, bindingName); return parseExpression($__584, exportName, id(bindingName)); } }, transformExportSpecifierSet: function(tree) { var specifiers = this.transformList(tree.specifiers); return new ExpressionStatement(tree.location, new CommaExpression(tree.location, specifiers.filter((function(specifier) { return specifier; })))); }, transformImportSpecifier: function(tree) { var importName; var localBinding; if (tree.rhs) { localBinding = tree.rhs; importName = tree.lhs.value; } else { localBinding = tree.lhs; importName = tree.lhs.value; } this.addImportBinding(this.curDepIndex_, localBinding.value, importName); return createVariableDeclaration(localBinding); }, transformModuleDeclaration: function(tree) { this.transformAny(tree.expression); this.addModuleBinding(this.curDepIndex_, tree.identifier.value); return parseStatement($__585, tree.identifier.value); }, transformModuleSpecifier: function(tree) { this.curDepIndex_ = this.getOrCreateDependencyIndex(tree); return tree; } }, {}, ModuleTransformer); return {get InstantiateModuleTransformer() { return InstantiateModuleTransformer; }}; }); System.register("traceur@0.0.52/src/outputgeneration/ParseTreeWriter", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/outputgeneration/ParseTreeWriter"; var $__597 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), BLOCK = $__597.BLOCK, CLASS_DECLARATION = $__597.CLASS_DECLARATION, FUNCTION_DECLARATION = $__597.FUNCTION_DECLARATION, IF_STATEMENT = $__597.IF_STATEMENT, LITERAL_EXPRESSION = $__597.LITERAL_EXPRESSION, POSTFIX_EXPRESSION = $__597.POSTFIX_EXPRESSION, UNARY_EXPRESSION = $__597.UNARY_EXPRESSION; var ParseTreeVisitor = System.get("traceur@0.0.52/src/syntax/ParseTreeVisitor").ParseTreeVisitor; var $__599 = System.get("traceur@0.0.52/src/syntax/PredefinedName"), AS = $__599.AS, ASYNC = $__599.ASYNC, AWAIT = $__599.AWAIT, FROM = $__599.FROM, GET = $__599.GET, OF = $__599.OF, MODULE = $__599.MODULE, SET = $__599.SET; var $__600 = System.get("traceur@0.0.52/src/syntax/Scanner"), isIdentifierPart = $__600.isIdentifierPart, isWhitespace = $__600.isWhitespace; var $__601 = System.get("traceur@0.0.52/src/syntax/TokenType"), ARROW = $__601.ARROW, AT = $__601.AT, BACK_QUOTE = $__601.BACK_QUOTE, BREAK = $__601.BREAK, CASE = $__601.CASE, CATCH = $__601.CATCH, CLASS = $__601.CLASS, CLOSE_CURLY = $__601.CLOSE_CURLY, CLOSE_PAREN = $__601.CLOSE_PAREN, CLOSE_SQUARE = $__601.CLOSE_SQUARE, COLON = $__601.COLON, COMMA = $__601.COMMA, CONTINUE = $__601.CONTINUE, DEBUGGER = $__601.DEBUGGER, DEFAULT = $__601.DEFAULT, DO = $__601.DO, DOT_DOT_DOT = $__601.DOT_DOT_DOT, ELSE = $__601.ELSE, EQUAL = $__601.EQUAL, EXPORT = $__601.EXPORT, EXTENDS = $__601.EXTENDS, FINALLY = $__601.FINALLY, FOR = $__601.FOR, FUNCTION = $__601.FUNCTION, IF = $__601.IF, IMPORT = $__601.IMPORT, IN = $__601.IN, MINUS = $__601.MINUS, MINUS_MINUS = $__601.MINUS_MINUS, NEW = $__601.NEW, NUMBER = $__601.NUMBER, OPEN_CURLY = $__601.OPEN_CURLY, OPEN_PAREN = $__601.OPEN_PAREN, OPEN_SQUARE = $__601.OPEN_SQUARE, PERIOD = $__601.PERIOD, PLUS = $__601.PLUS, PLUS_PLUS = $__601.PLUS_PLUS, QUESTION = $__601.QUESTION, RETURN = $__601.RETURN, SEMI_COLON = $__601.SEMI_COLON, STAR = $__601.STAR, STATIC = $__601.STATIC, SUPER = $__601.SUPER, SWITCH = $__601.SWITCH, THIS = $__601.THIS, THROW = $__601.THROW, TRY = $__601.TRY, WHILE = $__601.WHILE, WITH = $__601.WITH, YIELD = $__601.YIELD; var NEW_LINE = '\n'; var LINE_LENGTH = 80; var ParseTreeWriter = function ParseTreeWriter() { var $__604, $__605, $__606; var $__603 = $traceurRuntime.assertObject(arguments[0] !== (void 0) ? arguments[0] : {}), highlighted = ($__604 = $__603.highlighted) === void 0 ? false : $__604, showLineNumbers = ($__605 = $__603.showLineNumbers) === void 0 ? false : $__605, prettyPrint = ($__606 = $__603.prettyPrint) === void 0 ? true : $__606; $traceurRuntime.superCall(this, $ParseTreeWriter.prototype, "constructor", []); this.highlighted_ = highlighted; this.showLineNumbers_ = showLineNumbers; this.prettyPrint_ = prettyPrint; this.result_ = ''; this.currentLine_ = ''; this.currentLineComment_ = null; this.indentDepth_ = 0; this.currentParameterTypeAnnotation_ = null; }; var $ParseTreeWriter = ParseTreeWriter; ($traceurRuntime.createClass)(ParseTreeWriter, { toString: function() { if (this.currentLine_.length > 0) { this.result_ += this.currentLine_; this.currentLine_ = ''; } return this.result_; }, visitAny: function(tree) { if (!tree) { return; } if (tree === this.highlighted_) { this.write_('\x1B[41m'); } if (tree.location !== null && tree.location.start !== null && this.showLineNumbers_) { var line = tree.location.start.line + 1; var column = tree.location.start.column; this.currentLineComment_ = ("Line: " + line + "." + column); } $traceurRuntime.superCall(this, $ParseTreeWriter.prototype, "visitAny", [tree]); if (tree === this.highlighted_) { this.write_('\x1B[0m'); } }, visitAnnotation: function(tree) { this.write_(AT); this.visitAny(tree.name); if (tree.args !== null) { this.write_(OPEN_PAREN); this.writeList_(tree.args, COMMA, false); this.write_(CLOSE_PAREN); } }, visitArgumentList: function(tree) { this.write_(OPEN_PAREN); this.writeList_(tree.args, COMMA, false); this.write_(CLOSE_PAREN); }, visitArrayComprehension: function(tree) { this.write_(OPEN_SQUARE); this.visitList(tree.comprehensionList); this.visitAny(tree.expression); this.write_(CLOSE_SQUARE); }, visitArrayLiteralExpression: function(tree) { this.write_(OPEN_SQUARE); this.writeList_(tree.elements, COMMA, false); this.write_(CLOSE_SQUARE); }, visitArrayPattern: function(tree) { this.write_(OPEN_SQUARE); this.writeList_(tree.elements, COMMA, false); this.write_(CLOSE_SQUARE); }, visitArrowFunctionExpression: function(tree) { if (tree.functionKind) { this.write_(tree.functionKind); this.writeSpace_(); } this.write_(OPEN_PAREN); this.visitAny(tree.parameterList); this.write_(CLOSE_PAREN); this.writeSpace_(); this.write_(ARROW); this.writeSpace_(); this.visitAny(tree.body); }, visitAssignmentElement: function(tree) { this.visitAny(tree.assignment); if (tree.initializer) { this.writeSpace_(); this.write_(EQUAL); this.writeSpace_(); this.visitAny(tree.initializer); } }, visitAwaitExpression: function(tree) { this.write_(AWAIT); this.writeSpace_(); this.visitAny(tree.expression); }, visitBinaryExpression: function(tree) { var left = tree.left; this.visitAny(left); var operator = tree.operator; if (left.type === POSTFIX_EXPRESSION && requiresSpaceBetween(left.operator.type, operator.type)) { this.writeRequiredSpace_(); } else { this.writeSpace_(); } this.write_(operator); var right = tree.right; if (right.type === UNARY_EXPRESSION && requiresSpaceBetween(operator.type, right.operator.type)) { this.writeRequiredSpace_(); } else { this.writeSpace_(); } this.visitAny(right); }, visitBindingElement: function(tree) { var typeAnnotation = this.currentParameterTypeAnnotation_; this.currentParameterTypeAnnotation_ = null; this.visitAny(tree.binding); this.writeTypeAnnotation_(typeAnnotation); if (tree.initializer) { this.writeSpace_(); this.write_(EQUAL); this.writeSpace_(); this.visitAny(tree.initializer); } }, visitBindingIdentifier: function(tree) { this.write_(tree.identifierToken); }, visitBlock: function(tree) { this.write_(OPEN_CURLY); this.writelnList_(tree.statements); this.write_(CLOSE_CURLY); }, visitBreakStatement: function(tree) { this.write_(BREAK); if (tree.name !== null) { this.writeSpace_(); this.write_(tree.name); } this.write_(SEMI_COLON); }, visitCallExpression: function(tree) { this.visitAny(tree.operand); this.visitAny(tree.args); }, visitCaseClause: function(tree) { this.write_(CASE); this.writeSpace_(); this.visitAny(tree.expression); this.write_(COLON); this.indentDepth_++; this.writelnList_(tree.statements); this.indentDepth_--; }, visitCatch: function(tree) { this.write_(CATCH); this.writeSpace_(); this.write_(OPEN_PAREN); this.visitAny(tree.binding); this.write_(CLOSE_PAREN); this.writeSpace_(); this.visitAny(tree.catchBody); }, visitClassShared_: function(tree) { this.writeAnnotations_(tree.annotations); this.write_(CLASS); this.writeSpace_(); this.visitAny(tree.name); if (tree.superClass !== null) { this.writeSpace_(); this.write_(EXTENDS); this.writeSpace_(); this.visitAny(tree.superClass); } this.writeSpace_(); this.write_(OPEN_CURLY); this.writelnList_(tree.elements); this.write_(CLOSE_CURLY); }, visitClassDeclaration: function(tree) { this.visitClassShared_(tree); }, visitClassExpression: function(tree) { this.visitClassShared_(tree); }, visitCommaExpression: function(tree) { this.writeList_(tree.expressions, COMMA, false); }, visitComprehensionFor: function(tree) { this.write_(FOR); this.writeSpace_(); this.write_(OPEN_PAREN); this.visitAny(tree.left); this.writeSpace_(); this.write_(OF); this.writeSpace_(); this.visitAny(tree.iterator); this.write_(CLOSE_PAREN); this.writeSpace_(); }, visitComprehensionIf: function(tree) { this.write_(IF); this.writeSpace_(); this.write_(OPEN_PAREN); this.visitAny(tree.expression); this.write_(CLOSE_PAREN); this.writeSpace_(); }, visitComputedPropertyName: function(tree) { this.write_(OPEN_SQUARE); this.visitAny(tree.expression); this.write_(CLOSE_SQUARE); }, visitConditionalExpression: function(tree) { this.visitAny(tree.condition); this.writeSpace_(); this.write_(QUESTION); this.writeSpace_(); this.visitAny(tree.left); this.writeSpace_(); this.write_(COLON); this.writeSpace_(); this.visitAny(tree.right); }, visitContinueStatement: function(tree) { this.write_(CONTINUE); if (tree.name !== null) { this.writeSpace_(); this.write_(tree.name); } this.write_(SEMI_COLON); }, visitCoverInitializedName: function(tree) { this.write_(tree.name); this.writeSpace_(); this.write_(tree.equalToken); this.writeSpace_(); this.visitAny(tree.initializer); }, visitDebuggerStatement: function(tree) { this.write_(DEBUGGER); this.write_(SEMI_COLON); }, visitDefaultClause: function(tree) { this.write_(DEFAULT); this.write_(COLON); this.indentDepth_++; this.writelnList_(tree.statements); this.indentDepth_--; }, visitDoWhileStatement: function(tree) { this.write_(DO); this.visitAnyBlockOrIndent_(tree.body); this.writeSpace_(); this.write_(WHILE); this.writeSpace_(); this.write_(OPEN_PAREN); this.visitAny(tree.condition); this.write_(CLOSE_PAREN); this.write_(SEMI_COLON); }, visitEmptyStatement: function(tree) { this.write_(SEMI_COLON); }, visitExportDeclaration: function(tree) { this.writeAnnotations_(tree.annotations); this.write_(EXPORT); this.writeSpace_(); this.visitAny(tree.declaration); }, visitExportDefault: function(tree) { this.write_(DEFAULT); this.writeSpace_(); this.visitAny(tree.expression); switch (tree.expression.type) { case CLASS_DECLARATION: case FUNCTION_DECLARATION: break; default: this.write_(SEMI_COLON); } }, visitNamedExport: function(tree) { this.visitAny(tree.specifierSet); if (tree.moduleSpecifier) { this.writeSpace_(); this.write_(FROM); this.writeSpace_(); this.visitAny(tree.moduleSpecifier); } this.write_(SEMI_COLON); }, visitExportSpecifier: function(tree) { this.write_(tree.lhs); if (tree.rhs) { this.writeSpace_(); this.write_(AS); this.writeSpace_(); this.write_(tree.rhs); } }, visitExportSpecifierSet: function(tree) { this.write_(OPEN_CURLY); this.writeList_(tree.specifiers, COMMA, false); this.write_(CLOSE_CURLY); }, visitExportStar: function(tree) { this.write_(STAR); }, visitExpressionStatement: function(tree) { this.visitAny(tree.expression); this.write_(SEMI_COLON); }, visitFinally: function(tree) { this.write_(FINALLY); this.writeSpace_(); this.visitAny(tree.block); }, visitForOfStatement: function(tree) { this.write_(FOR); this.writeSpace_(); this.write_(OPEN_PAREN); this.visitAny(tree.initializer); this.writeSpace_(); this.write_(OF); this.writeSpace_(); this.visitAny(tree.collection); this.write_(CLOSE_PAREN); this.visitAnyBlockOrIndent_(tree.body); }, visitForInStatement: function(tree) { this.write_(FOR); this.writeSpace_(); this.write_(OPEN_PAREN); this.visitAny(tree.initializer); this.writeSpace_(); this.write_(IN); this.writeSpace_(); this.visitAny(tree.collection); this.write_(CLOSE_PAREN); this.visitAnyBlockOrIndent_(tree.body); }, visitForStatement: function(tree) { this.write_(FOR); this.writeSpace_(); this.write_(OPEN_PAREN); this.visitAny(tree.initializer); this.write_(SEMI_COLON); this.writeSpace_(); this.visitAny(tree.condition); this.write_(SEMI_COLON); this.writeSpace_(); this.visitAny(tree.increment); this.write_(CLOSE_PAREN); this.visitAnyBlockOrIndent_(tree.body); }, visitFormalParameterList: function(tree) { var first = true; for (var i = 0; i < tree.parameters.length; i++) { var parameter = tree.parameters[i]; if (first) { first = false; } else { this.write_(COMMA); this.writeSpace_(); } this.visitAny(parameter); } }, visitFormalParameter: function(tree) { this.writeAnnotations_(tree.annotations, false); this.currentParameterTypeAnnotation_ = tree.typeAnnotation; this.visitAny(tree.parameter); this.currentParameterTypeAnnotation_ = null; }, visitFunctionBody: function(tree) { this.write_(OPEN_CURLY); this.writelnList_(tree.statements); this.write_(CLOSE_CURLY); }, visitFunctionDeclaration: function(tree) { this.visitFunction_(tree); }, visitFunctionExpression: function(tree) { this.visitFunction_(tree); }, visitFunction_: function(tree) { this.writeAnnotations_(tree.annotations); if (tree.isAsyncFunction()) this.write_(tree.functionKind); this.write_(FUNCTION); if (tree.isGenerator()) this.write_(tree.functionKind); if (tree.name) { this.writeSpace_(); this.visitAny(tree.name); } this.write_(OPEN_PAREN); this.visitAny(tree.parameterList); this.write_(CLOSE_PAREN); this.writeTypeAnnotation_(tree.typeAnnotation); this.writeSpace_(); this.visitAny(tree.body); }, visitGeneratorComprehension: function(tree) { this.write_(OPEN_PAREN); this.visitList(tree.comprehensionList); this.visitAny(tree.expression); this.write_(CLOSE_PAREN); }, visitGetAccessor: function(tree) { this.writeAnnotations_(tree.annotations); if (tree.isStatic) { this.write_(STATIC); this.writeSpace_(); } this.write_(GET); this.writeSpace_(); this.visitAny(tree.name); this.write_(OPEN_PAREN); this.write_(CLOSE_PAREN); this.writeSpace_(); this.writeTypeAnnotation_(tree.typeAnnotation); this.visitAny(tree.body); }, visitIdentifierExpression: function(tree) { this.write_(tree.identifierToken); }, visitIfStatement: function(tree) { this.write_(IF); this.writeSpace_(); this.write_(OPEN_PAREN); this.visitAny(tree.condition); this.write_(CLOSE_PAREN); this.visitAnyBlockOrIndent_(tree.ifClause); if (tree.elseClause) { if (tree.ifClause.type === BLOCK) this.writeSpace_(); this.write_(ELSE); if (tree.elseClause.type === IF_STATEMENT) { this.writeSpace_(); this.visitAny(tree.elseClause); } else { this.visitAnyBlockOrIndent_(tree.elseClause); } } }, visitAnyBlockOrIndent_: function(tree) { if (tree.type === BLOCK) { this.writeSpace_(); this.visitAny(tree); } else { this.visitAnyIndented_(tree); } }, visitAnyIndented_: function(tree) { var indent = arguments[1] !== (void 0) ? arguments[1] : 1; if (this.prettyPrint_) { this.indentDepth_ += indent; this.writeln_(); } this.visitAny(tree); if (this.prettyPrint_) { this.indentDepth_ -= indent; this.writeln_(); } }, visitImportDeclaration: function(tree) { this.write_(IMPORT); this.writeSpace_(); if (tree.importClause) { this.visitAny(tree.importClause); this.writeSpace_(); this.write_(FROM); this.writeSpace_(); } this.visitAny(tree.moduleSpecifier); this.write_(SEMI_COLON); }, visitImportSpecifier: function(tree) { this.write_(tree.lhs); if (tree.rhs !== null) { this.writeSpace_(); this.write_(AS); this.writeSpace_(); this.write_(tree.rhs); } }, visitImportSpecifierSet: function(tree) { if (tree.specifiers.type == STAR) { this.write_(STAR); } else { this.write_(OPEN_CURLY); this.writelnList_(tree.specifiers, COMMA); this.write_(CLOSE_CURLY); } }, visitLabelledStatement: function(tree) { this.write_(tree.name); this.write_(COLON); this.writeSpace_(); this.visitAny(tree.statement); }, visitLiteralExpression: function(tree) { this.write_(tree.literalToken); }, visitLiteralPropertyName: function(tree) { this.write_(tree.literalToken); }, visitMemberExpression: function(tree) { this.visitAny(tree.operand); if (tree.operand.type === LITERAL_EXPRESSION && tree.operand.literalToken.type === NUMBER) { if (!/\.|e|E/.test(tree.operand.literalToken.value)) this.writeRequiredSpace_(); } this.write_(PERIOD); this.write_(tree.memberName); }, visitMemberLookupExpression: function(tree) { this.visitAny(tree.operand); this.write_(OPEN_SQUARE); this.visitAny(tree.memberExpression); this.write_(CLOSE_SQUARE); }, visitSyntaxErrorTree: function(tree) { this.write_('(function() {' + ("throw SyntaxError(" + JSON.stringify(tree.message) + ");") + '})()'); }, visitModule: function(tree) { this.writelnList_(tree.scriptItemList, null); }, visitModuleSpecifier: function(tree) { this.write_(tree.token); }, visitModuleDeclaration: function(tree) { this.write_(MODULE); this.writeSpace_(); this.write_(tree.identifier); this.writeSpace_(); this.write_(FROM); this.writeSpace_(); this.visitAny(tree.expression); this.write_(SEMI_COLON); }, visitNewExpression: function(tree) { this.write_(NEW); this.writeSpace_(); this.visitAny(tree.operand); this.visitAny(tree.args); }, visitObjectLiteralExpression: function(tree) { this.write_(OPEN_CURLY); if (tree.propertyNameAndValues.length > 1) this.writeln_(); this.writelnList_(tree.propertyNameAndValues, COMMA); if (tree.propertyNameAndValues.length > 1) this.writeln_(); this.write_(CLOSE_CURLY); }, visitObjectPattern: function(tree) { this.write_(OPEN_CURLY); this.writelnList_(tree.fields, COMMA); this.write_(CLOSE_CURLY); }, visitObjectPatternField: function(tree) { this.visitAny(tree.name); if (tree.element !== null) { this.write_(COLON); this.writeSpace_(); this.visitAny(tree.element); } }, visitParenExpression: function(tree) { this.write_(OPEN_PAREN); $traceurRuntime.superCall(this, $ParseTreeWriter.prototype, "visitParenExpression", [tree]); this.write_(CLOSE_PAREN); }, visitPostfixExpression: function(tree) { this.visitAny(tree.operand); if (tree.operand.type === POSTFIX_EXPRESSION && tree.operand.operator.type === tree.operator.type) { this.writeRequiredSpace_(); } this.write_(tree.operator); }, visitPredefinedType: function(tree) { this.write_(tree.typeToken); }, visitScript: function(tree) { this.writelnList_(tree.scriptItemList, null); }, visitPropertyMethodAssignment: function(tree) { this.writeAnnotations_(tree.annotations); if (tree.isStatic) { this.write_(STATIC); this.writeSpace_(); } if (tree.isGenerator()) this.write_(STAR); if (tree.isAsyncFunction()) this.write_(ASYNC); this.visitAny(tree.name); this.write_(OPEN_PAREN); this.visitAny(tree.parameterList); this.write_(CLOSE_PAREN); this.writeSpace_(); this.writeTypeAnnotation_(tree.typeAnnotation); this.visitAny(tree.body); }, visitPropertyNameAssignment: function(tree) { this.visitAny(tree.name); this.write_(COLON); this.writeSpace_(); this.visitAny(tree.value); }, visitPropertyNameShorthand: function(tree) { this.write_(tree.name); }, visitTemplateLiteralExpression: function(tree) { if (tree.operand) { this.visitAny(tree.operand); this.writeSpace_(); } this.writeRaw_(BACK_QUOTE); this.visitList(tree.elements); this.writeRaw_(BACK_QUOTE); }, visitTemplateLiteralPortion: function(tree) { this.writeRaw_(tree.value); }, visitTemplateSubstitution: function(tree) { this.writeRaw_('$'); this.writeRaw_(OPEN_CURLY); this.visitAny(tree.expression); this.writeRaw_(CLOSE_CURLY); }, visitReturnStatement: function(tree) { this.write_(RETURN); this.writeSpace_(tree.expression); this.visitAny(tree.expression); this.write_(SEMI_COLON); }, visitRestParameter: function(tree) { this.write_(DOT_DOT_DOT); this.write_(tree.identifier.identifierToken); this.writeTypeAnnotation_(this.currentParameterTypeAnnotation_); }, visitSetAccessor: function(tree) { this.writeAnnotations_(tree.annotations); if (tree.isStatic) { this.write_(STATIC); this.writeSpace_(); } this.write_(SET); this.writeSpace_(); this.visitAny(tree.name); this.write_(OPEN_PAREN); this.visitAny(tree.parameterList); this.write_(CLOSE_PAREN); this.writeSpace_(); this.visitAny(tree.body); }, visitSpreadExpression: function(tree) { this.write_(DOT_DOT_DOT); this.visitAny(tree.expression); }, visitSpreadPatternElement: function(tree) { this.write_(DOT_DOT_DOT); this.visitAny(tree.lvalue); }, visitStateMachine: function(tree) { throw new Error('State machines cannot be converted to source'); }, visitSuperExpression: function(tree) { this.write_(SUPER); }, visitSwitchStatement: function(tree) { this.write_(SWITCH); this.writeSpace_(); this.write_(OPEN_PAREN); this.visitAny(tree.expression); this.write_(CLOSE_PAREN); this.writeSpace_(); this.write_(OPEN_CURLY); this.writelnList_(tree.caseClauses); this.write_(CLOSE_CURLY); }, visitThisExpression: function(tree) { this.write_(THIS); }, visitThrowStatement: function(tree) { this.write_(THROW); this.writeSpace_(); this.visitAny(tree.value); this.write_(SEMI_COLON); }, visitTryStatement: function(tree) { this.write_(TRY); this.writeSpace_(); this.visitAny(tree.body); if (tree.catchBlock) { this.writeSpace_(); this.visitAny(tree.catchBlock); } if (tree.finallyBlock) { this.writeSpace_(); this.visitAny(tree.finallyBlock); } }, visitTypeName: function(tree) { if (tree.moduleName) { this.visitAny(tree.moduleName); this.write_(PERIOD); } this.write_(tree.name); }, visitUnaryExpression: function(tree) { var op = tree.operator; this.write_(op); var operand = tree.operand; if (operand.type === UNARY_EXPRESSION && requiresSpaceBetween(op.type, operand.operator.type)) { this.writeRequiredSpace_(); } this.visitAny(operand); }, visitVariableDeclarationList: function(tree) { this.write_(tree.declarationType); this.writeSpace_(); this.writeList_(tree.declarations, COMMA, true, 2); }, visitVariableDeclaration: function(tree) { this.visitAny(tree.lvalue); this.writeTypeAnnotation_(tree.typeAnnotation); if (tree.initializer !== null) { this.writeSpace_(); this.write_(EQUAL); this.writeSpace_(); this.visitAny(tree.initializer); } }, visitVariableStatement: function(tree) { $traceurRuntime.superCall(this, $ParseTreeWriter.prototype, "visitVariableStatement", [tree]); this.write_(SEMI_COLON); }, visitWhileStatement: function(tree) { this.write_(WHILE); this.writeSpace_(); this.write_(OPEN_PAREN); this.visitAny(tree.condition); this.write_(CLOSE_PAREN); this.visitAnyBlockOrIndent_(tree.body); }, visitWithStatement: function(tree) { this.write_(WITH); this.writeSpace_(); this.write_(OPEN_PAREN); this.visitAny(tree.expression); this.write_(CLOSE_PAREN); this.writeSpace_(); this.visitAny(tree.body); }, visitYieldExpression: function(tree) { this.write_(YIELD); if (tree.isYieldFor) this.write_(STAR); if (tree.expression) { this.writeSpace_(); this.visitAny(tree.expression); } }, writeCurrentln_: function() { this.result_ += this.currentLine_ + NEW_LINE; }, writeln_: function() { if (this.currentLineComment_) { while (this.currentLine_.length < LINE_LENGTH) { this.currentLine_ += ' '; } this.currentLine_ += ' // ' + this.currentLineComment_; this.currentLineComment_ = null; } if (this.currentLine_) this.writeCurrentln_(); this.currentLine_ = ''; }, writelnList_: function(list, delimiter) { if (delimiter) { this.writeList_(list, delimiter, true); } else { if (list.length > 0) this.writeln_(); this.writeList_(list, null, true); if (list.length > 0) this.writeln_(); } }, writeList_: function(list, delimiter, writeNewLine) { var indent = arguments[3] !== (void 0) ? arguments[3] : 0; var first = true; for (var i = 0; i < list.length; i++) { var element = list[i]; if (first) { first = false; } else { if (delimiter !== null) { this.write_(delimiter); if (!writeNewLine) this.writeSpace_(); } if (writeNewLine) { if (i === 1) this.indentDepth_ += indent; this.writeln_(); } } this.visitAny(element); } if (writeNewLine && list.length > 1) this.indentDepth_ -= indent; }, writeRaw_: function(value) { this.currentLine_ += value; }, write_: function(value) { if (value === CLOSE_CURLY) this.indentDepth_--; if (value !== null) { if (this.prettyPrint_) { if (!this.currentLine_) { for (var i = 0, indent = this.indentDepth_; i < indent; i++) { this.currentLine_ += ' '; } } } if (this.needsSpace_(value)) this.currentLine_ += ' '; this.currentLine_ += value; } if (value === OPEN_CURLY) this.indentDepth_++; }, writeSpace_: function() { var useSpace = arguments[0] !== (void 0) ? arguments[0] : this.prettyPrint_; if (useSpace && !endsWithSpace(this.currentLine_)) this.currentLine_ += ' '; }, writeRequiredSpace_: function() { this.writeSpace_(true); }, writeTypeAnnotation_: function(typeAnnotation) { if (typeAnnotation !== null) { this.write_(COLON); this.writeSpace_(); this.visitAny(typeAnnotation); } }, writeAnnotations_: function(annotations) { var writeNewLine = arguments[1] !== (void 0) ? arguments[1] : this.prettyPrint_; if (annotations.length > 0) { this.writeList_(annotations, null, writeNewLine); if (writeNewLine) this.writeln_(); } }, needsSpace_: function(token) { var line = this.currentLine_; if (!line) return false; var lastCode = line.charCodeAt(line.length - 1); if (isWhitespace(lastCode)) return false; var firstCode = token.toString().charCodeAt(0); return isIdentifierPart(firstCode) && (isIdentifierPart(lastCode) || lastCode === 47); } }, {}, ParseTreeVisitor); function requiresSpaceBetween(first, second) { return (first === MINUS || first === MINUS_MINUS) && (second === MINUS || second === MINUS_MINUS) || (first === PLUS || first === PLUS_PLUS) && (second === PLUS || second === PLUS_PLUS); } function endsWithSpace(s) { return isWhitespace(s.charCodeAt(s.length - 1)); } return {get ParseTreeWriter() { return ParseTreeWriter; }}; }); System.register("traceur@0.0.52/src/outputgeneration/ParseTreeMapWriter", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/outputgeneration/ParseTreeMapWriter"; var ParseTreeWriter = System.get("traceur@0.0.52/src/outputgeneration/ParseTreeWriter").ParseTreeWriter; var ParseTreeMapWriter = function ParseTreeMapWriter(sourceMapGenerator) { var options = arguments[1]; $traceurRuntime.superCall(this, $ParseTreeMapWriter.prototype, "constructor", [options]); this.sourceMapGenerator_ = sourceMapGenerator; this.outputLineCount_ = 1; this.isFirstMapping_ = true; }; var $ParseTreeMapWriter = ParseTreeMapWriter; ($traceurRuntime.createClass)(ParseTreeMapWriter, { visitAny: function(tree) { if (!tree) { return; } if (tree.location) this.enterBranch(tree.location); $traceurRuntime.superCall(this, $ParseTreeMapWriter.prototype, "visitAny", [tree]); if (tree.location) this.exitBranch(tree.location); }, writeCurrentln_: function() { $traceurRuntime.superCall(this, $ParseTreeMapWriter.prototype, "writeCurrentln_", []); this.flushMappings(); this.outputLineCount_++; this.generated_ = { line: this.outputLineCount_, column: 0 }; this.flushMappings(); }, write_: function(value) { if (this.entered_) { this.generate(); $traceurRuntime.superCall(this, $ParseTreeMapWriter.prototype, "write_", [value]); this.generate(); } else { this.generate(); $traceurRuntime.superCall(this, $ParseTreeMapWriter.prototype, "write_", [value]); this.generate(); } }, generate: function() { var column = this.currentLine_.length ? this.currentLine_.length - 1 : 0; this.generated_ = { line: this.outputLineCount_, column: column }; this.flushMappings(); }, enterBranch: function(location) { this.originate(location.start); this.entered_ = true; }, exitBranch: function(location) { var position = location.end; var endOfPreviousToken = { line: position.line, column: position.column ? position.column - 1 : 0, source: { name: position.source.name, contents: position.source.contents } }; this.originate(endOfPreviousToken); this.entered_ = false; }, originate: function(position) { var line = position.line + 1; if (this.original_ && this.original_.line !== line) this.flushMappings(); this.original_ = { line: line, column: position.column || 0 }; if (position.source.name !== this.sourceName_) { this.sourceName_ = position.source.name; this.sourceMapGenerator_.setSourceContent(position.source.name, position.source.contents); } this.flushMappings(); }, flushMappings: function() { if (this.original_ && this.generated_) { this.addMapping(); this.original_ = null; this.generated_ = null; } }, isSame: function(lhs, rhs) { return lhs.line === rhs.line && lhs.column === rhs.column; }, isSameMapping: function() { if (!this.previousMapping_) return false; if (this.isSame(this.previousMapping_.generated, this.generated_) && this.isSame(this.previousMapping_.original, this.original_)) return true; ; }, addMapping: function() { if (this.isSameMapping()) return; var mapping = { generated: this.generated_, original: this.original_, source: this.sourceName_ }; this.sourceMapGenerator_.addMapping(mapping); this.previousMapping_ = mapping; } }, {}, ParseTreeWriter); return {get ParseTreeMapWriter() { return ParseTreeMapWriter; }}; }); System.register("traceur@0.0.52/src/outputgeneration/SourceMapIntegration", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/outputgeneration/SourceMapIntegration"; function makeDefine(mapping, id) { var require = function(id) { return mapping[id]; }; var exports = mapping[id] = {}; var module = null; return function(factory) { factory(require, exports, module); }; } var define, m = {}; define = makeDefine(m, './util'); if (typeof define !== 'function') { var define = require('amdefine')(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) { 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 toSetString(aStr) { return '$' + aStr; } exports.toSetString = toSetString; function fromSetString(aStr) { return aStr.substr(1); } exports.fromSetString = fromSetString; function relative(aRoot, aPath) { aRoot = aRoot.replace(/\/$/, ''); var url = urlParse(aRoot); if (aPath.charAt(0) == "/" && url && url.path == "/") { return aPath.slice(1); } return aPath.indexOf(aRoot + '/') === 0 ? aPath.substr(aRoot.length + 1) : aPath; } exports.relative = relative; 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; }); define = makeDefine(m, './array-set'); if (typeof define !== 'function') { var define = require('amdefine')(module, require); } define(function(require, exports, module) { var util = require('./util'); 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; }); define = makeDefine(m, './base64'); if (typeof define !== 'function') { var define = require('amdefine')(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); }; }); define = makeDefine(m, './base64-vlq'); if (typeof define !== 'function') { var define = require('amdefine')(module, require); } define(function(require, exports, module) { var base64 = require('./base64'); 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) { var i = 0; var strLen = aStr.length; var result = 0; var shift = 0; var continuation, digit; do { if (i >= strLen) { throw new Error("Expected more digits in base 64 VLQ value."); } digit = base64.decode(aStr.charAt(i++)); continuation = !!(digit & VLQ_CONTINUATION_BIT); digit &= VLQ_BASE_MASK; result = result + (digit << shift); shift += VLQ_BASE_SHIFT; } while (continuation); return { value: fromVLQSigned(result), rest: aStr.slice(i) }; }; }); define = makeDefine(m, './binary-search'); if (typeof define !== 'function') { var define = require('amdefine')(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 aHaystack[mid]; } else if (cmp > 0) { if (aHigh - mid > 1) { return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare); } return aHaystack[mid]; } else { if (mid - aLow > 1) { return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare); } return aLow < 0 ? null : aHaystack[aLow]; } } exports.search = function search(aNeedle, aHaystack, aCompare) { return aHaystack.length > 0 ? recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack, aCompare) : null; }; }); define = makeDefine(m, './source-map-generator'); if (typeof define !== 'function') { var define = require('amdefine')(module, require); } define(function(require, exports, module) { var base64VLQ = require('./base64-vlq'); var util = require('./util'); var ArraySet = require('./array-set').ArraySet; function SourceMapGenerator(aArgs) { if (!aArgs) { aArgs = {}; } this._file = util.getArg(aArgs, 'file', null); this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null); this._sources = new ArraySet(); this._names = new ArraySet(); this._mappings = []; 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) { newMapping.source = mapping.source; if (sourceRoot) { newMapping.source = util.relative(sourceRoot, newMapping.source); } newMapping.original = { line: mapping.originalLine, column: mapping.originalColumn }; if (mapping.name) { newMapping.name = mapping.name; } } generator.addMapping(newMapping); }); aSourceMapConsumer.sources.forEach(function(sourceFile) { var content = aSourceMapConsumer.sourceContentFor(sourceFile); if (content) { generator.setSourceContent(sourceFile, content); } }); return generator; }; SourceMapGenerator.prototype.addMapping = function SourceMapGenerator_addMapping(aArgs) { var generated = util.getArg(aArgs, 'generated'); var original = util.getArg(aArgs, 'original', null); var source = util.getArg(aArgs, 'source', null); var name = util.getArg(aArgs, 'name', null); this._validateMapping(generated, original, source, name); if (source && !this._sources.has(source)) { this._sources.add(source); } if (name && !this._names.has(name)) { this._names.add(name); } this._mappings.push({ 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) { source = util.relative(this._sourceRoot, source); } if (aSourceContent !== null) { if (!this._sourcesContents) { this._sourcesContents = {}; } this._sourcesContents[util.toSetString(source)] = aSourceContent; } else { 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) { if (!aSourceFile) { if (!aSourceMapConsumer.file) { throw new Error('SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' + 'or the source map\'s "file" property. Both were omitted.'); } aSourceFile = aSourceMapConsumer.file; } var sourceRoot = this._sourceRoot; if (sourceRoot) { aSourceFile = util.relative(sourceRoot, aSourceFile); } var newSources = new ArraySet(); var newNames = new ArraySet(); this._mappings.forEach(function(mapping) { if (mapping.source === aSourceFile && mapping.originalLine) { var original = aSourceMapConsumer.originalPositionFor({ line: mapping.originalLine, column: mapping.originalColumn }); if (original.source !== null) { mapping.source = original.source; if (aSourceMapPath) { mapping.source = util.join(aSourceMapPath, mapping.source); } if (sourceRoot) { mapping.source = util.relative(sourceRoot, mapping.source); } mapping.originalLine = original.line; mapping.originalColumn = original.column; if (original.name !== null && mapping.name !== null) { mapping.name = original.name; } } } var source = mapping.source; if (source && !newSources.has(source)) { newSources.add(source); } var name = mapping.name; if (name && !newNames.has(name)) { newNames.add(name); } }, this); this._sources = newSources; this._names = newNames; aSourceMapConsumer.sources.forEach(function(sourceFile) { var content = aSourceMapConsumer.sourceContentFor(sourceFile); if (content) { if (aSourceMapPath) { sourceFile = util.join(aSourceMapPath, sourceFile); } if (sourceRoot) { 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; this._mappings.sort(util.compareByGeneratedPositions); for (var i = 0, len = this._mappings.length; i < len; i++) { mapping = this._mappings[i]; if (mapping.generatedLine !== previousGeneratedLine) { previousGeneratedColumn = 0; while (mapping.generatedLine !== previousGeneratedLine) { result += ';'; previousGeneratedLine++; } } else { if (i > 0) { if (!util.compareByGeneratedPositions(mapping, this._mappings[i - 1])) { continue; } result += ','; } } result += base64VLQ.encode(mapping.generatedColumn - previousGeneratedColumn); previousGeneratedColumn = mapping.generatedColumn; if (mapping.source) { 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) { 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) { 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, file: this._file, sources: this._sources.toArray(), names: this._names.toArray(), mappings: this._serializeMappings() }; if (this._sourceRoot) { map.sourceRoot = this._sourceRoot; } if (this._sourcesContents) { map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot); } return map; }; SourceMapGenerator.prototype.toString = function SourceMapGenerator_toString() { return JSON.stringify(this); }; exports.SourceMapGenerator = SourceMapGenerator; }); define = makeDefine(m, './source-map-consumer'); if (typeof define !== 'function') { var define = require('amdefine')(module, require); } define(function(require, exports, module) { var util = require('./util'); var binarySearch = require('./binary-search'); var ArraySet = require('./array-set').ArraySet; var base64VLQ = require('./base64-vlq'); function SourceMapConsumer(aSourceMap) { var sourceMap = aSourceMap; if (typeof aSourceMap === 'string') { sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, '')); } var version = util.getArg(sourceMap, 'version'); var sources = util.getArg(sourceMap, 'sources'); var names = util.getArg(sourceMap, 'names', []); var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null); var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null); var mappings = util.getArg(sourceMap, 'mappings'); var file = util.getArg(sourceMap, 'file', null); if (version != this._version) { throw new Error('Unsupported version: ' + version); } this._names = ArraySet.fromArray(names, true); this._sources = ArraySet.fromArray(sources, true); this.sourceRoot = sourceRoot; this.sourcesContent = sourcesContent; this._mappings = mappings; this.file = file; } SourceMapConsumer.fromSourceMap = function SourceMapConsumer_fromSourceMap(aSourceMap) { var smc = Object.create(SourceMapConsumer.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.slice().sort(util.compareByGeneratedPositions); smc.__originalMappings = aSourceMap._mappings.slice().sort(util.compareByOriginalPositions); return smc; }; SourceMapConsumer.prototype._version = 3; Object.defineProperty(SourceMapConsumer.prototype, 'sources', {get: function() { return this._sources.toArray().map(function(s) { return this.sourceRoot ? util.join(this.sourceRoot, s) : s; }, this); }}); 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._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) { var generatedLine = 1; var previousGeneratedColumn = 0; var previousOriginalLine = 0; var previousOriginalColumn = 0; var previousSource = 0; var previousName = 0; var mappingSeparator = /^[,;]/; var str = aStr; var mapping; var temp; while (str.length > 0) { if (str.charAt(0) === ';') { generatedLine++; str = str.slice(1); previousGeneratedColumn = 0; } else if (str.charAt(0) === ',') { str = str.slice(1); } else { mapping = {}; mapping.generatedLine = generatedLine; temp = base64VLQ.decode(str); mapping.generatedColumn = previousGeneratedColumn + temp.value; previousGeneratedColumn = mapping.generatedColumn; str = temp.rest; if (str.length > 0 && !mappingSeparator.test(str.charAt(0))) { temp = base64VLQ.decode(str); mapping.source = this._sources.at(previousSource + temp.value); previousSource += temp.value; str = temp.rest; if (str.length === 0 || mappingSeparator.test(str.charAt(0))) { throw new Error('Found a source, but no line and column'); } temp = base64VLQ.decode(str); mapping.originalLine = previousOriginalLine + temp.value; previousOriginalLine = mapping.originalLine; mapping.originalLine += 1; str = temp.rest; if (str.length === 0 || mappingSeparator.test(str.charAt(0))) { throw new Error('Found a source and line, but no column'); } temp = base64VLQ.decode(str); mapping.originalColumn = previousOriginalColumn + temp.value; previousOriginalColumn = mapping.originalColumn; str = temp.rest; if (str.length > 0 && !mappingSeparator.test(str.charAt(0))) { temp = base64VLQ.decode(str); mapping.name = this._names.at(previousName + temp.value); previousName += temp.value; str = temp.rest; } } this.__generatedMappings.push(mapping); if (typeof mapping.originalLine === 'number') { this.__originalMappings.push(mapping); } } } this.__generatedMappings.sort(util.compareByGeneratedPositions); this.__originalMappings.sort(util.compareByOriginalPositions); }; SourceMapConsumer.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); }; SourceMapConsumer.prototype.originalPositionFor = function SourceMapConsumer_originalPositionFor(aArgs) { var needle = { generatedLine: util.getArg(aArgs, 'line'), generatedColumn: util.getArg(aArgs, 'column') }; var mapping = this._findMapping(needle, this._generatedMappings, "generatedLine", "generatedColumn", util.compareByGeneratedPositions); if (mapping && mapping.generatedLine === needle.generatedLine) { var source = util.getArg(mapping, 'source', null); if (source && this.sourceRoot) { source = util.join(this.sourceRoot, source); } return { source: source, line: util.getArg(mapping, 'originalLine', null), column: util.getArg(mapping, 'originalColumn', null), name: util.getArg(mapping, 'name', null) }; } return { source: null, line: null, column: null, name: null }; }; SourceMapConsumer.prototype.sourceContentFor = function SourceMapConsumer_sourceContentFor(aSource) { if (!this.sourcesContent) { return null; } if (this.sourceRoot) { aSource = util.relative(this.sourceRoot, aSource); } if (this._sources.has(aSource)) { return this.sourcesContent[this._sources.indexOf(aSource)]; } var url; if (this.sourceRoot && (url = util.urlParse(this.sourceRoot))) { var fileUriAbsPath = aSource.replace(/^file:\/\//, ""); if (url.scheme == "file" && this._sources.has(fileUriAbsPath)) { return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]; } if ((!url.path || url.path == "/") && this._sources.has("/" + aSource)) { return this.sourcesContent[this._sources.indexOf("/" + aSource)]; } } throw new Error('"' + aSource + '" is not in the SourceMap.'); }; SourceMapConsumer.prototype.generatedPositionFor = function SourceMapConsumer_generatedPositionFor(aArgs) { var needle = { source: util.getArg(aArgs, 'source'), originalLine: util.getArg(aArgs, 'line'), originalColumn: util.getArg(aArgs, 'column') }; if (this.sourceRoot) { needle.source = util.relative(this.sourceRoot, needle.source); } var mapping = this._findMapping(needle, this._originalMappings, "originalLine", "originalColumn", util.compareByOriginalPositions); if (mapping) { return { line: util.getArg(mapping, 'generatedLine', null), column: util.getArg(mapping, 'generatedColumn', null) }; } return { line: null, column: null }; }; SourceMapConsumer.GENERATED_ORDER = 1; SourceMapConsumer.ORIGINAL_ORDER = 2; SourceMapConsumer.prototype.eachMapping = function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) { var context = aContext || null; var order = aOrder || SourceMapConsumer.GENERATED_ORDER; var mappings; switch (order) { case SourceMapConsumer.GENERATED_ORDER: mappings = this._generatedMappings; break; case SourceMapConsumer.ORIGINAL_ORDER: mappings = this._originalMappings; break; default: throw new Error("Unknown order of iteration."); } var sourceRoot = this.sourceRoot; mappings.map(function(mapping) { var source = mapping.source; if (source && sourceRoot) { source = util.join(sourceRoot, source); } return { source: source, generatedLine: mapping.generatedLine, generatedColumn: mapping.generatedColumn, originalLine: mapping.originalLine, originalColumn: mapping.originalColumn, name: mapping.name }; }).forEach(aCallback, context); }; exports.SourceMapConsumer = SourceMapConsumer; }); define = makeDefine(m, './source-node'); if (typeof define !== 'function') { var define = require('amdefine')(module, require); } define(function(require, exports, module) { var SourceMapGenerator = require('./source-map-generator').SourceMapGenerator; var util = require('./util'); var REGEX_NEWLINE = /(\r?\n)/g; var REGEX_CHARACTER = /\r\n|[\s\S]/g; function SourceNode(aLine, aColumn, aSource, aChunks, aName) { this.children = []; this.sourceContents = {}; this.line = aLine === undefined ? null : aLine; this.column = aColumn === undefined ? null : aColumn; this.source = aSource === undefined ? null : aSource; this.name = aName === undefined ? null : aName; if (aChunks != null) this.add(aChunks); } SourceNode.fromStringWithSourceMap = function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer) { 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) { node.setSourceContent(sourceFile, content); } }); return node; function addMappingWithCode(mapping, code) { if (mapping === null || mapping.source === undefined) { node.add(code); } else { node.add(new SourceNode(mapping.originalLine, mapping.originalColumn, mapping.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 instanceof SourceNode || typeof aChunk === "string") { if (aChunk) { this.children.push(aChunk); } } else { throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk); } return this; }; SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) { if (Array.isArray(aChunk)) { for (var i = aChunk.length - 1; i >= 0; i--) { this.prepend(aChunk[i]); } } else if (aChunk instanceof SourceNode || typeof aChunk === "string") { this.children.unshift(aChunk); } else { throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk); } return this; }; 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 instanceof SourceNode) { 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 instanceof SourceNode) { lastChild.replaceRight(aPattern, aReplacement); } else if (typeof lastChild === 'string') { this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement); } else { this.children.push(''.replace(aPattern, aReplacement)); } return this; }; 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] instanceof SourceNode) { 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; } chunk.match(REGEX_CHARACTER).forEach(function(ch, idx, array) { if (REGEX_NEWLINE.test(ch)) { generated.line++; generated.column = 0; if (idx + 1 === array.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 += ch.length; } }); }); this.walkSourceContents(function(sourceFile, sourceContent) { map.setSourceContent(sourceFile, sourceContent); }); return { code: generated.code, map: map }; }; exports.SourceNode = SourceNode; }); var SourceMapGenerator = m['./source-map-generator'].SourceMapGenerator; var SourceMapConsumer = m['./source-map-consumer'].SourceMapConsumer; var SourceNode = m['./source-node'].SourceNode; return { get SourceMapGenerator() { return SourceMapGenerator; }, get SourceMapConsumer() { return SourceMapConsumer; }, get SourceNode() { return SourceNode; } }; }); System.register("traceur@0.0.52/src/outputgeneration/toSource", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/outputgeneration/toSource"; var ParseTreeMapWriter = System.get("traceur@0.0.52/src/outputgeneration/ParseTreeMapWriter").ParseTreeMapWriter; var ParseTreeWriter = System.get("traceur@0.0.52/src/outputgeneration/ParseTreeWriter").ParseTreeWriter; var SourceMapGenerator = System.get("traceur@0.0.52/src/outputgeneration/SourceMapIntegration").SourceMapGenerator; function toSource(tree) { var options = arguments[1]; var sourceMapGenerator = options && options.sourceMapGenerator; if (!sourceMapGenerator && options && options.sourceMaps) { sourceMapGenerator = new SourceMapGenerator({ file: options.filename, sourceRoot: null }); } var writer; if (sourceMapGenerator) writer = new ParseTreeMapWriter(sourceMapGenerator, options); else writer = new ParseTreeWriter(options); writer.visitAny(tree); return [writer.toString(), sourceMapGenerator && sourceMapGenerator.toString()]; } return {get toSource() { return toSource; }}; }); System.register("traceur@0.0.52/src/outputgeneration/TreeWriter", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/outputgeneration/TreeWriter"; var toSource = System.get("traceur@0.0.52/src/outputgeneration/toSource").toSource; function write(tree) { var options = arguments[1]; var $__613 = $traceurRuntime.assertObject(toSource(tree, options)), result = $__613[0], sourceMap = $__613[1]; if (sourceMap) options.generatedSourceMap = sourceMap; return result; } var TreeWriter = function TreeWriter() {}; ($traceurRuntime.createClass)(TreeWriter, {}, {}); TreeWriter.write = write; return { get write() { return write; }, get TreeWriter() { return TreeWriter; } }; }); System.register("traceur@0.0.52/src/syntax/ParseTreeValidator", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/syntax/ParseTreeValidator"; var NewExpression = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees").NewExpression; var ParseTreeVisitor = System.get("traceur@0.0.52/src/syntax/ParseTreeVisitor").ParseTreeVisitor; var TreeWriter = System.get("traceur@0.0.52/src/outputgeneration/TreeWriter").TreeWriter; var $__617 = System.get("traceur@0.0.52/src/syntax/TokenType"), AMPERSAND = $__617.AMPERSAND, AMPERSAND_EQUAL = $__617.AMPERSAND_EQUAL, AND = $__617.AND, BAR = $__617.BAR, BAR_EQUAL = $__617.BAR_EQUAL, CARET = $__617.CARET, CARET_EQUAL = $__617.CARET_EQUAL, CLOSE_ANGLE = $__617.CLOSE_ANGLE, EQUAL = $__617.EQUAL, EQUAL_EQUAL = $__617.EQUAL_EQUAL, EQUAL_EQUAL_EQUAL = $__617.EQUAL_EQUAL_EQUAL, GREATER_EQUAL = $__617.GREATER_EQUAL, IDENTIFIER = $__617.IDENTIFIER, IN = $__617.IN, INSTANCEOF = $__617.INSTANCEOF, LEFT_SHIFT = $__617.LEFT_SHIFT, LEFT_SHIFT_EQUAL = $__617.LEFT_SHIFT_EQUAL, LESS_EQUAL = $__617.LESS_EQUAL, MINUS = $__617.MINUS, MINUS_EQUAL = $__617.MINUS_EQUAL, NOT_EQUAL = $__617.NOT_EQUAL, NOT_EQUAL_EQUAL = $__617.NOT_EQUAL_EQUAL, NUMBER = $__617.NUMBER, OPEN_ANGLE = $__617.OPEN_ANGLE, OR = $__617.OR, PERCENT = $__617.PERCENT, PERCENT_EQUAL = $__617.PERCENT_EQUAL, PLUS = $__617.PLUS, PLUS_EQUAL = $__617.PLUS_EQUAL, RIGHT_SHIFT = $__617.RIGHT_SHIFT, RIGHT_SHIFT_EQUAL = $__617.RIGHT_SHIFT_EQUAL, SLASH = $__617.SLASH, SLASH_EQUAL = $__617.SLASH_EQUAL, STAR = $__617.STAR, STAR_EQUAL = $__617.STAR_EQUAL, STRING = $__617.STRING, UNSIGNED_RIGHT_SHIFT = $__617.UNSIGNED_RIGHT_SHIFT, UNSIGNED_RIGHT_SHIFT_EQUAL = $__617.UNSIGNED_RIGHT_SHIFT_EQUAL; var $__618 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), ARRAY_PATTERN = $__618.ARRAY_PATTERN, ASSIGNMENT_ELEMENT = $__618.ASSIGNMENT_ELEMENT, BINDING_ELEMENT = $__618.BINDING_ELEMENT, BINDING_IDENTIFIER = $__618.BINDING_IDENTIFIER, BLOCK = $__618.BLOCK, CASE_CLAUSE = $__618.CASE_CLAUSE, CATCH = $__618.CATCH, CLASS_DECLARATION = $__618.CLASS_DECLARATION, COMPUTED_PROPERTY_NAME = $__618.COMPUTED_PROPERTY_NAME, DEFAULT_CLAUSE = $__618.DEFAULT_CLAUSE, EXPORT_DEFAULT = $__618.EXPORT_DEFAULT, EXPORT_SPECIFIER = $__618.EXPORT_SPECIFIER, EXPORT_SPECIFIER_SET = $__618.EXPORT_SPECIFIER_SET, EXPORT_STAR = $__618.EXPORT_STAR, FINALLY = $__618.FINALLY, FORMAL_PARAMETER = $__618.FORMAL_PARAMETER, FORMAL_PARAMETER_LIST = $__618.FORMAL_PARAMETER_LIST, FUNCTION_BODY = $__618.FUNCTION_BODY, FUNCTION_DECLARATION = $__618.FUNCTION_DECLARATION, GET_ACCESSOR = $__618.GET_ACCESSOR, IDENTIFIER_EXPRESSION = $__618.IDENTIFIER_EXPRESSION, LITERAL_PROPERTY_NAME = $__618.LITERAL_PROPERTY_NAME, MODULE_DECLARATION = $__618.MODULE_DECLARATION, MODULE_SPECIFIER = $__618.MODULE_SPECIFIER, NAMED_EXPORT = $__618.NAMED_EXPORT, OBJECT_PATTERN = $__618.OBJECT_PATTERN, OBJECT_PATTERN_FIELD = $__618.OBJECT_PATTERN_FIELD, PROPERTY_METHOD_ASSIGNMENT = $__618.PROPERTY_METHOD_ASSIGNMENT, PROPERTY_NAME_ASSIGNMENT = $__618.PROPERTY_NAME_ASSIGNMENT, PROPERTY_NAME_SHORTHAND = $__618.PROPERTY_NAME_SHORTHAND, REST_PARAMETER = $__618.REST_PARAMETER, SET_ACCESSOR = $__618.SET_ACCESSOR, TEMPLATE_LITERAL_PORTION = $__618.TEMPLATE_LITERAL_PORTION, TEMPLATE_SUBSTITUTION = $__618.TEMPLATE_SUBSTITUTION, VARIABLE_DECLARATION_LIST = $__618.VARIABLE_DECLARATION_LIST, VARIABLE_STATEMENT = $__618.VARIABLE_STATEMENT; var assert = System.get("traceur@0.0.52/src/util/assert").assert; var ValidationError = function ValidationError(tree, message) { this.tree = tree; this.message = message; }; ($traceurRuntime.createClass)(ValidationError, {}, {}, Error); var ParseTreeValidator = function ParseTreeValidator() { $traceurRuntime.defaultSuperCall(this, $ParseTreeValidator.prototype, arguments); }; var $ParseTreeValidator = ParseTreeValidator; ($traceurRuntime.createClass)(ParseTreeValidator, { fail_: function(tree, message) { throw new ValidationError(tree, message); }, check_: function(condition, tree, message) { if (!condition) { this.fail_(tree, message); } }, checkVisit_: function(condition, tree, message) { this.check_(condition, tree, message); this.visitAny(tree); }, checkType_: function(type, tree, message) { this.checkVisit_(tree.type === type, tree, message); }, visitArgumentList: function(tree) { for (var i = 0; i < tree.args.length; i++) { var argument = tree.args[i]; this.checkVisit_(argument.isAssignmentOrSpread(), argument, 'assignment or spread expected'); } }, visitArrayLiteralExpression: function(tree) { for (var i = 0; i < tree.elements.length; i++) { var element = tree.elements[i]; this.checkVisit_(element === null || element.isAssignmentOrSpread(), element, 'assignment or spread expected'); } }, visitArrayPattern: function(tree) { for (var i = 0; i < tree.elements.length; i++) { var element = tree.elements[i]; this.checkVisit_(element === null || element.type === BINDING_ELEMENT || element.type == ASSIGNMENT_ELEMENT || element.isLeftHandSideExpression() || element.isPattern() || element.isSpreadPatternElement(), element, 'null, sub pattern, left hand side expression or spread expected'); if (element && element.isSpreadPatternElement()) { this.check_(i === (tree.elements.length - 1), element, 'spread in array patterns must be the last element'); } } }, visitBinaryExpression: function(tree) { switch (tree.operator.type) { case EQUAL: case STAR_EQUAL: case SLASH_EQUAL: case PERCENT_EQUAL: case PLUS_EQUAL: case MINUS_EQUAL: case LEFT_SHIFT_EQUAL: case RIGHT_SHIFT_EQUAL: case UNSIGNED_RIGHT_SHIFT_EQUAL: case AMPERSAND_EQUAL: case CARET_EQUAL: case BAR_EQUAL: this.check_(tree.left.isLeftHandSideExpression() || tree.left.isPattern(), tree.left, 'left hand side expression or pattern expected'); this.check_(tree.right.isAssignmentExpression(), tree.right, 'assignment expression expected'); break; case AND: case OR: case BAR: case CARET: case AMPERSAND: case EQUAL_EQUAL: case NOT_EQUAL: case EQUAL_EQUAL_EQUAL: case NOT_EQUAL_EQUAL: case OPEN_ANGLE: case CLOSE_ANGLE: case GREATER_EQUAL: case LESS_EQUAL: case INSTANCEOF: case IN: case LEFT_SHIFT: case RIGHT_SHIFT: case UNSIGNED_RIGHT_SHIFT: case PLUS: case MINUS: case STAR: case SLASH: case PERCENT: this.check_(tree.left.isAssignmentExpression(), tree.left, 'assignment expression expected'); this.check_(tree.right.isAssignmentExpression(), tree.right, 'assignment expression expected'); break; default: this.fail_(tree, 'unexpected binary operator'); } this.visitAny(tree.left); this.visitAny(tree.right); }, visitBindingElement: function(tree) { var binding = tree.binding; this.checkVisit_(binding.type == BINDING_IDENTIFIER || binding.type == OBJECT_PATTERN || binding.type == ARRAY_PATTERN, binding, 'expected valid binding element'); this.visitAny(tree.initializer); }, visitAssignmentElement: function(tree) { var assignment = tree.assignment; this.checkVisit_(assignment.type == OBJECT_PATTERN || assignment.type == ARRAY_PATTERN || assignment.isLeftHandSideExpression(), assignment, 'expected valid assignment element'); this.visitAny(tree.initializer); }, visitBlock: function(tree) { for (var i = 0; i < tree.statements.length; i++) { var statement = tree.statements[i]; this.checkVisit_(statement.isStatementListItem(), statement, 'statement or function declaration expected'); } }, visitCallExpression: function(tree) { this.check_(tree.operand.isMemberExpression(), tree.operand, 'member expression expected'); if (tree.operand instanceof NewExpression) { this.check_(tree.operand.args !== null, tree.operand, 'new args expected'); } this.visitAny(tree.operand); this.visitAny(tree.args); }, visitCaseClause: function(tree) { this.checkVisit_(tree.expression.isExpression(), tree.expression, 'expression expected'); for (var i = 0; i < tree.statements.length; i++) { var statement = tree.statements[i]; this.checkVisit_(statement.isStatement(), statement, 'statement expected'); } }, visitCatch: function(tree) { this.checkVisit_(tree.binding.isPattern() || tree.binding.type == BINDING_IDENTIFIER, tree.binding, 'binding identifier expected'); this.checkVisit_(tree.catchBody.type === BLOCK, tree.catchBody, 'block expected'); }, visitClassDeclaration: function(tree) { for (var i = 0; i < tree.elements.length; i++) { var element = tree.elements[i]; switch (element.type) { case GET_ACCESSOR: case SET_ACCESSOR: case PROPERTY_METHOD_ASSIGNMENT: break; default: this.fail_(element, 'class element expected'); } this.visitAny(element); } }, visitCommaExpression: function(tree) { for (var i = 0; i < tree.expressions.length; i++) { var expression = tree.expressions[i]; this.checkVisit_(expression.isAssignmentExpression(), expression, 'expression expected'); } }, visitConditionalExpression: function(tree) { this.checkVisit_(tree.condition.isAssignmentExpression(), tree.condition, 'expression expected'); this.checkVisit_(tree.left.isAssignmentExpression(), tree.left, 'expression expected'); this.checkVisit_(tree.right.isAssignmentExpression(), tree.right, 'expression expected'); }, visitCoverFormals: function(tree) { this.fail_(tree, 'CoverFormals should have been removed'); }, visitCoverInitializedName: function(tree) { this.fail_(tree, 'CoverInitializedName should have been removed'); }, visitDefaultClause: function(tree) { for (var i = 0; i < tree.statements.length; i++) { var statement = tree.statements[i]; this.checkVisit_(statement.isStatement(), statement, 'statement expected'); } }, visitDoWhileStatement: function(tree) { this.checkVisit_(tree.body.isStatement(), tree.body, 'statement expected'); this.checkVisit_(tree.condition.isExpression(), tree.condition, 'expression expected'); }, visitExportDeclaration: function(tree) { var declType = tree.declaration.type; this.checkVisit_(declType == VARIABLE_STATEMENT || declType == FUNCTION_DECLARATION || declType == MODULE_DECLARATION || declType == CLASS_DECLARATION || declType == NAMED_EXPORT || declType == EXPORT_DEFAULT, tree.declaration, 'expected valid export tree'); }, visitNamedExport: function(tree) { if (tree.moduleSpecifier) { this.checkVisit_(tree.moduleSpecifier.type == MODULE_SPECIFIER, tree.moduleSpecifier, 'module expression expected'); } var specifierType = tree.specifierSet.type; this.checkVisit_(specifierType == EXPORT_SPECIFIER_SET || specifierType == EXPORT_STAR, tree.specifierSet, 'specifier set or identifier expected'); }, visitExportSpecifierSet: function(tree) { this.check_(tree.specifiers.length > 0, tree, 'expected at least one identifier'); for (var i = 0; i < tree.specifiers.length; i++) { var specifier = tree.specifiers[i]; this.checkVisit_(specifier.type == EXPORT_SPECIFIER || specifier.type == IDENTIFIER_EXPRESSION, specifier, 'expected valid export specifier'); } }, visitExpressionStatement: function(tree) { this.checkVisit_(tree.expression.isExpression(), tree.expression, 'expression expected'); }, visitFinally: function(tree) { this.checkVisit_(tree.block.type === BLOCK, tree.block, 'block expected'); }, visitForOfStatement: function(tree) { this.checkVisit_(tree.initializer.isPattern() || tree.initializer.type === IDENTIFIER_EXPRESSION || tree.initializer.type === VARIABLE_DECLARATION_LIST && tree.initializer.declarations.length === 1, tree.initializer, 'for-each statement may not have more than one variable declaration'); this.checkVisit_(tree.collection.isExpression(), tree.collection, 'expression expected'); this.checkVisit_(tree.body.isStatement(), tree.body, 'statement expected'); }, visitForInStatement: function(tree) { if (tree.initializer.type === VARIABLE_DECLARATION_LIST) { this.checkVisit_(tree.initializer.declarations.length <= 1, tree.initializer, 'for-in statement may not have more than one variable declaration'); } else { this.checkVisit_(tree.initializer.isPattern() || tree.initializer.isExpression(), tree.initializer, 'variable declaration, expression or ' + 'pattern expected'); } this.checkVisit_(tree.collection.isExpression(), tree.collection, 'expression expected'); this.checkVisit_(tree.body.isStatement(), tree.body, 'statement expected'); }, visitFormalParameterList: function(tree) { for (var i = 0; i < tree.parameters.length; i++) { var parameter = tree.parameters[i]; assert(parameter.type === FORMAL_PARAMETER); parameter = parameter.parameter; switch (parameter.type) { case BINDING_ELEMENT: break; case REST_PARAMETER: this.checkVisit_(i === tree.parameters.length - 1, parameter, 'rest parameters must be the last parameter in a parameter list'); this.checkType_(BINDING_IDENTIFIER, parameter.identifier, 'binding identifier expected'); break; default: this.fail_(parameter, 'parameters must be identifiers or rest' + (" parameters. Found: " + parameter.type)); break; } this.visitAny(parameter); } }, visitForStatement: function(tree) { if (tree.initializer !== null) { this.checkVisit_(tree.initializer.isExpression() || tree.initializer.type === VARIABLE_DECLARATION_LIST, tree.initializer, 'variable declaration list or expression expected'); } if (tree.condition !== null) { this.checkVisit_(tree.condition.isExpression(), tree.condition, 'expression expected'); } if (tree.increment !== null) { this.checkVisit_(tree.increment.isExpression(), tree.increment, 'expression expected'); } this.checkVisit_(tree.body.isStatement(), tree.body, 'statement expected'); }, visitFunctionBody: function(tree) { for (var i = 0; i < tree.statements.length; i++) { var statement = tree.statements[i]; this.checkVisit_(statement.isStatementListItem(), statement, 'statement expected'); } }, visitFunctionDeclaration: function(tree) { this.checkType_(BINDING_IDENTIFIER, tree.name, 'binding identifier expected'); this.visitFunction_(tree); }, visitFunctionExpression: function(tree) { if (tree.name !== null) { this.checkType_(BINDING_IDENTIFIER, tree.name, 'binding identifier expected'); } this.visitFunction_(tree); }, visitFunction_: function(tree) { this.checkType_(FORMAL_PARAMETER_LIST, tree.parameterList, 'formal parameters expected'); this.checkType_(FUNCTION_BODY, tree.body, 'function body expected'); }, visitGetAccessor: function(tree) { this.checkPropertyName_(tree.name); this.checkType_(FUNCTION_BODY, tree.body, 'function body expected'); }, visitIfStatement: function(tree) { this.checkVisit_(tree.condition.isExpression(), tree.condition, 'expression expected'); this.checkVisit_(tree.ifClause.isStatement(), tree.ifClause, 'statement expected'); if (tree.elseClause !== null) { this.checkVisit_(tree.elseClause.isStatement(), tree.elseClause, 'statement expected'); } }, visitLabelledStatement: function(tree) { this.checkVisit_(tree.statement.isStatement(), tree.statement, 'statement expected'); }, visitMemberExpression: function(tree) { this.check_(tree.operand.isMemberExpression(), tree.operand, 'member expression expected'); if (tree.operand instanceof NewExpression) { this.check_(tree.operand.args !== null, tree.operand, 'new args expected'); } this.visitAny(tree.operand); }, visitMemberLookupExpression: function(tree) { this.check_(tree.operand.isMemberExpression(), tree.operand, 'member expression expected'); if (tree.operand instanceof NewExpression) { this.check_(tree.operand.args !== null, tree.operand, 'new args expected'); } this.visitAny(tree.operand); }, visitSyntaxErrorTree: function(tree) { this.fail_(tree, ("parse tree contains SyntaxError: " + tree.message)); }, visitModuleSpecifier: function(tree) { this.check_(tree.token.type == STRING || tree.moduleName, 'string or identifier expected'); }, visitModuleDeclaration: function(tree) { this.checkType_(MODULE_SPECIFIER, tree.expression, 'module expression expected'); }, visitNewExpression: function(tree) { this.checkVisit_(tree.operand.isMemberExpression(), tree.operand, 'member expression expected'); this.visitAny(tree.args); }, visitObjectLiteralExpression: function(tree) { for (var i = 0; i < tree.propertyNameAndValues.length; i++) { var propertyNameAndValue = tree.propertyNameAndValues[i]; switch (propertyNameAndValue.type) { case GET_ACCESSOR: case SET_ACCESSOR: case PROPERTY_METHOD_ASSIGNMENT: this.check_(!propertyNameAndValue.isStatic, propertyNameAndValue, 'static is not allowed in object literal expression'); case PROPERTY_NAME_ASSIGNMENT: case PROPERTY_NAME_SHORTHAND: break; default: this.fail_(propertyNameAndValue, 'accessor, property name ' + 'assignment or property method assigment expected'); } this.visitAny(propertyNameAndValue); } }, visitObjectPattern: function(tree) { for (var i = 0; i < tree.fields.length; i++) { var field = tree.fields[i]; this.checkVisit_(field.type === OBJECT_PATTERN_FIELD || field.type === ASSIGNMENT_ELEMENT || field.type === BINDING_ELEMENT, field, 'object pattern field expected'); } }, visitObjectPatternField: function(tree) { this.checkPropertyName_(tree.name); this.checkVisit_(tree.element.type === ASSIGNMENT_ELEMENT || tree.element.type === BINDING_ELEMENT || tree.element.isPattern() || tree.element.isLeftHandSideExpression(), tree.element, 'binding element expected'); }, visitParenExpression: function(tree) { if (tree.expression.isPattern()) { this.visitAny(tree.expression); } else { this.checkVisit_(tree.expression.isExpression(), tree.expression, 'expression expected'); } }, visitPostfixExpression: function(tree) { this.checkVisit_(tree.operand.isAssignmentExpression(), tree.operand, 'assignment expression expected'); }, visitPredefinedType: function(tree) {}, visitScript: function(tree) { for (var i = 0; i < tree.scriptItemList.length; i++) { var scriptItemList = tree.scriptItemList[i]; this.checkVisit_(scriptItemList.isScriptElement(), scriptItemList, 'global script item expected'); } }, checkPropertyName_: function(tree) { this.checkVisit_(tree.type === LITERAL_PROPERTY_NAME || tree.type === COMPUTED_PROPERTY_NAME, tree, 'property name expected'); }, visitPropertyNameAssignment: function(tree) { this.checkPropertyName_(tree.name); this.checkVisit_(tree.value.isAssignmentExpression(), tree.value, 'assignment expression expected'); }, visitPropertyNameShorthand: function(tree) { this.check_(tree.name.type === IDENTIFIER, tree, 'identifier token expected'); }, visitLiteralPropertyName: function(tree) { var type = tree.literalToken.type; this.check_(tree.literalToken.isKeyword() || type === IDENTIFIER || type === NUMBER || type === STRING, tree, 'Unexpected token in literal property name'); }, visitTemplateLiteralExpression: function(tree) { if (tree.operand) { this.checkVisit_(tree.operand.isMemberExpression(), tree.operand, 'member or call expression expected'); } for (var i = 0; i < tree.elements.length; i++) { var element = tree.elements[i]; if (i % 2) { this.checkType_(TEMPLATE_SUBSTITUTION, element, 'Template literal substitution expected'); } else { this.checkType_(TEMPLATE_LITERAL_PORTION, element, 'Template literal portion expected'); } } }, visitReturnStatement: function(tree) { if (tree.expression !== null) { this.checkVisit_(tree.expression.isExpression(), tree.expression, 'expression expected'); } }, visitSetAccessor: function(tree) { this.checkPropertyName_(tree.name); this.checkType_(FUNCTION_BODY, tree.body, 'function body expected'); }, visitSpreadExpression: function(tree) { this.checkVisit_(tree.expression.isAssignmentExpression(), tree.expression, 'assignment expression expected'); }, visitStateMachine: function(tree) { this.fail_(tree, 'State machines are never valid outside of the ' + 'GeneratorTransformer pass.'); }, visitSwitchStatement: function(tree) { this.checkVisit_(tree.expression.isExpression(), tree.expression, 'expression expected'); var defaultCount = 0; for (var i = 0; i < tree.caseClauses.length; i++) { var caseClause = tree.caseClauses[i]; if (caseClause.type === DEFAULT_CLAUSE) { ++defaultCount; this.checkVisit_(defaultCount <= 1, caseClause, 'no more than one default clause allowed'); } else { this.checkType_(CASE_CLAUSE, caseClause, 'case or default clause expected'); } } }, visitThrowStatement: function(tree) { if (tree.value === null) { return; } this.checkVisit_(tree.value.isExpression(), tree.value, 'expression expected'); }, visitTryStatement: function(tree) { this.checkType_(BLOCK, tree.body, 'block expected'); if (tree.catchBlock !== null) { this.checkType_(CATCH, tree.catchBlock, 'catch block expected'); } if (tree.finallyBlock !== null) { this.checkType_(FINALLY, tree.finallyBlock, 'finally block expected'); } if (tree.catchBlock === null && tree.finallyBlock === null) { this.fail_(tree, 'either catch or finally must be present'); } }, visitTypeName: function(tree) {}, visitUnaryExpression: function(tree) { this.checkVisit_(tree.operand.isAssignmentExpression(), tree.operand, 'assignment expression expected'); }, visitVariableDeclaration: function(tree) { this.checkVisit_(tree.lvalue.isPattern() || tree.lvalue.type == BINDING_IDENTIFIER, tree.lvalue, 'binding identifier expected, found: ' + tree.lvalue.type); if (tree.initializer !== null) { this.checkVisit_(tree.initializer.isAssignmentExpression(), tree.initializer, 'assignment expression expected'); } }, visitWhileStatement: function(tree) { this.checkVisit_(tree.condition.isExpression(), tree.condition, 'expression expected'); this.checkVisit_(tree.body.isStatement(), tree.body, 'statement expected'); }, visitWithStatement: function(tree) { this.checkVisit_(tree.expression.isExpression(), tree.expression, 'expression expected'); this.checkVisit_(tree.body.isStatement(), tree.body, 'statement expected'); }, visitYieldExpression: function(tree) { if (tree.expression !== null) { this.checkVisit_(tree.expression.isExpression(), tree.expression, 'expression expected'); } } }, {}, ParseTreeVisitor); ParseTreeValidator.validate = function(tree) { var validator = new ParseTreeValidator(); try { validator.visitAny(tree); } catch (e) { if (!(e instanceof ValidationError)) { throw e; } var location = null; if (e.tree !== null) { location = e.tree.location; } if (location === null) { location = tree.location; } var locationString = location !== null ? location.start.toString() : '(unknown)'; throw new Error(("Parse tree validation failure '" + e.message + "' at " + locationString + ":") + '\n\n' + TreeWriter.write(tree, { highlighted: e.tree, showLineNumbers: true }) + '\n'); } }; return {get ParseTreeValidator() { return ParseTreeValidator; }}; }); System.register("traceur@0.0.52/src/codegeneration/MultiTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/MultiTransformer"; var ParseTreeValidator = System.get("traceur@0.0.52/src/syntax/ParseTreeValidator").ParseTreeValidator; var MultiTransformer = function MultiTransformer(reporter, validate) { this.reporter_ = reporter; this.validate_ = validate; this.treeTransformers_ = []; }; ($traceurRuntime.createClass)(MultiTransformer, { append: function(treeTransformer) { this.treeTransformers_.push(treeTransformer); }, transform: function(tree) { var reporter = this.reporter_; var validate = this.validate_; this.treeTransformers_.every((function(transformTree) { tree = transformTree(tree); if (reporter.hadError()) return false; if (validate) ParseTreeValidator.validate(tree); return true; })); return tree; } }, {}); return {get MultiTransformer() { return MultiTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/NumericLiteralTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/NumericLiteralTransformer"; var ParseTreeTransformer = System.get("traceur@0.0.52/src/codegeneration/ParseTreeTransformer").ParseTreeTransformer; var $__624 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), LiteralExpression = $__624.LiteralExpression, LiteralPropertyName = $__624.LiteralPropertyName; var LiteralToken = System.get("traceur@0.0.52/src/syntax/LiteralToken").LiteralToken; var NUMBER = System.get("traceur@0.0.52/src/syntax/TokenType").NUMBER; function needsTransform(token) { return token.type === NUMBER && /^0[bBoO]/.test(token.value); } function transformToken(token) { return new LiteralToken(NUMBER, String(token.processedValue), token.location); } var NumericLiteralTransformer = function NumericLiteralTransformer() { $traceurRuntime.defaultSuperCall(this, $NumericLiteralTransformer.prototype, arguments); }; var $NumericLiteralTransformer = NumericLiteralTransformer; ($traceurRuntime.createClass)(NumericLiteralTransformer, { transformLiteralExpression: function(tree) { var token = tree.literalToken; if (needsTransform(token)) return new LiteralExpression(tree.location, transformToken(token)); return tree; }, transformLiteralPropertyName: function(tree) { var token = tree.literalToken; if (needsTransform(token)) return new LiteralPropertyName(tree.location, transformToken(token)); return tree; } }, {}, ParseTreeTransformer); return {get NumericLiteralTransformer() { return NumericLiteralTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/ObjectLiteralTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/ObjectLiteralTransformer"; var FindVisitor = System.get("traceur@0.0.52/src/codegeneration/FindVisitor").FindVisitor; var $__629 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), FunctionExpression = $__629.FunctionExpression, IdentifierExpression = $__629.IdentifierExpression, LiteralExpression = $__629.LiteralExpression; var TempVarTransformer = System.get("traceur@0.0.52/src/codegeneration/TempVarTransformer").TempVarTransformer; var IDENTIFIER = System.get("traceur@0.0.52/src/syntax/TokenType").IDENTIFIER; var $__632 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), COMPUTED_PROPERTY_NAME = $__632.COMPUTED_PROPERTY_NAME, LITERAL_PROPERTY_NAME = $__632.LITERAL_PROPERTY_NAME; var $__633 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createAssignmentExpression = $__633.createAssignmentExpression, createCommaExpression = $__633.createCommaExpression, createDefineProperty = $__633.createDefineProperty, createEmptyParameterList = $__633.createEmptyParameterList, createFunctionExpression = $__633.createFunctionExpression, createIdentifierExpression = $__633.createIdentifierExpression, createObjectCreate = $__633.createObjectCreate, createObjectLiteralExpression = $__633.createObjectLiteralExpression, createParenExpression = $__633.createParenExpression, createPropertyNameAssignment = $__633.createPropertyNameAssignment, createStringLiteral = $__633.createStringLiteral; var propName = System.get("traceur@0.0.52/src/staticsemantics/PropName").propName; var transformOptions = System.get("traceur@0.0.52/src/Options").transformOptions; var FindAdvancedProperty = function FindAdvancedProperty(tree) { this.protoExpression = null; $traceurRuntime.superCall(this, $FindAdvancedProperty.prototype, "constructor", [tree, true]); }; var $FindAdvancedProperty = FindAdvancedProperty; ($traceurRuntime.createClass)(FindAdvancedProperty, { visitPropertyNameAssignment: function(tree) { if (isProtoName(tree.name)) this.protoExpression = tree.value; else $traceurRuntime.superCall(this, $FindAdvancedProperty.prototype, "visitPropertyNameAssignment", [tree]); }, visitComputedPropertyName: function(tree) { if (transformOptions.computedPropertyNames) this.found = true; } }, {}, FindVisitor); function isProtoName(tree) { return propName(tree) === '__proto__'; } var ObjectLiteralTransformer = function ObjectLiteralTransformer(identifierGenerator) { $traceurRuntime.superCall(this, $ObjectLiteralTransformer.prototype, "constructor", [identifierGenerator]); this.protoExpression = null; this.needsAdvancedTransform = false; this.seenAccessors = null; }; var $ObjectLiteralTransformer = ObjectLiteralTransformer; ($traceurRuntime.createClass)(ObjectLiteralTransformer, { findSeenAccessor_: function(name) { if (name.type === COMPUTED_PROPERTY_NAME) return null; var s = propName(name); return this.seenAccessors[s]; }, removeSeenAccessor_: function(name) { if (name.type === COMPUTED_PROPERTY_NAME) return; var s = propName(name); delete this.seenAccessors[s]; }, addSeenAccessor_: function(name, descr) { if (name.type === COMPUTED_PROPERTY_NAME) return; var s = propName(name); this.seenAccessors[s] = descr; }, createProperty_: function(name, descr) { var expression; if (name.type === LITERAL_PROPERTY_NAME) { if (this.needsAdvancedTransform) expression = this.getPropertyName_(name); else expression = name; } else { expression = name.expression; } if (descr.get || descr.set) { var oldAccessor = this.findSeenAccessor_(name); if (oldAccessor) { oldAccessor.get = descr.get || oldAccessor.get; oldAccessor.set = descr.set || oldAccessor.set; this.removeSeenAccessor_(name); return null; } else { this.addSeenAccessor_(name, descr); } } return [expression, descr]; }, getPropertyName_: function(nameTree) { var token = nameTree.literalToken; switch (token.type) { case IDENTIFIER: return createStringLiteral(token.value); default: if (token.isKeyword()) return createStringLiteral(token.type); return new LiteralExpression(token.location, token); } }, transformClassDeclaration: function(tree) { return tree; }, transformClassExpression: function(tree) { return tree; }, transformObjectLiteralExpression: function(tree) { var oldNeedsTransform = this.needsAdvancedTransform; var oldSeenAccessors = this.seenAccessors; try { var finder = new FindAdvancedProperty(tree); if (!finder.found) { this.needsAdvancedTransform = false; return $traceurRuntime.superCall(this, $ObjectLiteralTransformer.prototype, "transformObjectLiteralExpression", [tree]); } this.needsAdvancedTransform = true; this.seenAccessors = Object.create(null); var properties = this.transformList(tree.propertyNameAndValues); properties = properties.filter((function(tree) { return tree; })); var tempVar = this.addTempVar(); var tempVarIdentifierExpression = createIdentifierExpression(tempVar); var expressions = properties.map((function(property) { var expression = property[0]; var descr = property[1]; return createDefineProperty(tempVarIdentifierExpression, expression, descr); })); var protoExpression = this.transformAny(finder.protoExpression); var objectExpression; if (protoExpression) objectExpression = createObjectCreate(protoExpression); else objectExpression = createObjectLiteralExpression([]); expressions.unshift(createAssignmentExpression(tempVarIdentifierExpression, objectExpression)); expressions.push(tempVarIdentifierExpression); return createParenExpression(createCommaExpression(expressions)); } finally { this.needsAdvancedTransform = oldNeedsTransform; this.seenAccessors = oldSeenAccessors; } }, transformPropertyNameAssignment: function(tree) { if (!this.needsAdvancedTransform) return $traceurRuntime.superCall(this, $ObjectLiteralTransformer.prototype, "transformPropertyNameAssignment", [tree]); if (isProtoName(tree.name)) return null; return this.createProperty_(tree.name, { value: this.transformAny(tree.value), configurable: true, enumerable: true, writable: true }); }, transformGetAccessor: function(tree) { if (!this.needsAdvancedTransform) return $traceurRuntime.superCall(this, $ObjectLiteralTransformer.prototype, "transformGetAccessor", [tree]); var body = this.transformAny(tree.body); var func = createFunctionExpression(createEmptyParameterList(), body); return this.createProperty_(tree.name, { get: func, configurable: true, enumerable: true }); }, transformSetAccessor: function(tree) { if (!this.needsAdvancedTransform) return $traceurRuntime.superCall(this, $ObjectLiteralTransformer.prototype, "transformSetAccessor", [tree]); var body = this.transformAny(tree.body); var parameterList = this.transformAny(tree.parameterList); var func = createFunctionExpression(parameterList, body); return this.createProperty_(tree.name, { set: func, configurable: true, enumerable: true }); }, transformPropertyMethodAssignment: function(tree) { var func = new FunctionExpression(tree.location, null, tree.functionKind, this.transformAny(tree.parameterList), tree.typeAnnotation, [], this.transformAny(tree.body)); if (!this.needsAdvancedTransform) { return createPropertyNameAssignment(tree.name, func); } var expression = this.transformAny(tree.name); return this.createProperty_(tree.name, { value: func, configurable: true, enumerable: true, writable: true }); }, transformPropertyNameShorthand: function(tree) { if (!this.needsAdvancedTransform) return $traceurRuntime.superCall(this, $ObjectLiteralTransformer.prototype, "transformPropertyNameShorthand", [tree]); var expression = this.transformAny(tree.name); return this.createProperty_(tree.name, { value: new IdentifierExpression(tree.location, tree.name.identifierToken), configurable: true, enumerable: false, writable: true }); } }, {}, TempVarTransformer); return {get ObjectLiteralTransformer() { return ObjectLiteralTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/PropertyNameShorthandTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/PropertyNameShorthandTransformer"; var $__637 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), IdentifierExpression = $__637.IdentifierExpression, LiteralPropertyName = $__637.LiteralPropertyName, PropertyNameAssignment = $__637.PropertyNameAssignment; var ParseTreeTransformer = System.get("traceur@0.0.52/src/codegeneration/ParseTreeTransformer").ParseTreeTransformer; var PropertyNameShorthandTransformer = function PropertyNameShorthandTransformer() { $traceurRuntime.defaultSuperCall(this, $PropertyNameShorthandTransformer.prototype, arguments); }; var $PropertyNameShorthandTransformer = PropertyNameShorthandTransformer; ($traceurRuntime.createClass)(PropertyNameShorthandTransformer, {transformPropertyNameShorthand: function(tree) { return new PropertyNameAssignment(tree.location, new LiteralPropertyName(tree.location, tree.name), new IdentifierExpression(tree.location, tree.name)); }}, {}, ParseTreeTransformer); return {get PropertyNameShorthandTransformer() { return PropertyNameShorthandTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/RestParameterTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/RestParameterTransformer"; var $__640 = Object.freeze(Object.defineProperties(["\n for (var ", " = [], ", " = ", ";\n ", " < arguments.length; ", "++)\n ", "[", " - ", "] = arguments[", "];"], {raw: {value: Object.freeze(["\n for (var ", " = [], ", " = ", ";\n ", " < arguments.length; ", "++)\n ", "[", " - ", "] = arguments[", "];"])}})), $__641 = Object.freeze(Object.defineProperties(["\n for (var ", " = [], ", " = 0;\n ", " < arguments.length; ", "++)\n ", "[", "] = arguments[", "];"], {raw: {value: Object.freeze(["\n for (var ", " = [], ", " = 0;\n ", " < arguments.length; ", "++)\n ", "[", "] = arguments[", "];"])}})); var FormalParameterList = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees").FormalParameterList; var ParameterTransformer = System.get("traceur@0.0.52/src/codegeneration/ParameterTransformer").ParameterTransformer; var createIdentifierToken = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory").createIdentifierToken; var parseStatement = System.get("traceur@0.0.52/src/codegeneration/PlaceholderParser").parseStatement; function hasRestParameter(parameterList) { var parameters = parameterList.parameters; return parameters.length > 0 && parameters[parameters.length - 1].isRestParameter(); } function getRestParameterLiteralToken(parameterList) { var parameters = parameterList.parameters; return parameters[parameters.length - 1].parameter.identifier.identifierToken; } var RestParameterTransformer = function RestParameterTransformer() { $traceurRuntime.defaultSuperCall(this, $RestParameterTransformer.prototype, arguments); }; var $RestParameterTransformer = RestParameterTransformer; ($traceurRuntime.createClass)(RestParameterTransformer, {transformFormalParameterList: function(tree) { var transformed = $traceurRuntime.superCall(this, $RestParameterTransformer.prototype, "transformFormalParameterList", [tree]); if (hasRestParameter(transformed)) { var parametersWithoutRestParam = new FormalParameterList(transformed.location, transformed.parameters.slice(0, -1)); var startIndex = transformed.parameters.length - 1; var i = createIdentifierToken(this.getTempIdentifier()); var name = getRestParameterLiteralToken(transformed); var loop; if (startIndex) { loop = parseStatement($__640, name, i, startIndex, i, i, name, i, startIndex, i); } else { loop = parseStatement($__641, name, i, i, i, name, i, i); } this.parameterStatements.push(loop); return parametersWithoutRestParam; } return transformed; }}, {}, ParameterTransformer); return {get RestParameterTransformer() { return RestParameterTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/SpreadTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/SpreadTransformer"; var $__647 = Object.freeze(Object.defineProperties(["$traceurRuntime.spread(", ")"], {raw: {value: Object.freeze(["$traceurRuntime.spread(", ")"])}})); var $__648 = System.get("traceur@0.0.52/src/syntax/PredefinedName"), APPLY = $__648.APPLY, BIND = $__648.BIND, FUNCTION = $__648.FUNCTION, PROTOTYPE = $__648.PROTOTYPE; var $__649 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), MEMBER_EXPRESSION = $__649.MEMBER_EXPRESSION, MEMBER_LOOKUP_EXPRESSION = $__649.MEMBER_LOOKUP_EXPRESSION, SPREAD_EXPRESSION = $__649.SPREAD_EXPRESSION; var TempVarTransformer = System.get("traceur@0.0.52/src/codegeneration/TempVarTransformer").TempVarTransformer; var $__651 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createArgumentList = $__651.createArgumentList, createArrayLiteralExpression = $__651.createArrayLiteralExpression, createAssignmentExpression = $__651.createAssignmentExpression, createCallExpression = $__651.createCallExpression, createEmptyArgumentList = $__651.createEmptyArgumentList, createIdentifierExpression = $__651.createIdentifierExpression, createMemberExpression = $__651.createMemberExpression, createMemberLookupExpression = $__651.createMemberLookupExpression, createNewExpression = $__651.createNewExpression, createNullLiteral = $__651.createNullLiteral, createParenExpression = $__651.createParenExpression; var parseExpression = System.get("traceur@0.0.52/src/codegeneration/PlaceholderParser").parseExpression; function hasSpreadMember(trees) { return trees.some((function(tree) { return tree && tree.type == SPREAD_EXPRESSION; })); } var SpreadTransformer = function SpreadTransformer() { $traceurRuntime.defaultSuperCall(this, $SpreadTransformer.prototype, arguments); }; var $SpreadTransformer = SpreadTransformer; ($traceurRuntime.createClass)(SpreadTransformer, { createArrayFromElements_: function(elements) { var length = elements.length; var args = []; var lastArray; for (var i = 0; i < length; i++) { if (elements[i] && elements[i].type === SPREAD_EXPRESSION) { if (lastArray) { args.push(createArrayLiteralExpression(lastArray)); lastArray = null; } args.push(this.transformAny(elements[i].expression)); } else { if (!lastArray) lastArray = []; lastArray.push(this.transformAny(elements[i])); } } if (lastArray) args.push(createArrayLiteralExpression(lastArray)); return parseExpression($__647, createArgumentList(args)); }, desugarCallSpread_: function(tree) { var operand = this.transformAny(tree.operand); var functionObject, contextObject; this.pushTempScope(); if (operand.type == MEMBER_EXPRESSION) { var tempIdent = createIdentifierExpression(this.addTempVar()); var parenExpression = createParenExpression(createAssignmentExpression(tempIdent, operand.operand)); var memberName = operand.memberName; contextObject = tempIdent; functionObject = createMemberExpression(parenExpression, memberName); } else if (tree.operand.type == MEMBER_LOOKUP_EXPRESSION) { var tempIdent = createIdentifierExpression(this.addTempVar()); var parenExpression = createParenExpression(createAssignmentExpression(tempIdent, operand.operand)); var memberExpression = this.transformAny(operand.memberExpression); contextObject = tempIdent; functionObject = createMemberLookupExpression(parenExpression, memberExpression); } else { contextObject = createNullLiteral(); functionObject = operand; } this.popTempScope(); var arrayExpression = this.createArrayFromElements_(tree.args.args); return createCallExpression(createMemberExpression(functionObject, APPLY), createArgumentList([contextObject, arrayExpression])); }, desugarNewSpread_: function(tree) { var arrayExpression = $traceurRuntime.spread([createNullLiteral()], tree.args.args); arrayExpression = this.createArrayFromElements_(arrayExpression); return createNewExpression(createParenExpression(createCallExpression(createMemberExpression(FUNCTION, PROTOTYPE, BIND, APPLY), createArgumentList([this.transformAny(tree.operand), arrayExpression]))), createEmptyArgumentList()); }, transformArrayLiteralExpression: function(tree) { if (hasSpreadMember(tree.elements)) { return this.createArrayFromElements_(tree.elements); } return $traceurRuntime.superCall(this, $SpreadTransformer.prototype, "transformArrayLiteralExpression", [tree]); }, transformCallExpression: function(tree) { if (hasSpreadMember(tree.args.args)) { return this.desugarCallSpread_(tree); } return $traceurRuntime.superCall(this, $SpreadTransformer.prototype, "transformCallExpression", [tree]); }, transformNewExpression: function(tree) { if (tree.args != null && hasSpreadMember(tree.args.args)) { return this.desugarNewSpread_(tree); } return $traceurRuntime.superCall(this, $SpreadTransformer.prototype, "transformNewExpression", [tree]); } }, {}, TempVarTransformer); return {get SpreadTransformer() { return SpreadTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/SymbolTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/SymbolTransformer"; var $__654 = Object.freeze(Object.defineProperties(["$traceurRuntime.toProperty(", ") in ", ""], {raw: {value: Object.freeze(["$traceurRuntime.toProperty(", ") in ", ""])}})), $__655 = Object.freeze(Object.defineProperties(["$traceurRuntime.setProperty(", ",\n ", ", ", ")"], {raw: {value: Object.freeze(["$traceurRuntime.setProperty(", ",\n ", ", ", ")"])}})), $__656 = Object.freeze(Object.defineProperties(["", "[$traceurRuntime.toProperty(", ")]"], {raw: {value: Object.freeze(["", "[$traceurRuntime.toProperty(", ")]"])}})), $__657 = Object.freeze(Object.defineProperties(["$traceurRuntime.typeof(", ")"], {raw: {value: Object.freeze(["$traceurRuntime.typeof(", ")"])}})), $__658 = Object.freeze(Object.defineProperties(["(typeof ", " === 'undefined' ?\n 'undefined' : ", ")"], {raw: {value: Object.freeze(["(typeof ", " === 'undefined' ?\n 'undefined' : ", ")"])}})); var $__659 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), BinaryExpression = $__659.BinaryExpression, MemberLookupExpression = $__659.MemberLookupExpression, UnaryExpression = $__659.UnaryExpression; var ExplodeExpressionTransformer = System.get("traceur@0.0.52/src/codegeneration/ExplodeExpressionTransformer").ExplodeExpressionTransformer; var $__661 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), IDENTIFIER_EXPRESSION = $__661.IDENTIFIER_EXPRESSION, LITERAL_EXPRESSION = $__661.LITERAL_EXPRESSION, MEMBER_LOOKUP_EXPRESSION = $__661.MEMBER_LOOKUP_EXPRESSION, UNARY_EXPRESSION = $__661.UNARY_EXPRESSION; var TempVarTransformer = System.get("traceur@0.0.52/src/codegeneration/TempVarTransformer").TempVarTransformer; var $__663 = System.get("traceur@0.0.52/src/syntax/TokenType"), EQUAL = $__663.EQUAL, EQUAL_EQUAL = $__663.EQUAL_EQUAL, EQUAL_EQUAL_EQUAL = $__663.EQUAL_EQUAL_EQUAL, IN = $__663.IN, NOT_EQUAL = $__663.NOT_EQUAL, NOT_EQUAL_EQUAL = $__663.NOT_EQUAL_EQUAL, STRING = $__663.STRING, TYPEOF = $__663.TYPEOF; var createParenExpression = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory").createParenExpression; var parseExpression = System.get("traceur@0.0.52/src/codegeneration/PlaceholderParser").parseExpression; var ExplodeSymbolExpression = function ExplodeSymbolExpression() { $traceurRuntime.defaultSuperCall(this, $ExplodeSymbolExpression.prototype, arguments); }; var $ExplodeSymbolExpression = ExplodeSymbolExpression; ($traceurRuntime.createClass)(ExplodeSymbolExpression, { transformArrowFunctionExpression: function(tree) { return tree; }, transformClassExpression: function(tree) { return tree; }, transformFunctionBody: function(tree) { return tree; } }, {}, ExplodeExpressionTransformer); function isEqualityExpression(tree) { switch (tree.operator.type) { case EQUAL_EQUAL: case EQUAL_EQUAL_EQUAL: case NOT_EQUAL: case NOT_EQUAL_EQUAL: return true; } return false; } function isTypeof(tree) { return tree.type === UNARY_EXPRESSION && tree.operator.type === TYPEOF; } function isSafeTypeofString(tree) { if (tree.type !== LITERAL_EXPRESSION) return false; var value = tree.literalToken.processedValue; switch (value) { case 'symbol': case 'object': return false; } return true; } var SymbolTransformer = function SymbolTransformer() { $traceurRuntime.defaultSuperCall(this, $SymbolTransformer.prototype, arguments); }; var $SymbolTransformer = SymbolTransformer; ($traceurRuntime.createClass)(SymbolTransformer, { transformTypeofOperand_: function(tree) { var operand = this.transformAny(tree.operand); return new UnaryExpression(tree.location, tree.operator, operand); }, transformBinaryExpression: function(tree) { if (tree.operator.type === IN) { var name = this.transformAny(tree.left); var object = this.transformAny(tree.right); if (name.type === LITERAL_EXPRESSION) return new BinaryExpression(tree.location, name, tree.operator, object); return parseExpression($__654, name, object); } if (isEqualityExpression(tree)) { if (isTypeof(tree.left) && isSafeTypeofString(tree.right)) { var left = this.transformTypeofOperand_(tree.left); var right = tree.right; return new BinaryExpression(tree.location, left, tree.operator, right); } if (isTypeof(tree.right) && isSafeTypeofString(tree.left)) { var left = tree.left; var right = this.transformTypeofOperand_(tree.right); return new BinaryExpression(tree.location, left, tree.operator, right); } } if (tree.left.type === MEMBER_LOOKUP_EXPRESSION && tree.operator.isAssignmentOperator()) { if (tree.operator.type !== EQUAL) { var exploded = new ExplodeSymbolExpression(this).transformAny(tree); return this.transformAny(createParenExpression(exploded)); } var operand = this.transformAny(tree.left.operand); var memberExpression = this.transformAny(tree.left.memberExpression); var value = this.transformAny(tree.right); return parseExpression($__655, operand, memberExpression, value); } return $traceurRuntime.superCall(this, $SymbolTransformer.prototype, "transformBinaryExpression", [tree]); }, transformMemberLookupExpression: function(tree) { var operand = this.transformAny(tree.operand); var memberExpression = this.transformAny(tree.memberExpression); if (memberExpression.type === LITERAL_EXPRESSION && memberExpression.literalToken.type !== STRING) { return new MemberLookupExpression(tree.location, operand, memberExpression); } return parseExpression($__656, operand, memberExpression); }, transformUnaryExpression: function(tree) { if (tree.operator.type !== TYPEOF) return $traceurRuntime.superCall(this, $SymbolTransformer.prototype, "transformUnaryExpression", [tree]); var operand = this.transformAny(tree.operand); var expression = parseExpression($__657, operand); if (operand.type === IDENTIFIER_EXPRESSION) { return parseExpression($__658, operand, expression); } return expression; } }, {}, TempVarTransformer); return {get SymbolTransformer() { return SymbolTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/TemplateLiteralTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/TemplateLiteralTransformer"; var $__667 = Object.freeze(Object.defineProperties(["Object.freeze(Object.defineProperties(", ", {\n raw: {\n value: Object.freeze(", ")\n }\n }))"], {raw: {value: Object.freeze(["Object.freeze(Object.defineProperties(", ", {\n raw: {\n value: Object.freeze(", ")\n }\n }))"])}})); var $__668 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), BINARY_EXPRESSION = $__668.BINARY_EXPRESSION, COMMA_EXPRESSION = $__668.COMMA_EXPRESSION, CONDITIONAL_EXPRESSION = $__668.CONDITIONAL_EXPRESSION, TEMPLATE_LITERAL_PORTION = $__668.TEMPLATE_LITERAL_PORTION; var $__669 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), LiteralExpression = $__669.LiteralExpression, ParenExpression = $__669.ParenExpression; var LiteralToken = System.get("traceur@0.0.52/src/syntax/LiteralToken").LiteralToken; var ParseTreeTransformer = System.get("traceur@0.0.52/src/codegeneration/ParseTreeTransformer").ParseTreeTransformer; var TempVarTransformer = System.get("traceur@0.0.52/src/codegeneration/TempVarTransformer").TempVarTransformer; var $__673 = System.get("traceur@0.0.52/src/syntax/TokenType"), PERCENT = $__673.PERCENT, PLUS = $__673.PLUS, SLASH = $__673.SLASH, STAR = $__673.STAR, STRING = $__673.STRING; var $__674 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createArgumentList = $__674.createArgumentList, createArrayLiteralExpression = $__674.createArrayLiteralExpression, createBinaryExpression = $__674.createBinaryExpression, createCallExpression = $__674.createCallExpression, createIdentifierExpression = $__674.createIdentifierExpression, createOperatorToken = $__674.createOperatorToken, createStringLiteral = $__674.createStringLiteral; var parseExpression = System.get("traceur@0.0.52/src/codegeneration/PlaceholderParser").parseExpression; function createCallSiteIdObject(tree) { var elements = tree.elements; var cooked = createCookedStringArray(elements); var raw = createRawStringArray(elements); return parseExpression($__667, cooked, raw); } function maybeAddEmptyStringAtEnd(elements, items) { var length = elements.length; if (!length || elements[length - 1].type !== TEMPLATE_LITERAL_PORTION) items.push(createStringLiteral('')); } function createRawStringArray(elements) { var items = []; for (var i = 0; i < elements.length; i += 2) { var str = elements[i].value.value; str = str.replace(/\r\n?/g, '\n'); str = JSON.stringify(str); str = replaceRaw(str); var loc = elements[i].location; var expr = new LiteralExpression(loc, new LiteralToken(STRING, str, loc)); items.push(expr); } maybeAddEmptyStringAtEnd(elements, items); return createArrayLiteralExpression(items); } function createCookedStringLiteralExpression(tree) { var str = cookString(tree.value.value); var loc = tree.location; return new LiteralExpression(loc, new LiteralToken(STRING, str, loc)); } function createCookedStringArray(elements) { var items = []; for (var i = 0; i < elements.length; i += 2) { items.push(createCookedStringLiteralExpression(elements[i])); } maybeAddEmptyStringAtEnd(elements, items); return createArrayLiteralExpression(items); } function replaceRaw(s) { return s.replace(/\u2028|\u2029/g, function(c) { switch (c) { case '\u2028': return '\\u2028'; case '\u2029': return '\\u2029'; default: throw Error('Not reachable'); } }); } function cookString(s) { var sb = ['"']; var i = 0, k = 1, c, c2; while (i < s.length) { c = s[i++]; switch (c) { case '\\': c2 = s[i++]; switch (c2) { case '\n': case '\u2028': case '\u2029': break; case '\r': if (s[i + 1] === '\n') { i++; } break; default: sb[k++] = c; sb[k++] = c2; } break; case '"': sb[k++] = '\\"'; break; case '\n': sb[k++] = '\\n'; break; case '\r': if (s[i] === '\n') i++; sb[k++] = '\\n'; break; case '\t': sb[k++] = '\\t'; break; case '\f': sb[k++] = '\\f'; break; case '\b': sb[k++] = '\\b'; break; case '\u2028': sb[k++] = '\\u2028'; break; case '\u2029': sb[k++] = '\\u2029'; break; default: sb[k++] = c; } } sb[k++] = '"'; return sb.join(''); } var TemplateLiteralTransformer = function TemplateLiteralTransformer() { $traceurRuntime.defaultSuperCall(this, $TemplateLiteralTransformer.prototype, arguments); }; var $TemplateLiteralTransformer = TemplateLiteralTransformer; ($traceurRuntime.createClass)(TemplateLiteralTransformer, { transformFunctionBody: function(tree) { return ParseTreeTransformer.prototype.transformFunctionBody.call(this, tree); }, transformTemplateLiteralExpression: function(tree) { if (!tree.operand) return this.createDefaultTemplateLiteral(tree); var operand = this.transformAny(tree.operand); var elements = tree.elements; var callsiteIdObject = createCallSiteIdObject(tree); var idName = this.addTempVar(callsiteIdObject); var args = [createIdentifierExpression(idName)]; for (var i = 1; i < elements.length; i += 2) { args.push(this.transformAny(elements[i])); } return createCallExpression(operand, createArgumentList(args)); }, transformTemplateSubstitution: function(tree) { var transformedTree = this.transformAny(tree.expression); switch (transformedTree.type) { case BINARY_EXPRESSION: switch (transformedTree.operator.type) { case STAR: case PERCENT: case SLASH: return transformedTree; } case COMMA_EXPRESSION: case CONDITIONAL_EXPRESSION: return new ParenExpression(null, transformedTree); } return transformedTree; }, transformTemplateLiteralPortion: function(tree) { return createCookedStringLiteralExpression(tree); }, createDefaultTemplateLiteral: function(tree) { var length = tree.elements.length; if (length === 0) { var loc = tree.location; return new LiteralExpression(loc, new LiteralToken(STRING, '""', loc)); } var firstNonEmpty = tree.elements[0].value.value === '' ? -1 : 0; var binaryExpression = this.transformAny(tree.elements[0]); if (length == 1) return binaryExpression; var plusToken = createOperatorToken(PLUS); for (var i = 1; i < length; i++) { var element = tree.elements[i]; if (element.type === TEMPLATE_LITERAL_PORTION) { if (element.value.value === '') continue; else if (firstNonEmpty < 0 && i === 2) binaryExpression = binaryExpression.right; } var transformedTree = this.transformAny(tree.elements[i]); binaryExpression = createBinaryExpression(binaryExpression, plusToken, transformedTree); } return new ParenExpression(null, binaryExpression); } }, {}, TempVarTransformer); return {get TemplateLiteralTransformer() { return TemplateLiteralTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/TypeAssertionTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/TypeAssertionTransformer"; var $__677 = Object.freeze(Object.defineProperties(["assert.type(", ", ", ")"], {raw: {value: Object.freeze(["assert.type(", ", ", ")"])}})), $__678 = Object.freeze(Object.defineProperties(["assert.argumentTypes(", ")"], {raw: {value: Object.freeze(["assert.argumentTypes(", ")"])}})), $__679 = Object.freeze(Object.defineProperties(["return assert.returnType((", "), ", ")"], {raw: {value: Object.freeze(["return assert.returnType((", "), ", ")"])}})), $__680 = Object.freeze(Object.defineProperties(["$traceurRuntime.type.any"], {raw: {value: Object.freeze(["$traceurRuntime.type.any"])}})); var $__681 = System.get("traceur@0.0.52/src/syntax/trees/ParseTreeType"), BINDING_ELEMENT = $__681.BINDING_ELEMENT, REST_PARAMETER = $__681.REST_PARAMETER; var $__682 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), ImportDeclaration = $__682.ImportDeclaration, ImportSpecifier = $__682.ImportSpecifier, ImportSpecifierSet = $__682.ImportSpecifierSet, Module = $__682.Module, ModuleSpecifier = $__682.ModuleSpecifier, Script = $__682.Script, VariableDeclaration = $__682.VariableDeclaration; var $__683 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createArgumentList = $__683.createArgumentList, createIdentifierExpression = $__683.createIdentifierExpression, createIdentifierToken = $__683.createIdentifierToken, createStringLiteralToken = $__683.createStringLiteralToken; var $__684 = System.get("traceur@0.0.52/src/codegeneration/PlaceholderParser"), parseExpression = $__684.parseExpression, parseStatement = $__684.parseStatement; var ParameterTransformer = System.get("traceur@0.0.52/src/codegeneration/ParameterTransformer").ParameterTransformer; var options = System.get("traceur@0.0.52/src/Options").options; var TypeAssertionTransformer = function TypeAssertionTransformer(identifierGenerator) { $traceurRuntime.superCall(this, $TypeAssertionTransformer.prototype, "constructor", [identifierGenerator]); this.returnTypeStack_ = []; this.parametersStack_ = []; this.assertionAdded_ = false; }; var $TypeAssertionTransformer = TypeAssertionTransformer; ($traceurRuntime.createClass)(TypeAssertionTransformer, { transformScript: function(tree) { return this.prependAssertionImport_($traceurRuntime.superCall(this, $TypeAssertionTransformer.prototype, "transformScript", [tree]), Script); }, transformModule: function(tree) { return this.prependAssertionImport_($traceurRuntime.superCall(this, $TypeAssertionTransformer.prototype, "transformModule", [tree]), Module); }, transformVariableDeclaration: function(tree) { if (tree.typeAnnotation && tree.initializer) { var assert = parseExpression($__677, tree.initializer, tree.typeAnnotation); tree = new VariableDeclaration(tree.location, tree.lvalue, tree.typeAnnotation, assert); this.assertionAdded_ = true; } return $traceurRuntime.superCall(this, $TypeAssertionTransformer.prototype, "transformVariableDeclaration", [tree]); }, transformFormalParameterList: function(tree) { this.parametersStack_.push({ atLeastOneParameterTyped: false, arguments: [] }); var transformed = $traceurRuntime.superCall(this, $TypeAssertionTransformer.prototype, "transformFormalParameterList", [tree]); var params = this.parametersStack_.pop(); if (params.atLeastOneParameterTyped) { var argumentList = createArgumentList(params.arguments); var assertStatement = parseStatement($__678, argumentList); this.parameterStatements.push(assertStatement); this.assertionAdded_ = true; } return transformed; }, transformFormalParameter: function(tree) { var transformed = $traceurRuntime.superCall(this, $TypeAssertionTransformer.prototype, "transformFormalParameter", [tree]); switch (transformed.parameter.type) { case BINDING_ELEMENT: this.transformBindingElementParameter_(transformed.parameter, transformed.typeAnnotation); break; case REST_PARAMETER: break; } return transformed; }, transformGetAccessor: function(tree) { this.pushReturnType_(tree.typeAnnotation); tree = $traceurRuntime.superCall(this, $TypeAssertionTransformer.prototype, "transformGetAccessor", [tree]); this.popReturnType_(); return tree; }, transformPropertyMethodAssignment: function(tree) { this.pushReturnType_(tree.typeAnnotation); tree = $traceurRuntime.superCall(this, $TypeAssertionTransformer.prototype, "transformPropertyMethodAssignment", [tree]); this.popReturnType_(); return tree; }, transformFunctionDeclaration: function(tree) { this.pushReturnType_(tree.typeAnnotation); tree = $traceurRuntime.superCall(this, $TypeAssertionTransformer.prototype, "transformFunctionDeclaration", [tree]); this.popReturnType_(); return tree; }, transformFunctionExpression: function(tree) { this.pushReturnType_(tree.typeAnnotation); tree = $traceurRuntime.superCall(this, $TypeAssertionTransformer.prototype, "transformFunctionExpression", [tree]); this.popReturnType_(); return tree; }, transformReturnStatement: function(tree) { tree = $traceurRuntime.superCall(this, $TypeAssertionTransformer.prototype, "transformReturnStatement", [tree]); if (this.returnType_ && tree.expression) { this.assertionAdded_ = true; return parseStatement($__679, tree.expression, this.returnType_); } return tree; }, transformBindingElementParameter_: function(element, typeAnnotation) { if (!element.binding.isPattern()) { if (typeAnnotation) { this.paramTypes_.atLeastOneParameterTyped = true; } else { typeAnnotation = parseExpression($__680); } this.paramTypes_.arguments.push(createIdentifierExpression(element.binding.identifierToken), typeAnnotation); return; } }, pushReturnType_: function(typeAnnotation) { this.returnTypeStack_.push(this.transformAny(typeAnnotation)); }, prependAssertionImport_: function(tree, Ctor) { if (!this.assertionAdded_ || options.typeAssertionModule === null) return tree; var importStatement = new ImportDeclaration(null, new ImportSpecifierSet(null, [new ImportSpecifier(null, createIdentifierToken('assert'), null)]), new ModuleSpecifier(null, createStringLiteralToken(options.typeAssertionModule))); tree = new Ctor(tree.location, $traceurRuntime.spread([importStatement], tree.scriptItemList), tree.moduleName); return tree; }, popReturnType_: function() { return this.returnTypeStack_.pop(); }, get returnType_() { return this.returnTypeStack_.length > 0 ? this.returnTypeStack_[this.returnTypeStack_.length - 1] : null; }, get paramTypes_() { return this.parametersStack_[this.parametersStack_.length - 1]; } }, {}, ParameterTransformer); return {get TypeAssertionTransformer() { return TypeAssertionTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/TypeToExpressionTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/TypeToExpressionTransformer"; var ParseTreeTransformer = System.get("traceur@0.0.52/src/codegeneration/ParseTreeTransformer").ParseTreeTransformer; var $__689 = System.get("traceur@0.0.52/src/codegeneration/ParseTreeFactory"), createIdentifierExpression = $__689.createIdentifierExpression, createMemberExpression = $__689.createMemberExpression; var TypeToExpressionTransformer = function TypeToExpressionTransformer() { $traceurRuntime.defaultSuperCall(this, $TypeToExpressionTransformer.prototype, arguments); }; var $TypeToExpressionTransformer = TypeToExpressionTransformer; ($traceurRuntime.createClass)(TypeToExpressionTransformer, { transformTypeName: function(tree) { return createIdentifierExpression(tree.name); }, transformPredefinedType: function(tree) { return createMemberExpression('$traceurRuntime', 'type', tree.typeToken); } }, {}, ParseTreeTransformer); return {get TypeToExpressionTransformer() { return TypeToExpressionTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/TypeTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/TypeTransformer"; var $__691 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), FormalParameter = $__691.FormalParameter, FunctionDeclaration = $__691.FunctionDeclaration, FunctionExpression = $__691.FunctionExpression, GetAccessor = $__691.GetAccessor, PropertyMethodAssignment = $__691.PropertyMethodAssignment, VariableDeclaration = $__691.VariableDeclaration; var ParseTreeTransformer = System.get("traceur@0.0.52/src/codegeneration/ParseTreeTransformer").ParseTreeTransformer; var TypeTransformer = function TypeTransformer() { $traceurRuntime.defaultSuperCall(this, $TypeTransformer.prototype, arguments); }; var $TypeTransformer = TypeTransformer; ($traceurRuntime.createClass)(TypeTransformer, { transformVariableDeclaration: function(tree) { if (tree.typeAnnotation) { tree = new VariableDeclaration(tree.location, tree.lvalue, null, tree.initializer); } return $traceurRuntime.superCall(this, $TypeTransformer.prototype, "transformVariableDeclaration", [tree]); }, transformFormalParameter: function(tree) { if (tree.typeAnnotation !== null) return new FormalParameter(tree.location, tree.parameter, null, []); return tree; }, transformFunctionDeclaration: function(tree) { if (tree.typeAnnotation) { tree = new FunctionDeclaration(tree.location, tree.name, tree.functionKind, tree.parameterList, null, tree.annotations, tree.body); } return $traceurRuntime.superCall(this, $TypeTransformer.prototype, "transformFunctionDeclaration", [tree]); }, transformFunctionExpression: function(tree) { if (tree.typeAnnotation) { tree = new FunctionExpression(tree.location, tree.name, tree.functionKind, tree.parameterList, null, tree.annotations, tree.body); } return $traceurRuntime.superCall(this, $TypeTransformer.prototype, "transformFunctionExpression", [tree]); }, transformPropertyMethodAssignment: function(tree) { if (tree.typeAnnotation) { tree = new PropertyMethodAssignment(tree.location, tree.isStatic, tree.functionKind, tree.name, tree.parameterList, null, tree.annotations, tree.body); } return $traceurRuntime.superCall(this, $TypeTransformer.prototype, "transformPropertyMethodAssignment", [tree]); }, transformGetAccessor: function(tree) { if (tree.typeAnnotation) { tree = new GetAccessor(tree.location, tree.isStatic, tree.name, null, tree.annotations, tree.body); } return $traceurRuntime.superCall(this, $TypeTransformer.prototype, "transformGetAccessor", [tree]); } }, {}, ParseTreeTransformer); return {get TypeTransformer() { return TypeTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/UniqueIdentifierGenerator", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/UniqueIdentifierGenerator"; var UniqueIdentifierGenerator = function UniqueIdentifierGenerator() { this.identifierIndex = 0; }; ($traceurRuntime.createClass)(UniqueIdentifierGenerator, {generateUniqueIdentifier: function() { return ("$__" + this.identifierIndex++); }}, {}); return {get UniqueIdentifierGenerator() { return UniqueIdentifierGenerator; }}; }); System.register("traceur@0.0.52/src/codegeneration/FromOptionsTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/FromOptionsTransformer"; var AmdTransformer = System.get("traceur@0.0.52/src/codegeneration/AmdTransformer").AmdTransformer; var AnnotationsTransformer = System.get("traceur@0.0.52/src/codegeneration/AnnotationsTransformer").AnnotationsTransformer; var ArrayComprehensionTransformer = System.get("traceur@0.0.52/src/codegeneration/ArrayComprehensionTransformer").ArrayComprehensionTransformer; var ArrowFunctionTransformer = System.get("traceur@0.0.52/src/codegeneration/ArrowFunctionTransformer").ArrowFunctionTransformer; var BlockBindingTransformer = System.get("traceur@0.0.52/src/codegeneration/BlockBindingTransformer").BlockBindingTransformer; var ClassTransformer = System.get("traceur@0.0.52/src/codegeneration/ClassTransformer").ClassTransformer; var CommonJsModuleTransformer = System.get("traceur@0.0.52/src/codegeneration/CommonJsModuleTransformer").CommonJsModuleTransformer; var validateConst = System.get("traceur@0.0.52/src/semantics/ConstChecker").validate; var DefaultParametersTransformer = System.get("traceur@0.0.52/src/codegeneration/DefaultParametersTransformer").DefaultParametersTransformer; var DestructuringTransformer = System.get("traceur@0.0.52/src/codegeneration/DestructuringTransformer").DestructuringTransformer; var ForOfTransformer = System.get("traceur@0.0.52/src/codegeneration/ForOfTransformer").ForOfTransformer; var validateFreeVariables = System.get("traceur@0.0.52/src/semantics/FreeVariableChecker").validate; var GeneratorComprehensionTransformer = System.get("traceur@0.0.52/src/codegeneration/GeneratorComprehensionTransformer").GeneratorComprehensionTransformer; var GeneratorTransformPass = System.get("traceur@0.0.52/src/codegeneration/GeneratorTransformPass").GeneratorTransformPass; var InlineModuleTransformer = System.get("traceur@0.0.52/src/codegeneration/InlineModuleTransformer").InlineModuleTransformer; var ModuleTransformer = System.get("traceur@0.0.52/src/codegeneration/ModuleTransformer").ModuleTransformer; var MultiTransformer = System.get("traceur@0.0.52/src/codegeneration/MultiTransformer").MultiTransformer; var NumericLiteralTransformer = System.get("traceur@0.0.52/src/codegeneration/NumericLiteralTransformer").NumericLiteralTransformer; var ObjectLiteralTransformer = System.get("traceur@0.0.52/src/codegeneration/ObjectLiteralTransformer").ObjectLiteralTransformer; var PropertyNameShorthandTransformer = System.get("traceur@0.0.52/src/codegeneration/PropertyNameShorthandTransformer").PropertyNameShorthandTransformer; var InstantiateModuleTransformer = System.get("traceur@0.0.52/src/codegeneration/InstantiateModuleTransformer").InstantiateModuleTransformer; var RestParameterTransformer = System.get("traceur@0.0.52/src/codegeneration/RestParameterTransformer").RestParameterTransformer; var SpreadTransformer = System.get("traceur@0.0.52/src/codegeneration/SpreadTransformer").SpreadTransformer; var SymbolTransformer = System.get("traceur@0.0.52/src/codegeneration/SymbolTransformer").SymbolTransformer; var TemplateLiteralTransformer = System.get("traceur@0.0.52/src/codegeneration/TemplateLiteralTransformer").TemplateLiteralTransformer; var TypeTransformer = System.get("traceur@0.0.52/src/codegeneration/TypeTransformer").TypeTransformer; var TypeAssertionTransformer = System.get("traceur@0.0.52/src/codegeneration/TypeAssertionTransformer").TypeAssertionTransformer; var TypeToExpressionTransformer = System.get("traceur@0.0.52/src/codegeneration/TypeToExpressionTransformer").TypeToExpressionTransformer; var UniqueIdentifierGenerator = System.get("traceur@0.0.52/src/codegeneration/UniqueIdentifierGenerator").UniqueIdentifierGenerator; var $__724 = System.get("traceur@0.0.52/src/Options"), options = $__724.options, transformOptions = $__724.transformOptions; var FromOptionsTransformer = function FromOptionsTransformer(reporter) { var idGenerator = arguments[1] !== (void 0) ? arguments[1] : new UniqueIdentifierGenerator(); var $__725 = this; $traceurRuntime.superCall(this, $FromOptionsTransformer.prototype, "constructor", [reporter, options.validate]); var append = (function(transformer) { $__725.append((function(tree) { return new transformer(idGenerator, reporter).transformAny(tree); })); }); if (transformOptions.blockBinding) { this.append((function(tree) { validateConst(tree, reporter); return tree; })); } if (options.freeVariableChecker) { this.append((function(tree) { validateFreeVariables(tree, reporter); return tree; })); } if (transformOptions.numericLiterals) append(NumericLiteralTransformer); if (transformOptions.templateLiterals) append(TemplateLiteralTransformer); if (options.types) { append(TypeToExpressionTransformer); } if (transformOptions.annotations) append(AnnotationsTransformer); if (options.typeAssertions) append(TypeAssertionTransformer); if (transformOptions.propertyNameShorthand) append(PropertyNameShorthandTransformer); if (transformOptions.modules) { switch (transformOptions.modules) { case 'commonjs': append(CommonJsModuleTransformer); break; case 'amd': append(AmdTransformer); break; case 'inline': append(InlineModuleTransformer); break; case 'instantiate': append(InstantiateModuleTransformer); break; case 'register': append(ModuleTransformer); break; default: throw new Error('Invalid modules transform option'); } } if (transformOptions.arrowFunctions) append(ArrowFunctionTransformer); if (transformOptions.classes) append(ClassTransformer); if (transformOptions.propertyMethods || transformOptions.computedPropertyNames) { append(ObjectLiteralTransformer); } if (transformOptions.generatorComprehension) append(GeneratorComprehensionTransformer); if (transformOptions.arrayComprehension) append(ArrayComprehensionTransformer); if (transformOptions.forOf) append(ForOfTransformer); if (transformOptions.restParameters) append(RestParameterTransformer); if (transformOptions.defaultParameters) append(DefaultParametersTransformer); if (transformOptions.destructuring) append(DestructuringTransformer); if (transformOptions.types) append(TypeTransformer); if (transformOptions.spread) append(SpreadTransformer); if (transformOptions.blockBinding) append(BlockBindingTransformer); if (transformOptions.generators || transformOptions.asyncFuntions) append(GeneratorTransformPass); if (transformOptions.symbols) append(SymbolTransformer); }; var $FromOptionsTransformer = FromOptionsTransformer; ($traceurRuntime.createClass)(FromOptionsTransformer, {}, {}, MultiTransformer); return {get FromOptionsTransformer() { return FromOptionsTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/PureES6Transformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/PureES6Transformer"; var AnnotationsTransformer = System.get("traceur@0.0.52/src/codegeneration/AnnotationsTransformer").AnnotationsTransformer; var validateFreeVariables = System.get("traceur@0.0.52/src/semantics/FreeVariableChecker").validate; var MultiTransformer = System.get("traceur@0.0.52/src/codegeneration/MultiTransformer").MultiTransformer; var TypeTransformer = System.get("traceur@0.0.52/src/codegeneration/TypeTransformer").TypeTransformer; var UniqueIdentifierGenerator = System.get("traceur@0.0.52/src/codegeneration/UniqueIdentifierGenerator").UniqueIdentifierGenerator; var options = System.get("traceur@0.0.52/src/Options").options; var PureES6Transformer = function PureES6Transformer(reporter) { var idGenerator = arguments[1] !== (void 0) ? arguments[1] : new UniqueIdentifierGenerator(); var $__733 = this; $traceurRuntime.superCall(this, $PureES6Transformer.prototype, "constructor", [reporter, options.validate]); var append = (function(transformer) { $__733.append((function(tree) { return new transformer(idGenerator, reporter).transformAny(tree); })); }); if (options.freeVariableChecker) { this.append((function(tree) { validateFreeVariables(tree, reporter); return tree; })); } append(AnnotationsTransformer); append(TypeTransformer); }; var $PureES6Transformer = PureES6Transformer; ($traceurRuntime.createClass)(PureES6Transformer, {}, {}, MultiTransformer); return {get PureES6Transformer() { return PureES6Transformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/module/AttachModuleNameTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/module/AttachModuleNameTransformer"; var ParseTreeTransformer = System.get("traceur@0.0.52/src/codegeneration/ParseTreeTransformer").ParseTreeTransformer; var $__736 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), Module = $__736.Module, Script = $__736.Script; var AttachModuleNameTransformer = function AttachModuleNameTransformer(moduleName) { this.moduleName_ = moduleName; }; ($traceurRuntime.createClass)(AttachModuleNameTransformer, { transformModule: function(tree) { return new Module(tree.location, tree.scriptItemList, this.moduleName_); }, transformScript: function(tree) { return new Script(tree.location, tree.scriptItemList, this.moduleName_); } }, {}, ParseTreeTransformer); return {get AttachModuleNameTransformer() { return AttachModuleNameTransformer; }}; }); System.register("traceur@0.0.52/src/util/CollectingErrorReporter", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/util/CollectingErrorReporter"; var ErrorReporter = System.get("traceur@0.0.52/src/util/ErrorReporter").ErrorReporter; var CollectingErrorReporter = function CollectingErrorReporter() { $traceurRuntime.superCall(this, $CollectingErrorReporter.prototype, "constructor", []); this.errors = []; }; var $CollectingErrorReporter = CollectingErrorReporter; ($traceurRuntime.createClass)(CollectingErrorReporter, { reportMessageInternal: function(location, message) { if (location) message = (location + ": " + message); this.errors.push(message); }, errorsAsString: function() { return this.errors.join('\n'); }, toException: function() { return new Error(this.errorsAsString()); } }, {}, ErrorReporter); return {get CollectingErrorReporter() { return CollectingErrorReporter; }}; }); System.register("traceur@0.0.52/src/Compiler", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/Compiler"; var AttachModuleNameTransformer = System.get("traceur@0.0.52/src/codegeneration/module/AttachModuleNameTransformer").AttachModuleNameTransformer; var FromOptionsTransformer = System.get("traceur@0.0.52/src/codegeneration/FromOptionsTransformer").FromOptionsTransformer; var Parser = System.get("traceur@0.0.52/src/syntax/Parser").Parser; var PureES6Transformer = System.get("traceur@0.0.52/src/codegeneration/PureES6Transformer").PureES6Transformer; var SourceFile = System.get("traceur@0.0.52/src/syntax/SourceFile").SourceFile; var SourceMapGenerator = System.get("traceur@0.0.52/src/outputgeneration/SourceMapIntegration").SourceMapGenerator; var CollectingErrorReporter = System.get("traceur@0.0.52/src/util/CollectingErrorReporter").CollectingErrorReporter; var $__747 = System.get("traceur@0.0.52/src/Options"), traceurOptions = $__747.options, versionLockedOptions = $__747.versionLockedOptions; var write = System.get("traceur@0.0.52/src/outputgeneration/TreeWriter").write; function merge() { for (var srcs = [], $__751 = 0; $__751 < arguments.length; $__751++) srcs[$__751] = arguments[$__751]; var dest = Object.create(null); srcs.forEach((function(src) { Object.keys(src).forEach((function(key) { dest[key] = src[key]; })); var srcModules = src.modules; if (typeof srcModules !== 'undefined') { dest.modules = srcModules; } })); return dest; } var Compiler = function Compiler() { var overridingOptions = arguments[0] !== (void 0) ? arguments[0] : {}; this.defaultOptions_ = merge(this.defaultOptions(), overridingOptions); }; ($traceurRuntime.createClass)(Compiler, { script: function(content) { var options = arguments[1] !== (void 0) ? arguments[1] : {}; options.modules = false; return this.compile(content, options); }, module: function(content) { var options = arguments[1] !== (void 0) ? arguments[1] : {}; options.modules = 'register'; return this.compile(content, options); }, compile: function(content) { var options = arguments[1] !== (void 0) ? arguments[1] : {}; var $__749 = this; return this.parse({ content: content, options: options }).then((function(result) { return $__749.transform(result); })).then((function(result) { return $__749.write(result); })); }, stringToString: function(content) { var options = arguments[1] !== (void 0) ? arguments[1] : {}; var output = this.stringToTree({ content: content, options: options }); if (output.errors.length) return output; output = this.treeToTree(output); if (output.errors.length) return output; return this.treeToString(output); }, stringToTree: function($__752) { var $__754; var $__753 = $traceurRuntime.assertObject($__752), content = $__753.content, options = ($__754 = $__753.options) === void 0 ? {} : $__754; var mergedOptions = merge(this.defaultOptions_, options); options = traceurOptions.setFromObject(mergedOptions); var errorReporter = new CollectingErrorReporter(); var sourceFile = new SourceFile(mergedOptions.filename, content); var parser = new Parser(sourceFile, errorReporter); var tree = mergedOptions.modules ? parser.parseModule() : parser.parseScript(); return { tree: tree, options: mergedOptions, errors: errorReporter.errors }; }, parse: function(input) { return this.promise(this.stringToTree, input); }, treeToTree: function($__752) { var $__754 = $traceurRuntime.assertObject($__752), tree = $__754.tree, options = $__754.options; var transformer; if (options.moduleName) { var moduleName = options.moduleName; if (typeof moduleName !== 'string') moduleName = this.resolveModuleName(options.filename); if (moduleName) { transformer = new AttachModuleNameTransformer(moduleName); tree = transformer.transformAny(tree); } } var errorReporter = new CollectingErrorReporter(); if (options.outputLanguage.toLowerCase() === 'es6') { transformer = new PureES6Transformer(errorReporter); } else { transformer = new FromOptionsTransformer(errorReporter); } var transformedTree = transformer.transform(tree); if (errorReporter.hadError()) { return { js: null, errors: errorReporter.errors }; } else { return { tree: transformedTree, options: options, errors: errorReporter.errors }; } }, transform: function(input) { return this.promise(this.treeToTree, input); }, treeToString: function($__752) { var $__754 = $traceurRuntime.assertObject($__752), tree = $__754.tree, options = $__754.options, errors = $__754.errors; var treeWriterOptions = {}; if (options.sourceMaps) { treeWriterOptions.sourceMapGenerator = new SourceMapGenerator({ file: options.filename, sourceRoot: this.sourceRootForFilename(options.filename) }); } return { js: write(tree, treeWriterOptions), errors: errors, generatedSourceMap: treeWriterOptions.generatedSourceMap || null }; }, write: function(input) { return this.promise(this.treeToString, input); }, resolveModuleName: function(filename) { return filename; }, sourceRootForFilename: function(filename) { return filename; }, defaultOptions: function() { return versionLockedOptions; }, promise: function(method, input) { var $__749 = this; return new Promise((function(resolve, reject) { var output = method.call($__749, input); if (output.errors.length) reject(new Error(output.errors.join('\n'))); else resolve(output); })); } }, { amdOptions: function() { var options = arguments[0] !== (void 0) ? arguments[0] : {}; var amdOptions = { modules: 'amd', filename: undefined, sourceMap: false, moduleName: true }; return merge(amdOptions, options); }, commonJSOptions: function() { var options = arguments[0] !== (void 0) ? arguments[0] : {}; var commonjsOptions = { modules: 'commonjs', filename: '', sourceMap: false, moduleName: false }; return merge(commonjsOptions, options); } }); return {get Compiler() { return Compiler; }}; }); System.register("traceur@0.0.52/src/codegeneration/module/ValidationVisitor", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/module/ValidationVisitor"; var ModuleVisitor = System.get("traceur@0.0.52/src/codegeneration/module/ModuleVisitor").ModuleVisitor; var ValidationVisitor = function ValidationVisitor() { $traceurRuntime.defaultSuperCall(this, $ValidationVisitor.prototype, arguments); }; var $ValidationVisitor = ValidationVisitor; ($traceurRuntime.createClass)(ValidationVisitor, { checkExport_: function(tree, name) { var description = this.validatingModuleDescription_; if (description && !description.getExport(name)) { var moduleName = description.normalizedName; this.reportError(tree, ("'" + name + "' is not exported by '" + moduleName + "'")); } }, checkImport_: function(tree, name) { var existingImport = this.moduleSymbol.getImport(name); if (existingImport) { this.reportError(tree, ("'" + name + "' was previously imported at " + existingImport.location.start)); } else { this.moduleSymbol.addImport(name, tree); } }, visitAndValidate_: function(moduleDescription, tree) { var validatingModuleDescription = this.validatingModuleDescription_; this.validatingModuleDescription_ = moduleDescription; this.visitAny(tree); this.validatingModuleDescription_ = validatingModuleDescription; }, visitNamedExport: function(tree) { if (tree.moduleSpecifier) { var name = tree.moduleSpecifier.token.processedValue; var moduleDescription = this.getModuleDescriptionForModuleSpecifier(name); this.visitAndValidate_(moduleDescription, tree.specifierSet); } }, visitExportSpecifier: function(tree) { this.checkExport_(tree, tree.lhs.value); }, visitImportDeclaration: function(tree) { var name = tree.moduleSpecifier.token.processedValue; var moduleDescription = this.getModuleDescriptionForModuleSpecifier(name); this.visitAndValidate_(moduleDescription, tree.importClause); }, visitImportSpecifier: function(tree) { var importName = tree.rhs ? tree.rhs.value : tree.lhs.value; this.checkImport_(tree, importName); this.checkExport_(tree, tree.lhs.value); }, visitImportedBinding: function(tree) { var importName = tree.binding.identifierToken.value; this.checkImport_(tree, importName); this.checkExport_(tree, 'default'); } }, {}, ModuleVisitor); return {get ValidationVisitor() { return ValidationVisitor; }}; }); System.register("traceur@0.0.52/src/codegeneration/module/ExportListBuilder", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/module/ExportListBuilder"; var ExportVisitor = System.get("traceur@0.0.52/src/codegeneration/module/ExportVisitor").ExportVisitor; var ValidationVisitor = System.get("traceur@0.0.52/src/codegeneration/module/ValidationVisitor").ValidationVisitor; var transformOptions = System.get("traceur@0.0.52/src/Options").transformOptions; function buildExportList(deps, loader, reporter) { if (!transformOptions.modules) return; function doVisit(ctor) { for (var i = 0; i < deps.length; i++) { var visitor = new ctor(reporter, loader, deps[i].moduleSymbol); visitor.visitAny(deps[i].tree); } } function reverseVisit(ctor) { for (var i = deps.length - 1; i >= 0; i--) { var visitor = new ctor(reporter, loader, deps[i].moduleSymbol); visitor.visitAny(deps[i].tree); } } reverseVisit(ExportVisitor); doVisit(ValidationVisitor); } return {get buildExportList() { return buildExportList; }}; }); System.register("traceur@0.0.52/src/codegeneration/module/ModuleSpecifierVisitor", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/module/ModuleSpecifierVisitor"; var ParseTreeVisitor = System.get("traceur@0.0.52/src/syntax/ParseTreeVisitor").ParseTreeVisitor; var options = System.get("traceur@0.0.52/src/Options").options; var ModuleSpecifierVisitor = function ModuleSpecifierVisitor() { $traceurRuntime.superCall(this, $ModuleSpecifierVisitor.prototype, "constructor", []); this.moduleSpecifiers_ = Object.create(null); }; var $ModuleSpecifierVisitor = ModuleSpecifierVisitor; ($traceurRuntime.createClass)(ModuleSpecifierVisitor, { get moduleSpecifiers() { return Object.keys(this.moduleSpecifiers_); }, visitModuleSpecifier: function(tree) { this.moduleSpecifiers_[tree.token.processedValue] = true; }, visitVariableDeclaration: function(tree) { this.addTypeAssertionDependency_(tree.typeAnnotation); return $traceurRuntime.superCall(this, $ModuleSpecifierVisitor.prototype, "visitVariableDeclaration", [tree]); }, visitFormalParameter: function(tree) { this.addTypeAssertionDependency_(tree.typeAnnotation); return $traceurRuntime.superCall(this, $ModuleSpecifierVisitor.prototype, "visitFormalParameter", [tree]); }, visitGetAccessor: function(tree) { this.addTypeAssertionDependency_(tree.typeAnnotation); return $traceurRuntime.superCall(this, $ModuleSpecifierVisitor.prototype, "visitGetAccessor", [tree]); }, visitPropertyMethodAssignment: function(tree) { this.addTypeAssertionDependency_(tree.typeAnnotation); return $traceurRuntime.superCall(this, $ModuleSpecifierVisitor.prototype, "visitPropertyMethodAssignment", [tree]); }, visitFunctionDeclaration: function(tree) { this.addTypeAssertionDependency_(tree.typeAnnotation); return $traceurRuntime.superCall(this, $ModuleSpecifierVisitor.prototype, "visitFunctionDeclaration", [tree]); }, visitFunctionExpression: function(tree) { this.addTypeAssertionDependency_(tree.typeAnnotation); return $traceurRuntime.superCall(this, $ModuleSpecifierVisitor.prototype, "visitFunctionExpression", [tree]); }, addTypeAssertionDependency_: function(typeAnnotation) { if (typeAnnotation !== null && options.typeAssertionModule !== null) this.moduleSpecifiers_[options.typeAssertionModule] = true; } }, {}, ParseTreeVisitor); return {get ModuleSpecifierVisitor() { return ModuleSpecifierVisitor; }}; }); System.register("traceur@0.0.52/src/runtime/system-map", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/runtime/system-map"; function prefixMatchLength(name, prefix) { var prefixParts = prefix.split('/'); var nameParts = name.split('/'); if (prefixParts.length > nameParts.length) return 0; for (var i = 0; i < prefixParts.length; i++) { if (nameParts[i] != prefixParts[i]) return 0; } return prefixParts.length; } function applyMap(map, name, parentName) { var curMatch, curMatchLength = 0; var curParent, curParentMatchLength = 0; if (parentName) { var mappedName; Object.getOwnPropertyNames(map).some(function(p) { var curMap = map[p]; if (curMap && typeof curMap === 'object') { if (prefixMatchLength(parentName, p) <= curParentMatchLength) return; Object.getOwnPropertyNames(curMap).forEach(function(q) { if (prefixMatchLength(name, q) > curMatchLength) { curMatch = q; curMatchLength = q.split('/').length; curParent = p; curParentMatchLength = p.split('/').length; } }); } if (curMatch) { var subPath = name.split('/').splice(curMatchLength).join('/'); mappedName = map[curParent][curMatch] + (subPath ? '/' + subPath : ''); return mappedName; } }); } if (mappedName) return mappedName; Object.getOwnPropertyNames(map).forEach(function(p) { var curMap = map[p]; if (curMap && typeof curMap === 'string') { if (prefixMatchLength(name, p) > curMatchLength) { curMatch = p; curMatchLength = p.split('/').length; } } }); if (!curMatch) return name; var subPath = name.split('/').splice(curMatchLength).join('/'); return map[curMatch] + (subPath ? '/' + subPath : ''); } var systemjs = {applyMap: applyMap}; return {get systemjs() { return systemjs; }}; }); System.register("traceur@0.0.52/src/util/url", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/util/url"; var canonicalizeUrl = $traceurRuntime.canonicalizeUrl; var isAbsolute = $traceurRuntime.isAbsolute; var removeDotSegments = $traceurRuntime.removeDotSegments; var resolveUrl = $traceurRuntime.resolveUrl; return { get canonicalizeUrl() { return canonicalizeUrl; }, get isAbsolute() { return isAbsolute; }, get removeDotSegments() { return removeDotSegments; }, get resolveUrl() { return resolveUrl; } }; }); System.register("traceur@0.0.52/src/runtime/webLoader", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/runtime/webLoader"; var webLoader = {load: function(url, callback, errback) { var xhr = new XMLHttpRequest(); xhr.onload = (function() { if (xhr.status == 200 || xhr.status == 0) { callback(xhr.responseText); } else { var err; if (xhr.status === 404) err = 'File not found \'' + url + '\''; else err = xhr.status + xhr.statusText; errback(err); } xhr = null; }); xhr.onerror = (function(err) { errback(err); }); xhr.open('GET', url, true); xhr.send(); return (function() { xhr && xhr.abort(); }); }}; return {get webLoader() { return webLoader; }}; }); System.register("traceur@0.0.52/src/runtime/LoaderHooks", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/runtime/LoaderHooks"; var AttachModuleNameTransformer = System.get("traceur@0.0.52/src/codegeneration/module/AttachModuleNameTransformer").AttachModuleNameTransformer; var FromOptionsTransformer = System.get("traceur@0.0.52/src/codegeneration/FromOptionsTransformer").FromOptionsTransformer; var buildExportList = System.get("traceur@0.0.52/src/codegeneration/module/ExportListBuilder").buildExportList; var CollectingErrorReporter = System.get("traceur@0.0.52/src/util/CollectingErrorReporter").CollectingErrorReporter; var ModuleSpecifierVisitor = System.get("traceur@0.0.52/src/codegeneration/module/ModuleSpecifierVisitor").ModuleSpecifierVisitor; var ModuleSymbol = System.get("traceur@0.0.52/src/codegeneration/module/ModuleSymbol").ModuleSymbol; var Parser = System.get("traceur@0.0.52/src/syntax/Parser").Parser; var options = System.get("traceur@0.0.52/src/Options").options; var SourceFile = System.get("traceur@0.0.52/src/syntax/SourceFile").SourceFile; var systemjs = System.get("traceur@0.0.52/src/runtime/system-map").systemjs; var UniqueIdentifierGenerator = System.get("traceur@0.0.52/src/codegeneration/UniqueIdentifierGenerator").UniqueIdentifierGenerator; var $__774 = System.get("traceur@0.0.52/src/util/url"), isAbsolute = $__774.isAbsolute, resolveUrl = $__774.resolveUrl; var webLoader = System.get("traceur@0.0.52/src/runtime/webLoader").webLoader; var assert = System.get("traceur@0.0.52/src/util/assert").assert; var NOT_STARTED = 0; var LOADING = 1; var LOADED = 2; var PARSED = 3; var TRANSFORMING = 4; var TRANSFORMED = 5; var COMPLETE = 6; var ERROR = 7; var identifierGenerator = new UniqueIdentifierGenerator(); var LoaderHooks = function LoaderHooks(reporter, baseURL) { var fileLoader = arguments[2] !== (void 0) ? arguments[2] : webLoader; var moduleStore = arguments[3] !== (void 0) ? arguments[3] : $traceurRuntime.ModuleStore; this.baseURL_ = baseURL; this.moduleStore_ = moduleStore; this.fileLoader = fileLoader; }; ($traceurRuntime.createClass)(LoaderHooks, { get: function(normalizedName) { return this.moduleStore_.get(normalizedName); }, set: function(normalizedName, module) { this.moduleStore_.set(normalizedName, module); }, normalize: function(name, referrerName, referrerAddress) { var normalizedName = this.moduleStore_.normalize(name, referrerName, referrerAddress); if (System.map) return systemjs.applyMap(System.map, normalizedName, referrerName); else return normalizedName; }, get baseURL() { return this.baseURL_; }, set baseURL(value) { this.baseURL_ = String(value); }, getModuleSpecifiers: function(codeUnit) { this.parse(codeUnit); codeUnit.state = PARSED; var moduleSpecifierVisitor = new ModuleSpecifierVisitor(); moduleSpecifierVisitor.visit(codeUnit.metadata.tree); return moduleSpecifierVisitor.moduleSpecifiers; }, parse: function(codeUnit) { assert(!codeUnit.metadata.tree); var reporter = new CollectingErrorReporter(); var normalizedName = codeUnit.normalizedName; var program = codeUnit.source; var url = codeUnit.url || normalizedName; var file = new SourceFile(url, program); this.checkForErrors((function(reporter) { var parser = new Parser(file, reporter); if (codeUnit.type == 'module') codeUnit.metadata.tree = parser.parseModule(); else codeUnit.metadata.tree = parser.parseScript(); })); codeUnit.metadata.moduleSymbol = new ModuleSymbol(codeUnit.metadata.tree, normalizedName); }, transform: function(codeUnit) { var transformer = new AttachModuleNameTransformer(codeUnit.normalizedName); var transformedTree = transformer.transformAny(codeUnit.metadata.tree); return this.checkForErrors((function(reporter) { transformer = new FromOptionsTransformer(reporter, identifierGenerator); return transformer.transform(transformedTree); })); }, fetch: function(load) { var $__777 = this; return new Promise((function(resolve, reject) { if (!load) reject(new TypeError('fetch requires argument object')); else if (!load.address || typeof load.address !== 'string') reject(new TypeError('fetch({address}) missing required string.')); else $__777.fileLoader.load(load.address, resolve, reject); })); }, translate: function(load) { return new Promise((function(resolve, reject) { resolve(load.source); })); }, instantiate: function($__779) { var $__780 = $traceurRuntime.assertObject($__779), name = $__780.name, metadata = $__780.metadata, address = $__780.address, source = $__780.source, sourceMap = $__780.sourceMap; return new Promise((function(resolve, reject) { resolve(undefined); })); }, locate: function(load) { load.url = this.locate_(load); return load.url; }, locate_: function(load) { var normalizedModuleName = load.normalizedName; var asJS; if (load.type === 'script') { asJS = normalizedModuleName; } else { asJS = normalizedModuleName + '.js'; } if (options.referrer) { if (asJS.indexOf(options.referrer) === 0) { asJS = asJS.slice(options.referrer.length); load.metadata.locateMap = { pattern: options.referrer, replacement: '' }; } } if (isAbsolute(asJS)) return asJS; var baseURL = load.metadata && load.metadata.baseURL; baseURL = baseURL || this.baseURL; if (baseURL) { load.metadata.baseURL = baseURL; return resolveUrl(baseURL, asJS); } return asJS; }, nameTrace: function(load) { var trace = ''; if (load.metadata.locateMap) { trace += this.locateMapTrace(load); } var base = load.metadata.baseURL || this.baseURL; if (base) { trace += this.baseURLTrace(base); } else { trace += 'No baseURL\n'; } return trace; }, locateMapTrace: function(load) { var map = load.metadata.locateMap; return ("LoaderHooks.locate found \'" + map.pattern + "\' -> \'" + map.replacement + "\'\n"); }, baseURLTrace: function(base) { return 'LoaderHooks.locate resolved against base \'' + base + '\'\n'; }, evaluateCodeUnit: function(codeUnit) { var result = ('global', eval)(codeUnit.metadata.transcoded); codeUnit.metadata.transformedTree = null; return result; }, analyzeDependencies: function(dependencies, loader) { var deps = []; for (var i = 0; i < dependencies.length; i++) { var codeUnit = dependencies[i]; assert(codeUnit.state >= PARSED); if (codeUnit.state == PARSED) { deps.push(codeUnit.metadata); } } this.checkForErrors((function(reporter) { return buildExportList(deps, loader, reporter); })); }, bundledModule: function(name) { return this.moduleStore_.bundleStore[name]; }, checkForErrors: function(fncOfReporter) { var reporter = new CollectingErrorReporter(); var result = fncOfReporter(reporter); if (reporter.hadError()) throw reporter.toException(); return result; } }, {}); return {get LoaderHooks() { return LoaderHooks; }}; }); System.register("traceur@0.0.52/src/runtime/InterceptOutputLoaderHooks", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/runtime/InterceptOutputLoaderHooks"; var LoaderHooks = System.get("traceur@0.0.52/src/runtime/LoaderHooks").LoaderHooks; var InterceptOutputLoaderHooks = function InterceptOutputLoaderHooks() { for (var args = [], $__783 = 0; $__783 < arguments.length; $__783++) args[$__783] = arguments[$__783]; $traceurRuntime.superCall(this, $InterceptOutputLoaderHooks.prototype, "constructor", $traceurRuntime.spread(args)); this.sourceMap = null; this.transcoded = null; this.onTranscoded = (function() {}); }; var $InterceptOutputLoaderHooks = InterceptOutputLoaderHooks; ($traceurRuntime.createClass)(InterceptOutputLoaderHooks, {instantiate: function($__784) { var $__785 = $traceurRuntime.assertObject($__784), metadata = $__785.metadata, url = $__785.url; this.sourceMap = metadata.sourceMap; this.transcoded = metadata.transcoded; this.onTranscoded(metadata, url); return undefined; }}, {}, LoaderHooks); return {get InterceptOutputLoaderHooks() { return InterceptOutputLoaderHooks; }}; }); System.register("traceur@0.0.52/src/runtime/InternalLoader", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/runtime/InternalLoader"; var LoaderHooks = System.get("traceur@0.0.52/src/runtime/LoaderHooks").LoaderHooks; var Map = System.get("traceur@0.0.52/src/runtime/polyfills/Map").Map; var $__788 = System.get("traceur@0.0.52/src/util/url"), isAbsolute = $__788.isAbsolute, resolveUrl = $__788.resolveUrl; var options = System.get("traceur@0.0.52/src/Options").options; var toSource = System.get("traceur@0.0.52/src/outputgeneration/toSource").toSource; var NOT_STARTED = 0; var LOADING = 1; var LOADED = 2; var PARSED = 3; var TRANSFORMING = 4; var TRANSFORMED = 5; var COMPLETE = 6; var ERROR = 7; function mapToValues(map) { var array = []; map.forEach((function(v) { array.push(v); })); return array; } var CodeUnit = function CodeUnit(loaderHooks, normalizedName, type, state, name, referrerName, address) { var $__791 = this; this.promise = new Promise((function(res, rej) { $__791.loaderHooks = loaderHooks; $__791.normalizedName = normalizedName; $__791.type = type; $__791.name_ = name; $__791.referrerName_ = referrerName; $__791.address = address; $__791.url = InternalLoader.uniqueName(normalizedName, address); $__791.state_ = state || NOT_STARTED; $__791.error = null; $__791.result = null; $__791.data_ = {}; $__791.dependencies = []; $__791.resolve = res; $__791.reject = rej; })); }; ($traceurRuntime.createClass)(CodeUnit, { get state() { return this.state_; }, set state(state) { if (state < this.state_) { throw new Error('Invalid state change'); } this.state_ = state; }, get metadata() { return this.data_; }, nameTrace: function() { var trace = this.specifiedAs(); if (isAbsolute(this.name_)) { return trace + 'An absolute name.\n'; } if (this.referrerName_) { return trace + this.importedBy() + this.normalizesTo(); } return trace + this.normalizesTo(); }, specifiedAs: function() { return ("Specified as " + this.name_ + ".\n"); }, importedBy: function() { return ("Imported by " + this.referrerName_ + ".\n"); }, normalizesTo: function() { return 'Normalizes to ' + this.normalizedName + '\n'; }, transform: function() { return this.loaderHooks.transform(this); }, instantiate: function(load) { return this.loaderHooks.instantiate(this); } }, {}); var PreCompiledCodeUnit = function PreCompiledCodeUnit(loaderHooks, normalizedName, name, referrerName, address, module) { $traceurRuntime.superCall(this, $PreCompiledCodeUnit.prototype, "constructor", [loaderHooks, normalizedName, 'module', COMPLETE, name, referrerName, address]); this.result = module; this.resolve(this.result); }; var $PreCompiledCodeUnit = PreCompiledCodeUnit; ($traceurRuntime.createClass)(PreCompiledCodeUnit, {}, {}, CodeUnit); var BundledCodeUnit = function BundledCodeUnit(loaderHooks, normalizedName, name, referrerName, address, deps, execute) { $traceurRuntime.superCall(this, $BundledCodeUnit.prototype, "constructor", [loaderHooks, normalizedName, 'module', TRANSFORMED, name, referrerName, address]); this.deps = deps; this.execute = execute; }; var $BundledCodeUnit = BundledCodeUnit; ($traceurRuntime.createClass)(BundledCodeUnit, { getModuleSpecifiers: function() { return this.deps; }, evaluate: function() { var $__791 = this; var normalizedNames = this.deps.map((function(name) { return $__791.loaderHooks.normalize(name); })); var module = this.execute.apply(Reflect.global, normalizedNames); System.set(this.normalizedName, module); return module; } }, {}, CodeUnit); var HookedCodeUnit = function HookedCodeUnit() { $traceurRuntime.defaultSuperCall(this, $HookedCodeUnit.prototype, arguments); }; var $HookedCodeUnit = HookedCodeUnit; ($traceurRuntime.createClass)(HookedCodeUnit, { getModuleSpecifiers: function() { return this.loaderHooks.getModuleSpecifiers(this); }, evaluate: function() { return this.loaderHooks.evaluateCodeUnit(this); } }, {}, CodeUnit); var LoadCodeUnit = function LoadCodeUnit(loaderHooks, normalizedName, name, referrerName, address) { $traceurRuntime.superCall(this, $LoadCodeUnit.prototype, "constructor", [loaderHooks, normalizedName, 'module', NOT_STARTED, name, referrerName, address]); }; var $LoadCodeUnit = LoadCodeUnit; ($traceurRuntime.createClass)(LoadCodeUnit, {}, {}, HookedCodeUnit); var EvalCodeUnit = function EvalCodeUnit(loaderHooks, code) { var type = arguments[2] !== (void 0) ? arguments[2] : 'script'; var normalizedName = arguments[3]; var referrerName = arguments[4]; var address = arguments[5]; $traceurRuntime.superCall(this, $EvalCodeUnit.prototype, "constructor", [loaderHooks, normalizedName, type, LOADED, null, referrerName, address]); this.source = code; }; var $EvalCodeUnit = EvalCodeUnit; ($traceurRuntime.createClass)(EvalCodeUnit, {}, {}, HookedCodeUnit); var uniqueNameCount = 0; var InternalLoader = function InternalLoader(loaderHooks) { this.loaderHooks = loaderHooks; this.cache = new Map(); this.urlToKey = Object.create(null); this.sync_ = false; }; ($traceurRuntime.createClass)(InternalLoader, { load: function(name) { var referrerName = arguments[1] !== (void 0) ? arguments[1] : this.loaderHooks.baseURL; var address = arguments[2]; var type = arguments[3] !== (void 0) ? arguments[3] : 'script'; var codeUnit = this.load_(name, referrerName, address, type); return codeUnit.promise.then((function() { return codeUnit; })); }, load_: function(name, referrerName, address, type) { var $__791 = this; var codeUnit = this.getCodeUnit_(name, referrerName, address, type); if (codeUnit.state === ERROR) { return codeUnit; } if (codeUnit.state === TRANSFORMED) { this.handleCodeUnitLoaded(codeUnit); } else { if (codeUnit.state !== NOT_STARTED) return codeUnit; codeUnit.state = LOADING; codeUnit.address = this.loaderHooks.locate(codeUnit); this.loaderHooks.fetch(codeUnit).then((function(text) { codeUnit.source = text; return codeUnit; })).then(this.loaderHooks.translate.bind(this.loaderHooks)).then((function(source) { codeUnit.source = source; codeUnit.state = LOADED; $__791.handleCodeUnitLoaded(codeUnit); return codeUnit; })).catch((function(err) { try { codeUnit.state = ERROR; codeUnit.error = err; $__791.handleCodeUnitLoadError(codeUnit); } catch (ex) { console.error('Internal Error ' + (ex.stack || ex)); } })); } return codeUnit; }, module: function(code, referrerName, address) { var codeUnit = new EvalCodeUnit(this.loaderHooks, code, 'module', null, referrerName, address); this.cache.set({}, codeUnit); this.handleCodeUnitLoaded(codeUnit); return codeUnit.promise; }, define: function(normalizedName, code, address) { var codeUnit = new EvalCodeUnit(this.loaderHooks, code, 'module', normalizedName, null, address); var key = this.getKey(normalizedName, 'module'); this.cache.set(key, codeUnit); this.handleCodeUnitLoaded(codeUnit); return codeUnit.promise; }, script: function(code, name, referrerName, address) { var normalizedName = System.normalize(name || '', referrerName, address); var codeUnit = new EvalCodeUnit(this.loaderHooks, code, 'script', normalizedName, referrerName, address); var key = {}; if (name) key = this.getKey(normalizedName, 'script'); this.cache.set(key, codeUnit); this.handleCodeUnitLoaded(codeUnit); return codeUnit.promise; }, sourceMapInfo: function(normalizedName, type) { var key = this.getKey(normalizedName, type); var codeUnit = this.cache.get(key); return { sourceMap: codeUnit && codeUnit.metadata && codeUnit.metadata.sourceMap, url: codeUnit && codeUnit.url }; }, getKey: function(url, type) { var combined = type + ':' + url; if (combined in this.urlToKey) { return this.urlToKey[combined]; } return this.urlToKey[combined] = {}; }, getCodeUnit_: function(name, referrerName, address, type) { var normalizedName = System.normalize(name, referrerName, address); var key = this.getKey(normalizedName, type); var cacheObject = this.cache.get(key); if (!cacheObject) { var module = this.loaderHooks.get(normalizedName); if (module) { cacheObject = new PreCompiledCodeUnit(this.loaderHooks, normalizedName, name, referrerName, address, module); cacheObject.type = 'module'; } else { var bundledModule = this.loaderHooks.bundledModule(name); if (bundledModule) { cacheObject = new BundledCodeUnit(this.loaderHooks, normalizedName, name, referrerName, address, bundledModule.deps, bundledModule.execute); } else { cacheObject = new LoadCodeUnit(this.loaderHooks, normalizedName, name, referrerName, address); cacheObject.type = type; } } this.cache.set(key, cacheObject); } return cacheObject; }, areAll: function(state) { return mapToValues(this.cache).every((function(codeUnit) { return codeUnit.state >= state; })); }, getCodeUnitForModuleSpecifier: function(name, referrerName) { return this.getCodeUnit_(name, referrerName, null, 'module'); }, handleCodeUnitLoaded: function(codeUnit) { var $__791 = this; var referrerName = codeUnit.normalizedName; try { var moduleSpecifiers = codeUnit.getModuleSpecifiers(); if (!moduleSpecifiers) { this.abortAll(("No module specifiers in " + referrerName)); return; } codeUnit.dependencies = moduleSpecifiers.sort().map((function(name) { return $__791.getCodeUnit_(name, referrerName, null, 'module'); })); } catch (error) { this.rejectOneAndAll(codeUnit, error); return; } codeUnit.dependencies.forEach((function(dependency) { $__791.load(dependency.normalizedName, null, null, 'module'); })); if (this.areAll(PARSED)) { try { this.analyze(); this.transform(); this.evaluate(); } catch (error) { this.rejectOneAndAll(codeUnit, error); } } }, rejectOneAndAll: function(codeUnit, error) { codeUnit.state.ERROR; codeUnit.error = error; codeUnit.reject(error); this.abortAll(error); }, handleCodeUnitLoadError: function(codeUnit) { var message = codeUnit.error ? String(codeUnit.error) + '\n' : ("Failed to load '" + codeUnit.address + "'.\n"); message += codeUnit.nameTrace() + this.loaderHooks.nameTrace(codeUnit); this.rejectOneAndAll(codeUnit, new Error(message)); }, abortAll: function(errorMessage) { this.cache.forEach((function(codeUnit) { if (codeUnit.state !== ERROR) codeUnit.reject(errorMessage); })); }, analyze: function() { this.loaderHooks.analyzeDependencies(mapToValues(this.cache), this); }, transform: function() { this.transformDependencies_(mapToValues(this.cache)); }, transformDependencies_: function(dependencies, dependentName) { for (var i = 0; i < dependencies.length; i++) { var codeUnit = dependencies[i]; if (codeUnit.state >= TRANSFORMED) { continue; } if (codeUnit.state === TRANSFORMING) { var cir = codeUnit.normalizedName; var cle = dependentName; this.rejectOneAndAll(codeUnit, new Error(("Unsupported circular dependency between " + cir + " and " + cle))); return; } codeUnit.state = TRANSFORMING; try { this.transformCodeUnit_(codeUnit); } catch (error) { this.rejectOneAndAll(codeUnit, error); return; } } }, transformCodeUnit_: function(codeUnit) { var $__793; this.transformDependencies_(codeUnit.dependencies, codeUnit.normalizedName); if (codeUnit.state === ERROR) return; var metadata = codeUnit.metadata; metadata.transformedTree = codeUnit.transform(); codeUnit.state = TRANSFORMED; var filename = codeUnit.address || codeUnit.normalizedName; ($__793 = $traceurRuntime.assertObject(toSource(metadata.transformedTree, options, filename)), metadata.transcoded = $__793[0], metadata.sourceMap = $__793[1], $__793); if (codeUnit.address && metadata.transcoded) metadata.transcoded += '//# sourceURL=' + codeUnit.address; codeUnit.instantiate(); }, orderDependencies: function() { var visited = new Map(); var ordered = []; function orderCodeUnits(codeUnit) { if (visited.has(codeUnit)) { return; } visited.set(codeUnit, true); codeUnit.dependencies.forEach(orderCodeUnits); ordered.push(codeUnit); } this.cache.forEach(orderCodeUnits); return ordered; }, evaluate: function() { var dependencies = this.orderDependencies(); for (var i = 0; i < dependencies.length; i++) { var codeUnit = dependencies[i]; if (codeUnit.state >= COMPLETE) { continue; } var result; try { result = codeUnit.evaluate(); } catch (ex) { this.rejectOneAndAll(codeUnit, ex); return; } codeUnit.result = result; codeUnit.source = null; } for (var i = 0; i < dependencies.length; i++) { var codeUnit = dependencies[i]; if (codeUnit.state >= COMPLETE) { continue; } codeUnit.state = COMPLETE; codeUnit.resolve(codeUnit.result); } } }, {uniqueName: function(normalizedName, referrerAddress) { var importerAddress = referrerAddress || System.baseURL; if (!importerAddress) throw new Error('The System.baseURL is an empty string'); var path = normalizedName || String(uniqueNameCount++); return resolveUrl(importerAddress, path); }}); var SystemLoaderHooks = LoaderHooks; var internals = { CodeUnit: CodeUnit, EvalCodeUnit: EvalCodeUnit, LoadCodeUnit: LoadCodeUnit, LoaderHooks: LoaderHooks }; return { get InternalLoader() { return InternalLoader; }, get internals() { return internals; } }; }); System.register("traceur@0.0.52/src/runtime/Loader", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/runtime/Loader"; var InternalLoader = System.get("traceur@0.0.52/src/runtime/InternalLoader").InternalLoader; var Loader = function Loader(loaderHooks) { this.internalLoader_ = new InternalLoader(loaderHooks); this.loaderHooks_ = loaderHooks; }; ($traceurRuntime.createClass)(Loader, { import: function(name) { var $__797 = $traceurRuntime.assertObject(arguments[1] !== (void 0) ? arguments[1] : {}), referrerName = $__797.referrerName, address = $__797.address; var $__795 = this; return this.internalLoader_.load(name, referrerName, address, 'module').then((function(codeUnit) { return $__795.get(codeUnit.normalizedName); })); }, module: function(source) { var $__797 = $traceurRuntime.assertObject(arguments[1] !== (void 0) ? arguments[1] : {}), referrerName = $__797.referrerName, address = $__797.address; return this.internalLoader_.module(source, referrerName, address); }, define: function(normalizedName, source) { var $__797 = $traceurRuntime.assertObject(arguments[2] !== (void 0) ? arguments[2] : {}), address = $__797.address, metadata = $__797.metadata; return this.internalLoader_.define(normalizedName, source, address, metadata); }, get: function(normalizedName) { return this.loaderHooks_.get(normalizedName); }, set: function(normalizedName, module) { this.loaderHooks_.set(normalizedName, module); }, normalize: function(name, referrerName, referrerAddress) { return this.loaderHooks_.normalize(name, referrerName, referrerAddress); }, locate: function(load) { return this.loaderHooks_.locate(load); }, fetch: function(load) { return this.loaderHooks_.fetch(load); }, translate: function(load) { return this.loaderHooks_.translate(load); }, instantiate: function(load) { return this.loaderHooks_.instantiate(load); } }, {}); ; return { get Loader() { return Loader; }, get LoaderHooks() { return LoaderHooks; } }; }); System.register("traceur@0.0.52/src/WebPageTranscoder", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/WebPageTranscoder"; var Loader = System.get("traceur@0.0.52/src/runtime/Loader").Loader; var ErrorReporter = System.get("traceur@0.0.52/src/util/ErrorReporter").ErrorReporter; var InterceptOutputLoaderHooks = System.get("traceur@0.0.52/src/runtime/InterceptOutputLoaderHooks").InterceptOutputLoaderHooks; var webLoader = System.get("traceur@0.0.52/src/runtime/webLoader").webLoader; var WebPageTranscoder = function WebPageTranscoder(url) { this.url = url; this.numPending_ = 0; this.numberInlined_ = 0; }; ($traceurRuntime.createClass)(WebPageTranscoder, { asyncLoad_: function(url, fncOfContent, onScriptsReady) { var $__802 = this; this.numPending_++; webLoader.load(url, (function(content) { if (content) fncOfContent(content); else console.warn('Failed to load', url); if (--$__802.numPending_ <= 0) onScriptsReady(); }), (function(error) { console.error('WebPageTranscoder FAILED to load ' + url, error.stack || error); })); }, addFileFromScriptElement: function(scriptElement, name, content) { var nameInfo = { address: name, referrerName: window.location.href }; this.loader.module(content, nameInfo).catch(function(error) { console.error(error.stack || error); }); }, nextInlineScriptName_: function() { this.numberInlined_ += 1; if (!this.inlineScriptNameBase_) { var segments = this.url.split('.'); segments.pop(); this.inlineScriptNameBase_ = segments.join('.'); } return this.inlineScriptNameBase_ + '_' + this.numberInlined_ + '.js'; }, addFilesFromScriptElements: function(scriptElements, onScriptsReady) { for (var i = 0, length = scriptElements.length; i < length; i++) { var scriptElement = scriptElements[i]; if (!scriptElement.src) { var name = this.nextInlineScriptName_(); var content = scriptElement.textContent; this.addFileFromScriptElement(scriptElement, name, content); } else { var name = scriptElement.src; this.asyncLoad_(name, this.addFileFromScriptElement.bind(this, scriptElement, name), onScriptsReady); } } if (this.numPending_ <= 0) onScriptsReady(); }, get reporter() { if (!this.reporter_) { this.reporter_ = new ErrorReporter(); } return this.reporter_; }, get loader() { if (!this.loader_) { var loaderHooks = new InterceptOutputLoaderHooks(this.reporter, this.url); this.loader_ = new Loader(loaderHooks); } return this.loader_; }, putFile: function(file) { var scriptElement = document.createElement('script'); scriptElement.setAttribute('data-traceur-src-url', file.name); scriptElement.textContent = file.generatedSource; var parent = file.scriptElement.parentNode; parent.insertBefore(scriptElement, file.scriptElement || null); }, selectAndProcessScripts: function(done) { var selector = 'script[type="module"]'; var scripts = document.querySelectorAll(selector); if (!scripts.length) { done(); return; } this.addFilesFromScriptElements(scripts, (function() { done(); })); }, run: function() { var done = arguments[0] !== (void 0) ? arguments[0] : (function() {}); var $__802 = this; var ready = document.readyState; if (ready === 'complete' || ready === 'loaded') { this.selectAndProcessScripts(done); } else { document.addEventListener('DOMContentLoaded', (function() { return $__802.selectAndProcessScripts(done); }), false); } } }, {}); return {get WebPageTranscoder() { return WebPageTranscoder; }}; }); System.register("traceur@0.0.52/src/codegeneration/CloneTreeTransformer", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/CloneTreeTransformer"; var ParseTreeTransformer = System.get("traceur@0.0.52/src/codegeneration/ParseTreeTransformer").ParseTreeTransformer; var $__805 = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees"), BindingIdentifier = $__805.BindingIdentifier, BreakStatement = $__805.BreakStatement, ContinueStatement = $__805.ContinueStatement, DebuggerStatement = $__805.DebuggerStatement, EmptyStatement = $__805.EmptyStatement, ExportSpecifier = $__805.ExportSpecifier, ExportStar = $__805.ExportStar, IdentifierExpression = $__805.IdentifierExpression, ImportSpecifier = $__805.ImportSpecifier, LiteralExpression = $__805.LiteralExpression, ModuleSpecifier = $__805.ModuleSpecifier, PredefinedType = $__805.PredefinedType, PropertyNameShorthand = $__805.PropertyNameShorthand, TemplateLiteralPortion = $__805.TemplateLiteralPortion, SuperExpression = $__805.SuperExpression, ThisExpression = $__805.ThisExpression; var CloneTreeTransformer = function CloneTreeTransformer() { $traceurRuntime.defaultSuperCall(this, $CloneTreeTransformer.prototype, arguments); }; var $CloneTreeTransformer = CloneTreeTransformer; ($traceurRuntime.createClass)(CloneTreeTransformer, { transformBindingIdentifier: function(tree) { return new BindingIdentifier(tree.location, tree.identifierToken); }, transformBreakStatement: function(tree) { return new BreakStatement(tree.location, tree.name); }, transformContinueStatement: function(tree) { return new ContinueStatement(tree.location, tree.name); }, transformDebuggerStatement: function(tree) { return new DebuggerStatement(tree.location); }, transformEmptyStatement: function(tree) { return new EmptyStatement(tree.location); }, transformExportSpecifier: function(tree) { return new ExportSpecifier(tree.location, tree.lhs, tree.rhs); }, transformExportStar: function(tree) { return new ExportStar(tree.location); }, transformIdentifierExpression: function(tree) { return new IdentifierExpression(tree.location, tree.identifierToken); }, transformImportSpecifier: function(tree) { return new ImportSpecifier(tree.location, tree.lhs, tree.rhs); }, transformList: function(list) { if (!list) { return null; } else if (list.length == 0) { return []; } else { return $traceurRuntime.superCall(this, $CloneTreeTransformer.prototype, "transformList", [list]); } }, transformLiteralExpression: function(tree) { return new LiteralExpression(tree.location, tree.literalToken); }, transformModuleSpecifier: function(tree) { return new ModuleSpecifier(tree.location, tree.token); }, transformPredefinedType: function(tree) { return new PredefinedType(tree.location, tree.typeToken); }, transformPropertyNameShorthand: function(tree) { return new PropertyNameShorthand(tree.location, tree.name); }, transformTemplateLiteralPortion: function(tree) { return new TemplateLiteralPortion(tree.location, tree.value); }, transformSuperExpression: function(tree) { return new SuperExpression(tree.location); }, transformThisExpression: function(tree) { return new ThisExpression(tree.location); } }, {}, ParseTreeTransformer); CloneTreeTransformer.cloneTree = function(tree) { return new CloneTreeTransformer().transformAny(tree); }; return {get CloneTreeTransformer() { return CloneTreeTransformer; }}; }); System.register("traceur@0.0.52/src/codegeneration/module/createModuleEvaluationStatement", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/codegeneration/module/createModuleEvaluationStatement"; var $__807 = Object.freeze(Object.defineProperties(["System.get(", " +'')"], {raw: {value: Object.freeze(["System.get(", " +'')"])}})); var parseStatement = System.get("traceur@0.0.52/src/codegeneration/PlaceholderParser").parseStatement; function createModuleEvaluationStatement(normalizedName) { return parseStatement($__807, normalizedName); } return {get createModuleEvaluationStatement() { return createModuleEvaluationStatement; }}; }); System.register("traceur@0.0.52/src/runtime/InlineLoaderHooks", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/runtime/InlineLoaderHooks"; var LoaderHooks = System.get("traceur@0.0.52/src/runtime/LoaderHooks").LoaderHooks; var Script = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees").Script; var InlineLoaderHooks = function InlineLoaderHooks(url, elements, fileLoader, moduleStore) { $traceurRuntime.superCall(this, $InlineLoaderHooks.prototype, "constructor", [null, url, fileLoader, moduleStore]); this.elements = elements; }; var $InlineLoaderHooks = InlineLoaderHooks; ($traceurRuntime.createClass)(InlineLoaderHooks, { evaluateCodeUnit: function(codeUnit) { var $__812; var tree = codeUnit.metadata.transformedTree; ($__812 = this.elements).push.apply($__812, $traceurRuntime.spread(tree.scriptItemList)); }, toTree: function() { return new Script(null, this.elements); } }, {}, LoaderHooks); return {get InlineLoaderHooks() { return InlineLoaderHooks; }}; }); System.register("traceur@0.0.52/src/runtime/TraceurLoader", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/runtime/TraceurLoader"; var Loader = System.get("traceur@0.0.52/src/runtime/Loader").Loader; var version = __moduleName.slice(0, __moduleName.indexOf('/')); var TraceurLoader = function TraceurLoader(loaderHooks) { if (loaderHooks.translateSynchronous) { loaderHooks.translate = function(load) { return new Promise((function(resolve, reject) { resolve(loaderHooks.translateSynchronous(load)); })); }; } $traceurRuntime.superCall(this, $TraceurLoader.prototype, "constructor", [loaderHooks]); }; var $TraceurLoader = TraceurLoader; ($traceurRuntime.createClass)(TraceurLoader, { importAll: function(names) { var $__816 = $traceurRuntime.assertObject(arguments[1] !== (void 0) ? arguments[1] : {}), referrerName = $__816.referrerName, address = $__816.address; var $__814 = this; return Promise.all(names.map((function(name) { return $__814.import(name, { referrerName: referrerName, address: address }); }))); }, loadAsScript: function(name) { var $__816 = $traceurRuntime.assertObject(arguments[1] !== (void 0) ? arguments[1] : {}), referrerName = $__816.referrerName, address = $__816.address; return this.internalLoader_.load(name, referrerName, address, 'script').then((function(codeUnit) { return codeUnit.result; })); }, loadAsScriptAll: function(names) { var $__816 = $traceurRuntime.assertObject(arguments[1] !== (void 0) ? arguments[1] : {}), referrerName = $__816.referrerName, address = $__816.address; var $__814 = this; return Promise.all(names.map((function(name) { return $__814.loadAsScript(name, { referrerName: referrerName, address: address }); }))); }, script: function(source) { var $__816 = $traceurRuntime.assertObject(arguments[1] !== (void 0) ? arguments[1] : {}), name = $__816.name, referrerName = $__816.referrerName, address = $__816.address; return this.internalLoader_.script(source, name, referrerName, address); }, semVerRegExp_: function() { return /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+)?$/; }, semverMap: function(normalizedName) { var slash = normalizedName.indexOf('/'); var version = normalizedName.slice(0, slash); var at = version.indexOf('@'); if (at !== -1) { var semver = version.slice(at + 1); var m = this.semVerRegExp_().exec(semver); if (m) { var major = m[1]; var minor = m[2]; var packageName = version.slice(0, at); var map = Object.create(null); map[packageName] = version; map[packageName + '@' + major] = version; map[packageName + '@' + major + '.' + minor] = version; } } return map; }, get version() { return version; }, sourceMapInfo: function(normalizedName, type) { return this.internalLoader_.sourceMapInfo(normalizedName, type); }, register: function(normalizedName, deps, factoryFunction) { $traceurRuntime.ModuleStore.register(normalizedName, deps, factoryFunction); }, get baseURL() { return this.loaderHooks_.baseURL; }, set baseURL(value) { this.loaderHooks_.baseURL = value; } }, {}, Loader); return {get TraceurLoader() { return TraceurLoader; }}; }); System.register("traceur@0.0.52/src/runtime/System", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/runtime/System"; var ErrorReporter = System.get("traceur@0.0.52/src/util/ErrorReporter").ErrorReporter; var TraceurLoader = System.get("traceur@0.0.52/src/runtime/TraceurLoader").TraceurLoader; var LoaderHooks = System.get("traceur@0.0.52/src/runtime/LoaderHooks").LoaderHooks; var webLoader = System.get("traceur@0.0.52/src/runtime/webLoader").webLoader; var url; var fileLoader; if (typeof window !== 'undefined' && window.location) { url = window.location.href; fileLoader = webLoader; } var loaderHooks = new LoaderHooks(new ErrorReporter(), url, fileLoader); var traceurLoader = new TraceurLoader(loaderHooks); Reflect.global.System = traceurLoader; ; traceurLoader.map = traceurLoader.semverMap(__moduleName); return {get System() { return traceurLoader; }}; }); System.register("traceur@0.0.52/src/traceur", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/traceur"; System.get("traceur@0.0.52/src/runtime/System"); var $___64_traceur_47_src_47_runtime_47_ModuleStore__ = System.get("@traceur/src/runtime/ModuleStore"); ; var $__traceur_64_0_46_0_46_52_47_src_47_WebPageTranscoder__ = System.get("traceur@0.0.52/src/WebPageTranscoder"); var $__traceur_64_0_46_0_46_52_47_src_47_Options__ = System.get("traceur@0.0.52/src/Options"); var $__821 = System.get("traceur@0.0.52/src/Options"), addOptions = $__821.addOptions, CommandOptions = $__821.CommandOptions; var $__traceur_64_0_46_0_46_52_47_src_47_Compiler__ = System.get("traceur@0.0.52/src/Compiler"); var ErrorReporter = System.get("traceur@0.0.52/src/util/ErrorReporter").ErrorReporter; var CollectingErrorReporter = System.get("traceur@0.0.52/src/util/CollectingErrorReporter").CollectingErrorReporter; var util = { addOptions: addOptions, CommandOptions: CommandOptions, ErrorReporter: ErrorReporter, CollectingErrorReporter: CollectingErrorReporter }; var Parser = System.get("traceur@0.0.52/src/syntax/Parser").Parser; var Scanner = System.get("traceur@0.0.52/src/syntax/Scanner").Scanner; var Script = System.get("traceur@0.0.52/src/syntax/trees/ParseTrees").Script; var SourceFile = System.get("traceur@0.0.52/src/syntax/SourceFile").SourceFile; var syntax = { Parser: Parser, Scanner: Scanner, SourceFile: SourceFile, trees: {Script: Script} }; var ParseTreeMapWriter = System.get("traceur@0.0.52/src/outputgeneration/ParseTreeMapWriter").ParseTreeMapWriter; var ParseTreeWriter = System.get("traceur@0.0.52/src/outputgeneration/ParseTreeWriter").ParseTreeWriter; var SourceMapConsumer = System.get("traceur@0.0.52/src/outputgeneration/SourceMapIntegration").SourceMapConsumer; var SourceMapGenerator = System.get("traceur@0.0.52/src/outputgeneration/SourceMapIntegration").SourceMapGenerator; var TreeWriter = System.get("traceur@0.0.52/src/outputgeneration/TreeWriter").TreeWriter; var outputgeneration = { ParseTreeMapWriter: ParseTreeMapWriter, ParseTreeWriter: ParseTreeWriter, SourceMapConsumer: SourceMapConsumer, SourceMapGenerator: SourceMapGenerator, TreeWriter: TreeWriter }; var AttachModuleNameTransformer = System.get("traceur@0.0.52/src/codegeneration/module/AttachModuleNameTransformer").AttachModuleNameTransformer; var CloneTreeTransformer = System.get("traceur@0.0.52/src/codegeneration/CloneTreeTransformer").CloneTreeTransformer; var FromOptionsTransformer = System.get("traceur@0.0.52/src/codegeneration/FromOptionsTransformer").FromOptionsTransformer; var PureES6Transformer = System.get("traceur@0.0.52/src/codegeneration/PureES6Transformer").PureES6Transformer; var createModuleEvaluationStatement = System.get("traceur@0.0.52/src/codegeneration/module/createModuleEvaluationStatement").createModuleEvaluationStatement; var codegeneration = { CloneTreeTransformer: CloneTreeTransformer, FromOptionsTransformer: FromOptionsTransformer, PureES6Transformer: PureES6Transformer, module: { AttachModuleNameTransformer: AttachModuleNameTransformer, createModuleEvaluationStatement: createModuleEvaluationStatement } }; var Loader = System.get("traceur@0.0.52/src/runtime/Loader").Loader; var LoaderHooks = System.get("traceur@0.0.52/src/runtime/LoaderHooks").LoaderHooks; var InlineLoaderHooks = System.get("traceur@0.0.52/src/runtime/InlineLoaderHooks").InlineLoaderHooks; var InterceptOutputLoaderHooks = System.get("traceur@0.0.52/src/runtime/InterceptOutputLoaderHooks").InterceptOutputLoaderHooks; var TraceurLoader = System.get("traceur@0.0.52/src/runtime/TraceurLoader").TraceurLoader; var runtime = { InlineLoaderHooks: InlineLoaderHooks, InterceptOutputLoaderHooks: InterceptOutputLoaderHooks, Loader: Loader, LoaderHooks: LoaderHooks, TraceurLoader: TraceurLoader }; return { get ModuleStore() { return $___64_traceur_47_src_47_runtime_47_ModuleStore__.ModuleStore; }, get System() { return System; }, get WebPageTranscoder() { return $__traceur_64_0_46_0_46_52_47_src_47_WebPageTranscoder__.WebPageTranscoder; }, get options() { return $__traceur_64_0_46_0_46_52_47_src_47_Options__.options; }, get Compiler() { return $__traceur_64_0_46_0_46_52_47_src_47_Compiler__.Compiler; }, get util() { return util; }, get syntax() { return syntax; }, get outputgeneration() { return outputgeneration; }, get codegeneration() { return codegeneration; }, get runtime() { return runtime; } }; }); System.register("traceur@0.0.52/src/traceur-import", [], function() { "use strict"; var __moduleName = "traceur@0.0.52/src/traceur-import"; var traceur = System.get("traceur@0.0.52/src/traceur"); Reflect.global.traceur = traceur; $traceurRuntime.ModuleStore.set('traceur@', traceur); return {}; }); System.get("traceur@0.0.52/src/traceur-import" + ''); acorn-4.0.4/test/driver.js000066400000000000000000000103631302576755300154510ustar00rootroot00000000000000(function(exports) { var tests = []; exports.test = function(code, ast, options) { tests.push({code: code, ast: ast, options: options}); }; exports.testFail = function(code, message, options) { tests.push({code: code, error: message, options: options}); }; exports.testAssert = function(code, assert, options) { tests.push({code: code, assert: assert, options: options}); }; exports.runTests = function(config, callback) { var parse = config.parse; for (var i = 0; i < tests.length; ++i) { var test = tests[i]; if (config.filter && !config.filter(test)) continue; var testOpts = test.options || {locations: true}; if (!testOpts.ecmaVersion) testOpts.ecmaVersion = 5; var expected = {}; if (expected.onComment = testOpts.onComment) testOpts.onComment = [] if (expected.onToken = testOpts.onToken) testOpts.onToken = []; try { var ast = parse(test.code, testOpts); } catch(e) { if (!(e instanceof SyntaxError)) { console.log(e.stack); throw e; } if (test.error) { if (test.error.charAt(0) == "~" ? e.message.indexOf(test.error.slice(1)) > -1 : e.message == test.error) callback("ok", test.code); else callback("fail", test.code, "Expected error message: " + test.error + "\nGot error message: " + e.message); } else { callback("error", test.code, e.message || e.toString()); } continue } if (test.error) { if (config.loose) callback("ok", test.code); else callback("fail", test.code, "Expected error message: " + test.error + "\nBut parsing succeeded."); } else if (test.assert) { var error = test.assert(ast); if (error) callback("fail", test.code, "\n Assertion failed:\n " + error); else callback("ok", test.code); } else { var mis = misMatch(test.ast, ast); for (var name in expected) { if (mis) break; if (expected[name]) { mis = misMatch(expected[name], testOpts[name]); testOpts[name] = expected[name]; } } if (mis) callback("fail", test.code, mis); else callback("ok", test.code); } } }; function ppJSON(v) { return v instanceof RegExp ? v.toString() : JSON.stringify(v, null, 2); } function addPath(str, pt) { if (str.charAt(str.length-1) == ")") return str.slice(0, str.length-1) + "/" + pt + ")"; return str + " (" + pt + ")"; } var misMatch = exports.misMatch = function(exp, act) { if (!exp || !act || (typeof exp != "object") || (typeof act != "object")) { if (exp !== act && typeof exp != "function") return ppJSON(exp) + " !== " + ppJSON(act); } else if (exp instanceof RegExp || act instanceof RegExp) { var left = ppJSON(exp), right = ppJSON(act); if (left !== right) return left + " !== " + right; } else if (exp.splice) { if (!act.slice) return ppJSON(exp) + " != " + ppJSON(act); if (act.length != exp.length) return "array length mismatch " + exp.length + " != " + act.length; for (var i = 0; i < act.length; ++i) { var mis = misMatch(exp[i], act[i]); if (mis) return addPath(mis, i); } } else { for (var prop in exp) { var mis = misMatch(exp[prop], act[prop]); if (mis) return addPath(mis, prop); } } }; function mangle(ast) { if (typeof ast != "object" || !ast) return; if (ast.slice) { for (var i = 0; i < ast.length; ++i) mangle(ast[i]); } else { var loc = ast.start && ast.end && {start: ast.start, end: ast.end}; if (loc) { delete ast.start; delete ast.end; } for (var name in ast) if (ast.hasOwnProperty(name)) mangle(ast[name]); if (loc) ast.loc = loc; } } exports.printTests = function() { var out = ""; for (var i = 0; i < tests.length; ++i) { if (tests[i].error) continue; mangle(tests[i].ast); out += "test(" + JSON.stringify(tests[i].code) + ", " + JSON.stringify(tests[i].ast, null, 2) + ");\n\n"; } document.body.innerHTML = ""; document.body.appendChild(document.createElement("pre")).appendChild(document.createTextNode(out)); }; })(typeof exports == "undefined" ? window : exports); acorn-4.0.4/test/index.html000066400000000000000000000006151302576755300156140ustar00rootroot00000000000000 Acorn test suite
    acorn-4.0.4/test/jquery-string.js000066400000000000000000012256121302576755300170070ustar00rootroot00000000000000/* Silly noise to be able to load in source code without doing an XMLHttpReq */var jquery111 = "/*!\n\ * jQuery JavaScript Library v1.11.1\n\ * http://jquery.com/\n\ *\n\ * Includes Sizzle.js\n\ * http://sizzlejs.com/\n\ *\n\ * Copyright 2005, 2014 jQuery Foundation, Inc. and other contributors\n\ * Released under the MIT license\n\ * http://jquery.org/license\n\ *\n\ * Date: 2014-05-01T17:42Z\n\ */\n\ \n\ (function( global, factory ) {\n\ \n\ \tif ( typeof module === \"object\" && typeof module.exports === \"object\" ) {\n\ \t\t// For CommonJS and CommonJS-like environments where a proper window is present,\n\ \t\t// execute the factory and get jQuery\n\ \t\t// For environments that do not inherently posses a window with a document\n\ \t\t// (such as Node.js), expose a jQuery-making factory as module.exports\n\ \t\t// This accentuates the need for the creation of a real window\n\ \t\t// e.g. var jQuery = require(\"jquery\")(window);\n\ \t\t// See ticket #14549 for more info\n\ \t\tmodule.exports = global.document ?\n\ \t\t\tfactory( global, true ) :\n\ \t\t\tfunction( w ) {\n\ \t\t\t\tif ( !w.document ) {\n\ \t\t\t\t\tthrow new Error( \"jQuery requires a window with a document\" );\n\ \t\t\t\t}\n\ \t\t\t\treturn factory( w );\n\ \t\t\t};\n\ \t} else {\n\ \t\tfactory( global );\n\ \t}\n\ \n\ // Pass this if window is not defined yet\n\ }(typeof window !== \"undefined\" ? window : this, function( window, noGlobal ) {\n\ \n\ // Can't do this because several apps including ASP.NET trace\n\ // the stack via arguments.caller.callee and Firefox dies if\n\ // you try to trace through \"use strict\" call chains. (#13335)\n\ // Support: Firefox 18+\n\ //\n\ \n\ var deletedIds = [];\n\ \n\ var slice = deletedIds.slice;\n\ \n\ var concat = deletedIds.concat;\n\ \n\ var push = deletedIds.push;\n\ \n\ var indexOf = deletedIds.indexOf;\n\ \n\ var class2type = {};\n\ \n\ var toString = class2type.toString;\n\ \n\ var hasOwn = class2type.hasOwnProperty;\n\ \n\ var support = {};\n\ \n\ \n\ \n\ var\n\ \tversion = \"1.11.1\",\n\ \n\ \t// Define a local copy of jQuery\n\ \tjQuery = function( selector, context ) {\n\ \t\t// The jQuery object is actually just the init constructor 'enhanced'\n\ \t\t// Need init if jQuery is called (just allow error to be thrown if not included)\n\ \t\treturn new jQuery.fn.init( selector, context );\n\ \t},\n\ \n\ \t// Support: Android<4.1, IE<9\n\ \t// Make sure we trim BOM and NBSP\n\ \trtrim = /^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g,\n\ \n\ \t// Matches dashed string for camelizing\n\ \trmsPrefix = /^-ms-/,\n\ \trdashAlpha = /-([\\da-z])/gi,\n\ \n\ \t// Used by jQuery.camelCase as callback to replace()\n\ \tfcamelCase = function( all, letter ) {\n\ \t\treturn letter.toUpperCase();\n\ \t};\n\ \n\ jQuery.fn = jQuery.prototype = {\n\ \t// The current version of jQuery being used\n\ \tjquery: version,\n\ \n\ \tconstructor: jQuery,\n\ \n\ \t// Start with an empty selector\n\ \tselector: \"\",\n\ \n\ \t// The default length of a jQuery object is 0\n\ \tlength: 0,\n\ \n\ \ttoArray: function() {\n\ \t\treturn slice.call( this );\n\ \t},\n\ \n\ \t// Get the Nth element in the matched element set OR\n\ \t// Get the whole matched element set as a clean array\n\ \tget: function( num ) {\n\ \t\treturn num != null ?\n\ \n\ \t\t\t// Return just the one element from the set\n\ \t\t\t( num < 0 ? this[ num + this.length ] : this[ num ] ) :\n\ \n\ \t\t\t// Return all the elements in a clean array\n\ \t\t\tslice.call( this );\n\ \t},\n\ \n\ \t// Take an array of elements and push it onto the stack\n\ \t// (returning the new matched element set)\n\ \tpushStack: function( elems ) {\n\ \n\ \t\t// Build a new jQuery matched element set\n\ \t\tvar ret = jQuery.merge( this.constructor(), elems );\n\ \n\ \t\t// Add the old object onto the stack (as a reference)\n\ \t\tret.prevObject = this;\n\ \t\tret.context = this.context;\n\ \n\ \t\t// Return the newly-formed element set\n\ \t\treturn ret;\n\ \t},\n\ \n\ \t// Execute a callback for every element in the matched set.\n\ \t// (You can seed the arguments with an array of args, but this is\n\ \t// only used internally.)\n\ \teach: function( callback, args ) {\n\ \t\treturn jQuery.each( this, callback, args );\n\ \t},\n\ \n\ \tmap: function( callback ) {\n\ \t\treturn this.pushStack( jQuery.map(this, function( elem, i ) {\n\ \t\t\treturn callback.call( elem, i, elem );\n\ \t\t}));\n\ \t},\n\ \n\ \tslice: function() {\n\ \t\treturn this.pushStack( slice.apply( this, arguments ) );\n\ \t},\n\ \n\ \tfirst: function() {\n\ \t\treturn this.eq( 0 );\n\ \t},\n\ \n\ \tlast: function() {\n\ \t\treturn this.eq( -1 );\n\ \t},\n\ \n\ \teq: function( i ) {\n\ \t\tvar len = this.length,\n\ \t\t\tj = +i + ( i < 0 ? len : 0 );\n\ \t\treturn this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] );\n\ \t},\n\ \n\ \tend: function() {\n\ \t\treturn this.prevObject || this.constructor(null);\n\ \t},\n\ \n\ \t// For internal use only.\n\ \t// Behaves like an Array's method, not like a jQuery method.\n\ \tpush: push,\n\ \tsort: deletedIds.sort,\n\ \tsplice: deletedIds.splice\n\ };\n\ \n\ jQuery.extend = jQuery.fn.extend = function() {\n\ \tvar src, copyIsArray, copy, name, options, clone,\n\ \t\ttarget = arguments[0] || {},\n\ \t\ti = 1,\n\ \t\tlength = arguments.length,\n\ \t\tdeep = false;\n\ \n\ \t// Handle a deep copy situation\n\ \tif ( typeof target === \"boolean\" ) {\n\ \t\tdeep = target;\n\ \n\ \t\t// skip the boolean and the target\n\ \t\ttarget = arguments[ i ] || {};\n\ \t\ti++;\n\ \t}\n\ \n\ \t// Handle case when target is a string or something (possible in deep copy)\n\ \tif ( typeof target !== \"object\" && !jQuery.isFunction(target) ) {\n\ \t\ttarget = {};\n\ \t}\n\ \n\ \t// extend jQuery itself if only one argument is passed\n\ \tif ( i === length ) {\n\ \t\ttarget = this;\n\ \t\ti--;\n\ \t}\n\ \n\ \tfor ( ; i < length; i++ ) {\n\ \t\t// Only deal with non-null/undefined values\n\ \t\tif ( (options = arguments[ i ]) != null ) {\n\ \t\t\t// Extend the base object\n\ \t\t\tfor ( name in options ) {\n\ \t\t\t\tsrc = target[ name ];\n\ \t\t\t\tcopy = options[ name ];\n\ \n\ \t\t\t\t// Prevent never-ending loop\n\ \t\t\t\tif ( target === copy ) {\n\ \t\t\t\t\tcontinue;\n\ \t\t\t\t}\n\ \n\ \t\t\t\t// Recurse if we're merging plain objects or arrays\n\ \t\t\t\tif ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {\n\ \t\t\t\t\tif ( copyIsArray ) {\n\ \t\t\t\t\t\tcopyIsArray = false;\n\ \t\t\t\t\t\tclone = src && jQuery.isArray(src) ? src : [];\n\ \n\ \t\t\t\t\t} else {\n\ \t\t\t\t\t\tclone = src && jQuery.isPlainObject(src) ? src : {};\n\ \t\t\t\t\t}\n\ \n\ \t\t\t\t\t// Never move original objects, clone them\n\ \t\t\t\t\ttarget[ name ] = jQuery.extend( deep, clone, copy );\n\ \n\ \t\t\t\t// Don't bring in undefined values\n\ \t\t\t\t} else if ( copy !== undefined ) {\n\ \t\t\t\t\ttarget[ name ] = copy;\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t}\n\ \t}\n\ \n\ \t// Return the modified object\n\ \treturn target;\n\ };\n\ \n\ jQuery.extend({\n\ \t// Unique for each copy of jQuery on the page\n\ \texpando: \"jQuery\" + ( version + Math.random() ).replace( /\\D/g, \"\" ),\n\ \n\ \t// Assume jQuery is ready without the ready module\n\ \tisReady: true,\n\ \n\ \terror: function( msg ) {\n\ \t\tthrow new Error( msg );\n\ \t},\n\ \n\ \tnoop: function() {},\n\ \n\ \t// See test/unit/core.js for details concerning isFunction.\n\ \t// Since version 1.3, DOM methods and functions like alert\n\ \t// aren't supported. They return false on IE (#2968).\n\ \tisFunction: function( obj ) {\n\ \t\treturn jQuery.type(obj) === \"function\";\n\ \t},\n\ \n\ \tisArray: Array.isArray || function( obj ) {\n\ \t\treturn jQuery.type(obj) === \"array\";\n\ \t},\n\ \n\ \tisWindow: function( obj ) {\n\ \t\t/* jshint eqeqeq: false */\n\ \t\treturn obj != null && obj == obj.window;\n\ \t},\n\ \n\ \tisNumeric: function( obj ) {\n\ \t\t// parseFloat NaNs numeric-cast false positives (null|true|false|\"\")\n\ \t\t// ...but misinterprets leading-number strings, particularly hex literals (\"0x...\")\n\ \t\t// subtraction forces infinities to NaN\n\ \t\treturn !jQuery.isArray( obj ) && obj - parseFloat( obj ) >= 0;\n\ \t},\n\ \n\ \tisEmptyObject: function( obj ) {\n\ \t\tvar name;\n\ \t\tfor ( name in obj ) {\n\ \t\t\treturn false;\n\ \t\t}\n\ \t\treturn true;\n\ \t},\n\ \n\ \tisPlainObject: function( obj ) {\n\ \t\tvar key;\n\ \n\ \t\t// Must be an Object.\n\ \t\t// Because of IE, we also have to check the presence of the constructor property.\n\ \t\t// Make sure that DOM nodes and window objects don't pass through, as well\n\ \t\tif ( !obj || jQuery.type(obj) !== \"object\" || obj.nodeType || jQuery.isWindow( obj ) ) {\n\ \t\t\treturn false;\n\ \t\t}\n\ \n\ \t\ttry {\n\ \t\t\t// Not own constructor property must be Object\n\ \t\t\tif ( obj.constructor &&\n\ \t\t\t\t!hasOwn.call(obj, \"constructor\") &&\n\ \t\t\t\t!hasOwn.call(obj.constructor.prototype, \"isPrototypeOf\") ) {\n\ \t\t\t\treturn false;\n\ \t\t\t}\n\ \t\t} catch ( e ) {\n\ \t\t\t// IE8,9 Will throw exceptions on certain host objects #9897\n\ \t\t\treturn false;\n\ \t\t}\n\ \n\ \t\t// Support: IE<9\n\ \t\t// Handle iteration over inherited properties before own properties.\n\ \t\tif ( support.ownLast ) {\n\ \t\t\tfor ( key in obj ) {\n\ \t\t\t\treturn hasOwn.call( obj, key );\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\t// Own properties are enumerated firstly, so to speed up,\n\ \t\t// if last one is own, then all properties are own.\n\ \t\tfor ( key in obj ) {}\n\ \n\ \t\treturn key === undefined || hasOwn.call( obj, key );\n\ \t},\n\ \n\ \ttype: function( obj ) {\n\ \t\tif ( obj == null ) {\n\ \t\t\treturn obj + \"\";\n\ \t\t}\n\ \t\treturn typeof obj === \"object\" || typeof obj === \"function\" ?\n\ \t\t\tclass2type[ toString.call(obj) ] || \"object\" :\n\ \t\t\ttypeof obj;\n\ \t},\n\ \n\ \t// Evaluates a script in a global context\n\ \t// Workarounds based on findings by Jim Driscoll\n\ \t// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context\n\ \tglobalEval: function( data ) {\n\ \t\tif ( data && jQuery.trim( data ) ) {\n\ \t\t\t// We use execScript on Internet Explorer\n\ \t\t\t// We use an anonymous function so that context is window\n\ \t\t\t// rather than jQuery in Firefox\n\ \t\t\t( window.execScript || function( data ) {\n\ \t\t\t\twindow[ \"eval\" ].call( window, data );\n\ \t\t\t} )( data );\n\ \t\t}\n\ \t},\n\ \n\ \t// Convert dashed to camelCase; used by the css and data modules\n\ \t// Microsoft forgot to hump their vendor prefix (#9572)\n\ \tcamelCase: function( string ) {\n\ \t\treturn string.replace( rmsPrefix, \"ms-\" ).replace( rdashAlpha, fcamelCase );\n\ \t},\n\ \n\ \tnodeName: function( elem, name ) {\n\ \t\treturn elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();\n\ \t},\n\ \n\ \t// args is for internal usage only\n\ \teach: function( obj, callback, args ) {\n\ \t\tvar value,\n\ \t\t\ti = 0,\n\ \t\t\tlength = obj.length,\n\ \t\t\tisArray = isArraylike( obj );\n\ \n\ \t\tif ( args ) {\n\ \t\t\tif ( isArray ) {\n\ \t\t\t\tfor ( ; i < length; i++ ) {\n\ \t\t\t\t\tvalue = callback.apply( obj[ i ], args );\n\ \n\ \t\t\t\t\tif ( value === false ) {\n\ \t\t\t\t\t\tbreak;\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \t\t\t} else {\n\ \t\t\t\tfor ( i in obj ) {\n\ \t\t\t\t\tvalue = callback.apply( obj[ i ], args );\n\ \n\ \t\t\t\t\tif ( value === false ) {\n\ \t\t\t\t\t\tbreak;\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \t\t\t}\n\ \n\ \t\t// A special, fast, case for the most common use of each\n\ \t\t} else {\n\ \t\t\tif ( isArray ) {\n\ \t\t\t\tfor ( ; i < length; i++ ) {\n\ \t\t\t\t\tvalue = callback.call( obj[ i ], i, obj[ i ] );\n\ \n\ \t\t\t\t\tif ( value === false ) {\n\ \t\t\t\t\t\tbreak;\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \t\t\t} else {\n\ \t\t\t\tfor ( i in obj ) {\n\ \t\t\t\t\tvalue = callback.call( obj[ i ], i, obj[ i ] );\n\ \n\ \t\t\t\t\tif ( value === false ) {\n\ \t\t\t\t\t\tbreak;\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\treturn obj;\n\ \t},\n\ \n\ \t// Support: Android<4.1, IE<9\n\ \ttrim: function( text ) {\n\ \t\treturn text == null ?\n\ \t\t\t\"\" :\n\ \t\t\t( text + \"\" ).replace( rtrim, \"\" );\n\ \t},\n\ \n\ \t// results is for internal usage only\n\ \tmakeArray: function( arr, results ) {\n\ \t\tvar ret = results || [];\n\ \n\ \t\tif ( arr != null ) {\n\ \t\t\tif ( isArraylike( Object(arr) ) ) {\n\ \t\t\t\tjQuery.merge( ret,\n\ \t\t\t\t\ttypeof arr === \"string\" ?\n\ \t\t\t\t\t[ arr ] : arr\n\ \t\t\t\t);\n\ \t\t\t} else {\n\ \t\t\t\tpush.call( ret, arr );\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\treturn ret;\n\ \t},\n\ \n\ \tinArray: function( elem, arr, i ) {\n\ \t\tvar len;\n\ \n\ \t\tif ( arr ) {\n\ \t\t\tif ( indexOf ) {\n\ \t\t\t\treturn indexOf.call( arr, elem, i );\n\ \t\t\t}\n\ \n\ \t\t\tlen = arr.length;\n\ \t\t\ti = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;\n\ \n\ \t\t\tfor ( ; i < len; i++ ) {\n\ \t\t\t\t// Skip accessing in sparse arrays\n\ \t\t\t\tif ( i in arr && arr[ i ] === elem ) {\n\ \t\t\t\t\treturn i;\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\treturn -1;\n\ \t},\n\ \n\ \tmerge: function( first, second ) {\n\ \t\tvar len = +second.length,\n\ \t\t\tj = 0,\n\ \t\t\ti = first.length;\n\ \n\ \t\twhile ( j < len ) {\n\ \t\t\tfirst[ i++ ] = second[ j++ ];\n\ \t\t}\n\ \n\ \t\t// Support: IE<9\n\ \t\t// Workaround casting of .length to NaN on otherwise arraylike objects (e.g., NodeLists)\n\ \t\tif ( len !== len ) {\n\ \t\t\twhile ( second[j] !== undefined ) {\n\ \t\t\t\tfirst[ i++ ] = second[ j++ ];\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\tfirst.length = i;\n\ \n\ \t\treturn first;\n\ \t},\n\ \n\ \tgrep: function( elems, callback, invert ) {\n\ \t\tvar callbackInverse,\n\ \t\t\tmatches = [],\n\ \t\t\ti = 0,\n\ \t\t\tlength = elems.length,\n\ \t\t\tcallbackExpect = !invert;\n\ \n\ \t\t// Go through the array, only saving the items\n\ \t\t// that pass the validator function\n\ \t\tfor ( ; i < length; i++ ) {\n\ \t\t\tcallbackInverse = !callback( elems[ i ], i );\n\ \t\t\tif ( callbackInverse !== callbackExpect ) {\n\ \t\t\t\tmatches.push( elems[ i ] );\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\treturn matches;\n\ \t},\n\ \n\ \t// arg is for internal usage only\n\ \tmap: function( elems, callback, arg ) {\n\ \t\tvar value,\n\ \t\t\ti = 0,\n\ \t\t\tlength = elems.length,\n\ \t\t\tisArray = isArraylike( elems ),\n\ \t\t\tret = [];\n\ \n\ \t\t// Go through the array, translating each of the items to their new values\n\ \t\tif ( isArray ) {\n\ \t\t\tfor ( ; i < length; i++ ) {\n\ \t\t\t\tvalue = callback( elems[ i ], i, arg );\n\ \n\ \t\t\t\tif ( value != null ) {\n\ \t\t\t\t\tret.push( value );\n\ \t\t\t\t}\n\ \t\t\t}\n\ \n\ \t\t// Go through every key on the object,\n\ \t\t} else {\n\ \t\t\tfor ( i in elems ) {\n\ \t\t\t\tvalue = callback( elems[ i ], i, arg );\n\ \n\ \t\t\t\tif ( value != null ) {\n\ \t\t\t\t\tret.push( value );\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\t// Flatten any nested arrays\n\ \t\treturn concat.apply( [], ret );\n\ \t},\n\ \n\ \t// A global GUID counter for objects\n\ \tguid: 1,\n\ \n\ \t// Bind a function to a context, optionally partially applying any\n\ \t// arguments.\n\ \tproxy: function( fn, context ) {\n\ \t\tvar args, proxy, tmp;\n\ \n\ \t\tif ( typeof context === \"string\" ) {\n\ \t\t\ttmp = fn[ context ];\n\ \t\t\tcontext = fn;\n\ \t\t\tfn = tmp;\n\ \t\t}\n\ \n\ \t\t// Quick check to determine if target is callable, in the spec\n\ \t\t// this throws a TypeError, but we will just return undefined.\n\ \t\tif ( !jQuery.isFunction( fn ) ) {\n\ \t\t\treturn undefined;\n\ \t\t}\n\ \n\ \t\t// Simulated bind\n\ \t\targs = slice.call( arguments, 2 );\n\ \t\tproxy = function() {\n\ \t\t\treturn fn.apply( context || this, args.concat( slice.call( arguments ) ) );\n\ \t\t};\n\ \n\ \t\t// Set the guid of unique handler to the same of original handler, so it can be removed\n\ \t\tproxy.guid = fn.guid = fn.guid || jQuery.guid++;\n\ \n\ \t\treturn proxy;\n\ \t},\n\ \n\ \tnow: function() {\n\ \t\treturn +( new Date() );\n\ \t},\n\ \n\ \t// jQuery.support is not used in Core but other projects attach their\n\ \t// properties to it so it needs to exist.\n\ \tsupport: support\n\ });\n\ \n\ // Populate the class2type map\n\ jQuery.each(\"Boolean Number String Function Array Date RegExp Object Error\".split(\" \"), function(i, name) {\n\ \tclass2type[ \"[object \" + name + \"]\" ] = name.toLowerCase();\n\ });\n\ \n\ function isArraylike( obj ) {\n\ \tvar length = obj.length,\n\ \t\ttype = jQuery.type( obj );\n\ \n\ \tif ( type === \"function\" || jQuery.isWindow( obj ) ) {\n\ \t\treturn false;\n\ \t}\n\ \n\ \tif ( obj.nodeType === 1 && length ) {\n\ \t\treturn true;\n\ \t}\n\ \n\ \treturn type === \"array\" || length === 0 ||\n\ \t\ttypeof length === \"number\" && length > 0 && ( length - 1 ) in obj;\n\ }\n\ var Sizzle =\n\ /*!\n\ * Sizzle CSS Selector Engine v1.10.19\n\ * http://sizzlejs.com/\n\ *\n\ * Copyright 2013 jQuery Foundation, Inc. and other contributors\n\ * Released under the MIT license\n\ * http://jquery.org/license\n\ *\n\ * Date: 2014-04-18\n\ */\n\ (function( window ) {\n\ \n\ var i,\n\ \tsupport,\n\ \tExpr,\n\ \tgetText,\n\ \tisXML,\n\ \ttokenize,\n\ \tcompile,\n\ \tselect,\n\ \toutermostContext,\n\ \tsortInput,\n\ \thasDuplicate,\n\ \n\ \t// Local document vars\n\ \tsetDocument,\n\ \tdocument,\n\ \tdocElem,\n\ \tdocumentIsHTML,\n\ \trbuggyQSA,\n\ \trbuggyMatches,\n\ \tmatches,\n\ \tcontains,\n\ \n\ \t// Instance-specific data\n\ \texpando = \"sizzle\" + -(new Date()),\n\ \tpreferredDoc = window.document,\n\ \tdirruns = 0,\n\ \tdone = 0,\n\ \tclassCache = createCache(),\n\ \ttokenCache = createCache(),\n\ \tcompilerCache = createCache(),\n\ \tsortOrder = function( a, b ) {\n\ \t\tif ( a === b ) {\n\ \t\t\thasDuplicate = true;\n\ \t\t}\n\ \t\treturn 0;\n\ \t},\n\ \n\ \t// General-purpose constants\n\ \tstrundefined = typeof undefined,\n\ \tMAX_NEGATIVE = 1 << 31,\n\ \n\ \t// Instance methods\n\ \thasOwn = ({}).hasOwnProperty,\n\ \tarr = [],\n\ \tpop = arr.pop,\n\ \tpush_native = arr.push,\n\ \tpush = arr.push,\n\ \tslice = arr.slice,\n\ \t// Use a stripped-down indexOf if we can't use a native one\n\ \tindexOf = arr.indexOf || function( elem ) {\n\ \t\tvar i = 0,\n\ \t\t\tlen = this.length;\n\ \t\tfor ( ; i < len; i++ ) {\n\ \t\t\tif ( this[i] === elem ) {\n\ \t\t\t\treturn i;\n\ \t\t\t}\n\ \t\t}\n\ \t\treturn -1;\n\ \t},\n\ \n\ \tbooleans = \"checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped\",\n\ \n\ \t// Regular expressions\n\ \n\ \t// Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace\n\ \twhitespace = \"[\\\\x20\\\\t\\\\r\\\\n\ \\\\f]\",\n\ \t// http://www.w3.org/TR/css3-syntax/#characters\n\ \tcharacterEncoding = \"(?:\\\\\\\\.|[\\\\w-]|[^\\\\x00-\\\\xa0])+\",\n\ \n\ \t// Loosely modeled on CSS identifier characters\n\ \t// An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors\n\ \t// Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier\n\ \tidentifier = characterEncoding.replace( \"w\", \"w#\" ),\n\ \n\ \t// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors\n\ \tattributes = \"\\\\[\" + whitespace + \"*(\" + characterEncoding + \")(?:\" + whitespace +\n\ \t\t// Operator (capture 2)\n\ \t\t\"*([*^$|!~]?=)\" + whitespace +\n\ \t\t// \"Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]\"\n\ \t\t\"*(?:'((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\"|(\" + identifier + \"))|)\" + whitespace +\n\ \t\t\"*\\\\]\",\n\ \n\ \tpseudos = \":(\" + characterEncoding + \")(?:\\\\((\" +\n\ \t\t// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:\n\ \t\t// 1. quoted (capture 3; capture 4 or capture 5)\n\ \t\t\"('((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\")|\" +\n\ \t\t// 2. simple (capture 6)\n\ \t\t\"((?:\\\\\\\\.|[^\\\\\\\\()[\\\\]]|\" + attributes + \")*)|\" +\n\ \t\t// 3. anything else (capture 2)\n\ \t\t\".*\" +\n\ \t\t\")\\\\)|)\",\n\ \n\ \t// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter\n\ \trtrim = new RegExp( \"^\" + whitespace + \"+|((?:^|[^\\\\\\\\])(?:\\\\\\\\.)*)\" + whitespace + \"+$\", \"g\" ),\n\ \n\ \trcomma = new RegExp( \"^\" + whitespace + \"*,\" + whitespace + \"*\" ),\n\ \trcombinators = new RegExp( \"^\" + whitespace + \"*([>+~]|\" + whitespace + \")\" + whitespace + \"*\" ),\n\ \n\ \trattributeQuotes = new RegExp( \"=\" + whitespace + \"*([^\\\\]'\\\"]*?)\" + whitespace + \"*\\\\]\", \"g\" ),\n\ \n\ \trpseudo = new RegExp( pseudos ),\n\ \tridentifier = new RegExp( \"^\" + identifier + \"$\" ),\n\ \n\ \tmatchExpr = {\n\ \t\t\"ID\": new RegExp( \"^#(\" + characterEncoding + \")\" ),\n\ \t\t\"CLASS\": new RegExp( \"^\\\\.(\" + characterEncoding + \")\" ),\n\ \t\t\"TAG\": new RegExp( \"^(\" + characterEncoding.replace( \"w\", \"w*\" ) + \")\" ),\n\ \t\t\"ATTR\": new RegExp( \"^\" + attributes ),\n\ \t\t\"PSEUDO\": new RegExp( \"^\" + pseudos ),\n\ \t\t\"CHILD\": new RegExp( \"^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\\\(\" + whitespace +\n\ \t\t\t\"*(even|odd|(([+-]|)(\\\\d*)n|)\" + whitespace + \"*(?:([+-]|)\" + whitespace +\n\ \t\t\t\"*(\\\\d+)|))\" + whitespace + \"*\\\\)|)\", \"i\" ),\n\ \t\t\"bool\": new RegExp( \"^(?:\" + booleans + \")$\", \"i\" ),\n\ \t\t// For use in libraries implementing .is()\n\ \t\t// We use this for POS matching in `select`\n\ \t\t\"needsContext\": new RegExp( \"^\" + whitespace + \"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\\\(\" +\n\ \t\t\twhitespace + \"*((?:-\\\\d)?\\\\d*)\" + whitespace + \"*\\\\)|)(?=[^-]|$)\", \"i\" )\n\ \t},\n\ \n\ \trinputs = /^(?:input|select|textarea|button)$/i,\n\ \trheader = /^h\\d$/i,\n\ \n\ \trnative = /^[^{]+\\{\\s*\\[native \\w/,\n\ \n\ \t// Easily-parseable/retrievable ID or TAG or CLASS selectors\n\ \trquickExpr = /^(?:#([\\w-]+)|(\\w+)|\\.([\\w-]+))$/,\n\ \n\ \trsibling = /[+~]/,\n\ \trescape = /'|\\\\/g,\n\ \n\ \t// CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters\n\ \trunescape = new RegExp( \"\\\\\\\\([\\\\da-f]{1,6}\" + whitespace + \"?|(\" + whitespace + \")|.)\", \"ig\" ),\n\ \tfunescape = function( _, escaped, escapedWhitespace ) {\n\ \t\tvar high = \"0x\" + escaped - 0x10000;\n\ \t\t// NaN means non-codepoint\n\ \t\t// Support: Firefox<24\n\ \t\t// Workaround erroneous numeric interpretation of +\"0x\"\n\ \t\treturn high !== high || escapedWhitespace ?\n\ \t\t\tescaped :\n\ \t\t\thigh < 0 ?\n\ \t\t\t\t// BMP codepoint\n\ \t\t\t\tString.fromCharCode( high + 0x10000 ) :\n\ \t\t\t\t// Supplemental Plane codepoint (surrogate pair)\n\ \t\t\t\tString.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );\n\ \t};\n\ \n\ // Optimize for push.apply( _, NodeList )\n\ try {\n\ \tpush.apply(\n\ \t\t(arr = slice.call( preferredDoc.childNodes )),\n\ \t\tpreferredDoc.childNodes\n\ \t);\n\ \t// Support: Android<4.0\n\ \t// Detect silently failing push.apply\n\ \tarr[ preferredDoc.childNodes.length ].nodeType;\n\ } catch ( e ) {\n\ \tpush = { apply: arr.length ?\n\ \n\ \t\t// Leverage slice if possible\n\ \t\tfunction( target, els ) {\n\ \t\t\tpush_native.apply( target, slice.call(els) );\n\ \t\t} :\n\ \n\ \t\t// Support: IE<9\n\ \t\t// Otherwise append directly\n\ \t\tfunction( target, els ) {\n\ \t\t\tvar j = target.length,\n\ \t\t\t\ti = 0;\n\ \t\t\t// Can't trust NodeList.length\n\ \t\t\twhile ( (target[j++] = els[i++]) ) {}\n\ \t\t\ttarget.length = j - 1;\n\ \t\t}\n\ \t};\n\ }\n\ \n\ function Sizzle( selector, context, results, seed ) {\n\ \tvar match, elem, m, nodeType,\n\ \t\t// QSA vars\n\ \t\ti, groups, old, nid, newContext, newSelector;\n\ \n\ \tif ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {\n\ \t\tsetDocument( context );\n\ \t}\n\ \n\ \tcontext = context || document;\n\ \tresults = results || [];\n\ \n\ \tif ( !selector || typeof selector !== \"string\" ) {\n\ \t\treturn results;\n\ \t}\n\ \n\ \tif ( (nodeType = context.nodeType) !== 1 && nodeType !== 9 ) {\n\ \t\treturn [];\n\ \t}\n\ \n\ \tif ( documentIsHTML && !seed ) {\n\ \n\ \t\t// Shortcuts\n\ \t\tif ( (match = rquickExpr.exec( selector )) ) {\n\ \t\t\t// Speed-up: Sizzle(\"#ID\")\n\ \t\t\tif ( (m = match[1]) ) {\n\ \t\t\t\tif ( nodeType === 9 ) {\n\ \t\t\t\t\telem = context.getElementById( m );\n\ \t\t\t\t\t// Check parentNode to catch when Blackberry 4.6 returns\n\ \t\t\t\t\t// nodes that are no longer in the document (jQuery #6963)\n\ \t\t\t\t\tif ( elem && elem.parentNode ) {\n\ \t\t\t\t\t\t// Handle the case where IE, Opera, and Webkit return items\n\ \t\t\t\t\t\t// by name instead of ID\n\ \t\t\t\t\t\tif ( elem.id === m ) {\n\ \t\t\t\t\t\t\tresults.push( elem );\n\ \t\t\t\t\t\t\treturn results;\n\ \t\t\t\t\t\t}\n\ \t\t\t\t\t} else {\n\ \t\t\t\t\t\treturn results;\n\ \t\t\t\t\t}\n\ \t\t\t\t} else {\n\ \t\t\t\t\t// Context is not a document\n\ \t\t\t\t\tif ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) &&\n\ \t\t\t\t\t\tcontains( context, elem ) && elem.id === m ) {\n\ \t\t\t\t\t\tresults.push( elem );\n\ \t\t\t\t\t\treturn results;\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \n\ \t\t\t// Speed-up: Sizzle(\"TAG\")\n\ \t\t\t} else if ( match[2] ) {\n\ \t\t\t\tpush.apply( results, context.getElementsByTagName( selector ) );\n\ \t\t\t\treturn results;\n\ \n\ \t\t\t// Speed-up: Sizzle(\".CLASS\")\n\ \t\t\t} else if ( (m = match[3]) && support.getElementsByClassName && context.getElementsByClassName ) {\n\ \t\t\t\tpush.apply( results, context.getElementsByClassName( m ) );\n\ \t\t\t\treturn results;\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\t// QSA path\n\ \t\tif ( support.qsa && (!rbuggyQSA || !rbuggyQSA.test( selector )) ) {\n\ \t\t\tnid = old = expando;\n\ \t\t\tnewContext = context;\n\ \t\t\tnewSelector = nodeType === 9 && selector;\n\ \n\ \t\t\t// qSA works strangely on Element-rooted queries\n\ \t\t\t// We can work around this by specifying an extra ID on the root\n\ \t\t\t// and working up from there (Thanks to Andrew Dupont for the technique)\n\ \t\t\t// IE 8 doesn't work on object elements\n\ \t\t\tif ( nodeType === 1 && context.nodeName.toLowerCase() !== \"object\" ) {\n\ \t\t\t\tgroups = tokenize( selector );\n\ \n\ \t\t\t\tif ( (old = context.getAttribute(\"id\")) ) {\n\ \t\t\t\t\tnid = old.replace( rescape, \"\\\\$&\" );\n\ \t\t\t\t} else {\n\ \t\t\t\t\tcontext.setAttribute( \"id\", nid );\n\ \t\t\t\t}\n\ \t\t\t\tnid = \"[id='\" + nid + \"'] \";\n\ \n\ \t\t\t\ti = groups.length;\n\ \t\t\t\twhile ( i-- ) {\n\ \t\t\t\t\tgroups[i] = nid + toSelector( groups[i] );\n\ \t\t\t\t}\n\ \t\t\t\tnewContext = rsibling.test( selector ) && testContext( context.parentNode ) || context;\n\ \t\t\t\tnewSelector = groups.join(\",\");\n\ \t\t\t}\n\ \n\ \t\t\tif ( newSelector ) {\n\ \t\t\t\ttry {\n\ \t\t\t\t\tpush.apply( results,\n\ \t\t\t\t\t\tnewContext.querySelectorAll( newSelector )\n\ \t\t\t\t\t);\n\ \t\t\t\t\treturn results;\n\ \t\t\t\t} catch(qsaError) {\n\ \t\t\t\t} finally {\n\ \t\t\t\t\tif ( !old ) {\n\ \t\t\t\t\t\tcontext.removeAttribute(\"id\");\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t}\n\ \t}\n\ \n\ \t// All others\n\ \treturn select( selector.replace( rtrim, \"$1\" ), context, results, seed );\n\ }\n\ \n\ /**\n\ * Create key-value caches of limited size\n\ * @returns {Function(string, Object)} Returns the Object data after storing it on itself with\n\ *\tproperty name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)\n\ *\tdeleting the oldest entry\n\ */\n\ function createCache() {\n\ \tvar keys = [];\n\ \n\ \tfunction cache( key, value ) {\n\ \t\t// Use (key + \" \") to avoid collision with native prototype properties (see Issue #157)\n\ \t\tif ( keys.push( key + \" \" ) > Expr.cacheLength ) {\n\ \t\t\t// Only keep the most recent entries\n\ \t\t\tdelete cache[ keys.shift() ];\n\ \t\t}\n\ \t\treturn (cache[ key + \" \" ] = value);\n\ \t}\n\ \treturn cache;\n\ }\n\ \n\ /**\n\ * Mark a function for special use by Sizzle\n\ * @param {Function} fn The function to mark\n\ */\n\ function markFunction( fn ) {\n\ \tfn[ expando ] = true;\n\ \treturn fn;\n\ }\n\ \n\ /**\n\ * Support testing using an element\n\ * @param {Function} fn Passed the created div and expects a boolean result\n\ */\n\ function assert( fn ) {\n\ \tvar div = document.createElement(\"div\");\n\ \n\ \ttry {\n\ \t\treturn !!fn( div );\n\ \t} catch (e) {\n\ \t\treturn false;\n\ \t} finally {\n\ \t\t// Remove from its parent by default\n\ \t\tif ( div.parentNode ) {\n\ \t\t\tdiv.parentNode.removeChild( div );\n\ \t\t}\n\ \t\t// release memory in IE\n\ \t\tdiv = null;\n\ \t}\n\ }\n\ \n\ /**\n\ * Adds the same handler for all of the specified attrs\n\ * @param {String} attrs Pipe-separated list of attributes\n\ * @param {Function} handler The method that will be applied\n\ */\n\ function addHandle( attrs, handler ) {\n\ \tvar arr = attrs.split(\"|\"),\n\ \t\ti = attrs.length;\n\ \n\ \twhile ( i-- ) {\n\ \t\tExpr.attrHandle[ arr[i] ] = handler;\n\ \t}\n\ }\n\ \n\ /**\n\ * Checks document order of two siblings\n\ * @param {Element} a\n\ * @param {Element} b\n\ * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b\n\ */\n\ function siblingCheck( a, b ) {\n\ \tvar cur = b && a,\n\ \t\tdiff = cur && a.nodeType === 1 && b.nodeType === 1 &&\n\ \t\t\t( ~b.sourceIndex || MAX_NEGATIVE ) -\n\ \t\t\t( ~a.sourceIndex || MAX_NEGATIVE );\n\ \n\ \t// Use IE sourceIndex if available on both nodes\n\ \tif ( diff ) {\n\ \t\treturn diff;\n\ \t}\n\ \n\ \t// Check if b follows a\n\ \tif ( cur ) {\n\ \t\twhile ( (cur = cur.nextSibling) ) {\n\ \t\t\tif ( cur === b ) {\n\ \t\t\t\treturn -1;\n\ \t\t\t}\n\ \t\t}\n\ \t}\n\ \n\ \treturn a ? 1 : -1;\n\ }\n\ \n\ /**\n\ * Returns a function to use in pseudos for input types\n\ * @param {String} type\n\ */\n\ function createInputPseudo( type ) {\n\ \treturn function( elem ) {\n\ \t\tvar name = elem.nodeName.toLowerCase();\n\ \t\treturn name === \"input\" && elem.type === type;\n\ \t};\n\ }\n\ \n\ /**\n\ * Returns a function to use in pseudos for buttons\n\ * @param {String} type\n\ */\n\ function createButtonPseudo( type ) {\n\ \treturn function( elem ) {\n\ \t\tvar name = elem.nodeName.toLowerCase();\n\ \t\treturn (name === \"input\" || name === \"button\") && elem.type === type;\n\ \t};\n\ }\n\ \n\ /**\n\ * Returns a function to use in pseudos for positionals\n\ * @param {Function} fn\n\ */\n\ function createPositionalPseudo( fn ) {\n\ \treturn markFunction(function( argument ) {\n\ \t\targument = +argument;\n\ \t\treturn markFunction(function( seed, matches ) {\n\ \t\t\tvar j,\n\ \t\t\t\tmatchIndexes = fn( [], seed.length, argument ),\n\ \t\t\t\ti = matchIndexes.length;\n\ \n\ \t\t\t// Match elements found at the specified indexes\n\ \t\t\twhile ( i-- ) {\n\ \t\t\t\tif ( seed[ (j = matchIndexes[i]) ] ) {\n\ \t\t\t\t\tseed[j] = !(matches[j] = seed[j]);\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t});\n\ \t});\n\ }\n\ \n\ /**\n\ * Checks a node for validity as a Sizzle context\n\ * @param {Element|Object=} context\n\ * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value\n\ */\n\ function testContext( context ) {\n\ \treturn context && typeof context.getElementsByTagName !== strundefined && context;\n\ }\n\ \n\ // Expose support vars for convenience\n\ support = Sizzle.support = {};\n\ \n\ /**\n\ * Detects XML nodes\n\ * @param {Element|Object} elem An element or a document\n\ * @returns {Boolean} True iff elem is a non-HTML XML node\n\ */\n\ isXML = Sizzle.isXML = function( elem ) {\n\ \t// documentElement is verified for cases where it doesn't yet exist\n\ \t// (such as loading iframes in IE - #4833)\n\ \tvar documentElement = elem && (elem.ownerDocument || elem).documentElement;\n\ \treturn documentElement ? documentElement.nodeName !== \"HTML\" : false;\n\ };\n\ \n\ /**\n\ * Sets document-related variables once based on the current document\n\ * @param {Element|Object} [doc] An element or document object to use to set the document\n\ * @returns {Object} Returns the current document\n\ */\n\ setDocument = Sizzle.setDocument = function( node ) {\n\ \tvar hasCompare,\n\ \t\tdoc = node ? node.ownerDocument || node : preferredDoc,\n\ \t\tparent = doc.defaultView;\n\ \n\ \t// If no document and documentElement is available, return\n\ \tif ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {\n\ \t\treturn document;\n\ \t}\n\ \n\ \t// Set our document\n\ \tdocument = doc;\n\ \tdocElem = doc.documentElement;\n\ \n\ \t// Support tests\n\ \tdocumentIsHTML = !isXML( doc );\n\ \n\ \t// Support: IE>8\n\ \t// If iframe document is assigned to \"document\" variable and if iframe has been reloaded,\n\ \t// IE will throw \"permission denied\" error when accessing \"document\" variable, see jQuery #13936\n\ \t// IE6-8 do not support the defaultView property so parent will be undefined\n\ \tif ( parent && parent !== parent.top ) {\n\ \t\t// IE11 does not have attachEvent, so all must suffer\n\ \t\tif ( parent.addEventListener ) {\n\ \t\t\tparent.addEventListener( \"unload\", function() {\n\ \t\t\t\tsetDocument();\n\ \t\t\t}, false );\n\ \t\t} else if ( parent.attachEvent ) {\n\ \t\t\tparent.attachEvent( \"onunload\", function() {\n\ \t\t\t\tsetDocument();\n\ \t\t\t});\n\ \t\t}\n\ \t}\n\ \n\ \t/* Attributes\n\ \t---------------------------------------------------------------------- */\n\ \n\ \t// Support: IE<8\n\ \t// Verify that getAttribute really returns attributes and not properties (excepting IE8 booleans)\n\ \tsupport.attributes = assert(function( div ) {\n\ \t\tdiv.className = \"i\";\n\ \t\treturn !div.getAttribute(\"className\");\n\ \t});\n\ \n\ \t/* getElement(s)By*\n\ \t---------------------------------------------------------------------- */\n\ \n\ \t// Check if getElementsByTagName(\"*\") returns only elements\n\ \tsupport.getElementsByTagName = assert(function( div ) {\n\ \t\tdiv.appendChild( doc.createComment(\"\") );\n\ \t\treturn !div.getElementsByTagName(\"*\").length;\n\ \t});\n\ \n\ \t// Check if getElementsByClassName can be trusted\n\ \tsupport.getElementsByClassName = rnative.test( doc.getElementsByClassName ) && assert(function( div ) {\n\ \t\tdiv.innerHTML = \"
    \";\n\ \n\ \t\t// Support: Safari<4\n\ \t\t// Catch class over-caching\n\ \t\tdiv.firstChild.className = \"i\";\n\ \t\t// Support: Opera<10\n\ \t\t// Catch gEBCN failure to find non-leading classes\n\ \t\treturn div.getElementsByClassName(\"i\").length === 2;\n\ \t});\n\ \n\ \t// Support: IE<10\n\ \t// Check if getElementById returns elements by name\n\ \t// The broken getElementById methods don't pick up programatically-set names,\n\ \t// so use a roundabout getElementsByName test\n\ \tsupport.getById = assert(function( div ) {\n\ \t\tdocElem.appendChild( div ).id = expando;\n\ \t\treturn !doc.getElementsByName || !doc.getElementsByName( expando ).length;\n\ \t});\n\ \n\ \t// ID find and filter\n\ \tif ( support.getById ) {\n\ \t\tExpr.find[\"ID\"] = function( id, context ) {\n\ \t\t\tif ( typeof context.getElementById !== strundefined && documentIsHTML ) {\n\ \t\t\t\tvar m = context.getElementById( id );\n\ \t\t\t\t// Check parentNode to catch when Blackberry 4.6 returns\n\ \t\t\t\t// nodes that are no longer in the document #6963\n\ \t\t\t\treturn m && m.parentNode ? [ m ] : [];\n\ \t\t\t}\n\ \t\t};\n\ \t\tExpr.filter[\"ID\"] = function( id ) {\n\ \t\t\tvar attrId = id.replace( runescape, funescape );\n\ \t\t\treturn function( elem ) {\n\ \t\t\t\treturn elem.getAttribute(\"id\") === attrId;\n\ \t\t\t};\n\ \t\t};\n\ \t} else {\n\ \t\t// Support: IE6/7\n\ \t\t// getElementById is not reliable as a find shortcut\n\ \t\tdelete Expr.find[\"ID\"];\n\ \n\ \t\tExpr.filter[\"ID\"] = function( id ) {\n\ \t\t\tvar attrId = id.replace( runescape, funescape );\n\ \t\t\treturn function( elem ) {\n\ \t\t\t\tvar node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode(\"id\");\n\ \t\t\t\treturn node && node.value === attrId;\n\ \t\t\t};\n\ \t\t};\n\ \t}\n\ \n\ \t// Tag\n\ \tExpr.find[\"TAG\"] = support.getElementsByTagName ?\n\ \t\tfunction( tag, context ) {\n\ \t\t\tif ( typeof context.getElementsByTagName !== strundefined ) {\n\ \t\t\t\treturn context.getElementsByTagName( tag );\n\ \t\t\t}\n\ \t\t} :\n\ \t\tfunction( tag, context ) {\n\ \t\t\tvar elem,\n\ \t\t\t\ttmp = [],\n\ \t\t\t\ti = 0,\n\ \t\t\t\tresults = context.getElementsByTagName( tag );\n\ \n\ \t\t\t// Filter out possible comments\n\ \t\t\tif ( tag === \"*\" ) {\n\ \t\t\t\twhile ( (elem = results[i++]) ) {\n\ \t\t\t\t\tif ( elem.nodeType === 1 ) {\n\ \t\t\t\t\t\ttmp.push( elem );\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \n\ \t\t\t\treturn tmp;\n\ \t\t\t}\n\ \t\t\treturn results;\n\ \t\t};\n\ \n\ \t// Class\n\ \tExpr.find[\"CLASS\"] = support.getElementsByClassName && function( className, context ) {\n\ \t\tif ( typeof context.getElementsByClassName !== strundefined && documentIsHTML ) {\n\ \t\t\treturn context.getElementsByClassName( className );\n\ \t\t}\n\ \t};\n\ \n\ \t/* QSA/matchesSelector\n\ \t---------------------------------------------------------------------- */\n\ \n\ \t// QSA and matchesSelector support\n\ \n\ \t// matchesSelector(:active) reports false when true (IE9/Opera 11.5)\n\ \trbuggyMatches = [];\n\ \n\ \t// qSa(:focus) reports false when true (Chrome 21)\n\ \t// We allow this because of a bug in IE8/9 that throws an error\n\ \t// whenever `document.activeElement` is accessed on an iframe\n\ \t// So, we allow :focus to pass through QSA all the time to avoid the IE error\n\ \t// See http://bugs.jquery.com/ticket/13378\n\ \trbuggyQSA = [];\n\ \n\ \tif ( (support.qsa = rnative.test( doc.querySelectorAll )) ) {\n\ \t\t// Build QSA regex\n\ \t\t// Regex strategy adopted from Diego Perini\n\ \t\tassert(function( div ) {\n\ \t\t\t// Select is set to empty string on purpose\n\ \t\t\t// This is to test IE's treatment of not explicitly\n\ \t\t\t// setting a boolean content attribute,\n\ \t\t\t// since its presence should be enough\n\ \t\t\t// http://bugs.jquery.com/ticket/12359\n\ \t\t\tdiv.innerHTML = \"\";\n\ \n\ \t\t\t// Support: IE8, Opera 11-12.16\n\ \t\t\t// Nothing should be selected when empty strings follow ^= or $= or *=\n\ \t\t\t// The test attribute must be unknown in Opera but \"safe\" for WinRT\n\ \t\t\t// http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section\n\ \t\t\tif ( div.querySelectorAll(\"[msallowclip^='']\").length ) {\n\ \t\t\t\trbuggyQSA.push( \"[*^$]=\" + whitespace + \"*(?:''|\\\"\\\")\" );\n\ \t\t\t}\n\ \n\ \t\t\t// Support: IE8\n\ \t\t\t// Boolean attributes and \"value\" are not treated correctly\n\ \t\t\tif ( !div.querySelectorAll(\"[selected]\").length ) {\n\ \t\t\t\trbuggyQSA.push( \"\\\\[\" + whitespace + \"*(?:value|\" + booleans + \")\" );\n\ \t\t\t}\n\ \n\ \t\t\t// Webkit/Opera - :checked should return selected option elements\n\ \t\t\t// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n\ \t\t\t// IE8 throws error here and will not see later tests\n\ \t\t\tif ( !div.querySelectorAll(\":checked\").length ) {\n\ \t\t\t\trbuggyQSA.push(\":checked\");\n\ \t\t\t}\n\ \t\t});\n\ \n\ \t\tassert(function( div ) {\n\ \t\t\t// Support: Windows 8 Native Apps\n\ \t\t\t// The type and name attributes are restricted during .innerHTML assignment\n\ \t\t\tvar input = doc.createElement(\"input\");\n\ \t\t\tinput.setAttribute( \"type\", \"hidden\" );\n\ \t\t\tdiv.appendChild( input ).setAttribute( \"name\", \"D\" );\n\ \n\ \t\t\t// Support: IE8\n\ \t\t\t// Enforce case-sensitivity of name attribute\n\ \t\t\tif ( div.querySelectorAll(\"[name=d]\").length ) {\n\ \t\t\t\trbuggyQSA.push( \"name\" + whitespace + \"*[*^$|!~]?=\" );\n\ \t\t\t}\n\ \n\ \t\t\t// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)\n\ \t\t\t// IE8 throws error here and will not see later tests\n\ \t\t\tif ( !div.querySelectorAll(\":enabled\").length ) {\n\ \t\t\t\trbuggyQSA.push( \":enabled\", \":disabled\" );\n\ \t\t\t}\n\ \n\ \t\t\t// Opera 10-11 does not throw on post-comma invalid pseudos\n\ \t\t\tdiv.querySelectorAll(\"*,:x\");\n\ \t\t\trbuggyQSA.push(\",.*:\");\n\ \t\t});\n\ \t}\n\ \n\ \tif ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||\n\ \t\tdocElem.webkitMatchesSelector ||\n\ \t\tdocElem.mozMatchesSelector ||\n\ \t\tdocElem.oMatchesSelector ||\n\ \t\tdocElem.msMatchesSelector) )) ) {\n\ \n\ \t\tassert(function( div ) {\n\ \t\t\t// Check to see if it's possible to do matchesSelector\n\ \t\t\t// on a disconnected node (IE 9)\n\ \t\t\tsupport.disconnectedMatch = matches.call( div, \"div\" );\n\ \n\ \t\t\t// This should fail with an exception\n\ \t\t\t// Gecko does not error, returns false instead\n\ \t\t\tmatches.call( div, \"[s!='']:x\" );\n\ \t\t\trbuggyMatches.push( \"!=\", pseudos );\n\ \t\t});\n\ \t}\n\ \n\ \trbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join(\"|\") );\n\ \trbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join(\"|\") );\n\ \n\ \t/* Contains\n\ \t---------------------------------------------------------------------- */\n\ \thasCompare = rnative.test( docElem.compareDocumentPosition );\n\ \n\ \t// Element contains another\n\ \t// Purposefully does not implement inclusive descendent\n\ \t// As in, an element does not contain itself\n\ \tcontains = hasCompare || rnative.test( docElem.contains ) ?\n\ \t\tfunction( a, b ) {\n\ \t\t\tvar adown = a.nodeType === 9 ? a.documentElement : a,\n\ \t\t\t\tbup = b && b.parentNode;\n\ \t\t\treturn a === bup || !!( bup && bup.nodeType === 1 && (\n\ \t\t\t\tadown.contains ?\n\ \t\t\t\t\tadown.contains( bup ) :\n\ \t\t\t\t\ta.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16\n\ \t\t\t));\n\ \t\t} :\n\ \t\tfunction( a, b ) {\n\ \t\t\tif ( b ) {\n\ \t\t\t\twhile ( (b = b.parentNode) ) {\n\ \t\t\t\t\tif ( b === a ) {\n\ \t\t\t\t\t\treturn true;\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t\treturn false;\n\ \t\t};\n\ \n\ \t/* Sorting\n\ \t---------------------------------------------------------------------- */\n\ \n\ \t// Document order sorting\n\ \tsortOrder = hasCompare ?\n\ \tfunction( a, b ) {\n\ \n\ \t\t// Flag for duplicate removal\n\ \t\tif ( a === b ) {\n\ \t\t\thasDuplicate = true;\n\ \t\t\treturn 0;\n\ \t\t}\n\ \n\ \t\t// Sort on method existence if only one input has compareDocumentPosition\n\ \t\tvar compare = !a.compareDocumentPosition - !b.compareDocumentPosition;\n\ \t\tif ( compare ) {\n\ \t\t\treturn compare;\n\ \t\t}\n\ \n\ \t\t// Calculate position if both inputs belong to the same document\n\ \t\tcompare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?\n\ \t\t\ta.compareDocumentPosition( b ) :\n\ \n\ \t\t\t// Otherwise we know they are disconnected\n\ \t\t\t1;\n\ \n\ \t\t// Disconnected nodes\n\ \t\tif ( compare & 1 ||\n\ \t\t\t(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {\n\ \n\ \t\t\t// Choose the first element that is related to our preferred document\n\ \t\t\tif ( a === doc || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {\n\ \t\t\t\treturn -1;\n\ \t\t\t}\n\ \t\t\tif ( b === doc || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {\n\ \t\t\t\treturn 1;\n\ \t\t\t}\n\ \n\ \t\t\t// Maintain original order\n\ \t\t\treturn sortInput ?\n\ \t\t\t\t( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :\n\ \t\t\t\t0;\n\ \t\t}\n\ \n\ \t\treturn compare & 4 ? -1 : 1;\n\ \t} :\n\ \tfunction( a, b ) {\n\ \t\t// Exit early if the nodes are identical\n\ \t\tif ( a === b ) {\n\ \t\t\thasDuplicate = true;\n\ \t\t\treturn 0;\n\ \t\t}\n\ \n\ \t\tvar cur,\n\ \t\t\ti = 0,\n\ \t\t\taup = a.parentNode,\n\ \t\t\tbup = b.parentNode,\n\ \t\t\tap = [ a ],\n\ \t\t\tbp = [ b ];\n\ \n\ \t\t// Parentless nodes are either documents or disconnected\n\ \t\tif ( !aup || !bup ) {\n\ \t\t\treturn a === doc ? -1 :\n\ \t\t\t\tb === doc ? 1 :\n\ \t\t\t\taup ? -1 :\n\ \t\t\t\tbup ? 1 :\n\ \t\t\t\tsortInput ?\n\ \t\t\t\t( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :\n\ \t\t\t\t0;\n\ \n\ \t\t// If the nodes are siblings, we can do a quick check\n\ \t\t} else if ( aup === bup ) {\n\ \t\t\treturn siblingCheck( a, b );\n\ \t\t}\n\ \n\ \t\t// Otherwise we need full lists of their ancestors for comparison\n\ \t\tcur = a;\n\ \t\twhile ( (cur = cur.parentNode) ) {\n\ \t\t\tap.unshift( cur );\n\ \t\t}\n\ \t\tcur = b;\n\ \t\twhile ( (cur = cur.parentNode) ) {\n\ \t\t\tbp.unshift( cur );\n\ \t\t}\n\ \n\ \t\t// Walk down the tree looking for a discrepancy\n\ \t\twhile ( ap[i] === bp[i] ) {\n\ \t\t\ti++;\n\ \t\t}\n\ \n\ \t\treturn i ?\n\ \t\t\t// Do a sibling check if the nodes have a common ancestor\n\ \t\t\tsiblingCheck( ap[i], bp[i] ) :\n\ \n\ \t\t\t// Otherwise nodes in our document sort first\n\ \t\t\tap[i] === preferredDoc ? -1 :\n\ \t\t\tbp[i] === preferredDoc ? 1 :\n\ \t\t\t0;\n\ \t};\n\ \n\ \treturn doc;\n\ };\n\ \n\ Sizzle.matches = function( expr, elements ) {\n\ \treturn Sizzle( expr, null, null, elements );\n\ };\n\ \n\ Sizzle.matchesSelector = function( elem, expr ) {\n\ \t// Set document vars if needed\n\ \tif ( ( elem.ownerDocument || elem ) !== document ) {\n\ \t\tsetDocument( elem );\n\ \t}\n\ \n\ \t// Make sure that attribute selectors are quoted\n\ \texpr = expr.replace( rattributeQuotes, \"='$1']\" );\n\ \n\ \tif ( support.matchesSelector && documentIsHTML &&\n\ \t\t( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&\n\ \t\t( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) {\n\ \n\ \t\ttry {\n\ \t\t\tvar ret = matches.call( elem, expr );\n\ \n\ \t\t\t// IE 9's matchesSelector returns false on disconnected nodes\n\ \t\t\tif ( ret || support.disconnectedMatch ||\n\ \t\t\t\t\t// As well, disconnected nodes are said to be in a document\n\ \t\t\t\t\t// fragment in IE 9\n\ \t\t\t\t\telem.document && elem.document.nodeType !== 11 ) {\n\ \t\t\t\treturn ret;\n\ \t\t\t}\n\ \t\t} catch(e) {}\n\ \t}\n\ \n\ \treturn Sizzle( expr, document, null, [ elem ] ).length > 0;\n\ };\n\ \n\ Sizzle.contains = function( context, elem ) {\n\ \t// Set document vars if needed\n\ \tif ( ( context.ownerDocument || context ) !== document ) {\n\ \t\tsetDocument( context );\n\ \t}\n\ \treturn contains( context, elem );\n\ };\n\ \n\ Sizzle.attr = function( elem, name ) {\n\ \t// Set document vars if needed\n\ \tif ( ( elem.ownerDocument || elem ) !== document ) {\n\ \t\tsetDocument( elem );\n\ \t}\n\ \n\ \tvar fn = Expr.attrHandle[ name.toLowerCase() ],\n\ \t\t// Don't get fooled by Object.prototype properties (jQuery #13807)\n\ \t\tval = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?\n\ \t\t\tfn( elem, name, !documentIsHTML ) :\n\ \t\t\tundefined;\n\ \n\ \treturn val !== undefined ?\n\ \t\tval :\n\ \t\tsupport.attributes || !documentIsHTML ?\n\ \t\t\telem.getAttribute( name ) :\n\ \t\t\t(val = elem.getAttributeNode(name)) && val.specified ?\n\ \t\t\t\tval.value :\n\ \t\t\t\tnull;\n\ };\n\ \n\ Sizzle.error = function( msg ) {\n\ \tthrow new Error( \"Syntax error, unrecognized expression: \" + msg );\n\ };\n\ \n\ /**\n\ * Document sorting and removing duplicates\n\ * @param {ArrayLike} results\n\ */\n\ Sizzle.uniqueSort = function( results ) {\n\ \tvar elem,\n\ \t\tduplicates = [],\n\ \t\tj = 0,\n\ \t\ti = 0;\n\ \n\ \t// Unless we *know* we can detect duplicates, assume their presence\n\ \thasDuplicate = !support.detectDuplicates;\n\ \tsortInput = !support.sortStable && results.slice( 0 );\n\ \tresults.sort( sortOrder );\n\ \n\ \tif ( hasDuplicate ) {\n\ \t\twhile ( (elem = results[i++]) ) {\n\ \t\t\tif ( elem === results[ i ] ) {\n\ \t\t\t\tj = duplicates.push( i );\n\ \t\t\t}\n\ \t\t}\n\ \t\twhile ( j-- ) {\n\ \t\t\tresults.splice( duplicates[ j ], 1 );\n\ \t\t}\n\ \t}\n\ \n\ \t// Clear input after sorting to release objects\n\ \t// See https://github.com/jquery/sizzle/pull/225\n\ \tsortInput = null;\n\ \n\ \treturn results;\n\ };\n\ \n\ /**\n\ * Utility function for retrieving the text value of an array of DOM nodes\n\ * @param {Array|Element} elem\n\ */\n\ getText = Sizzle.getText = function( elem ) {\n\ \tvar node,\n\ \t\tret = \"\",\n\ \t\ti = 0,\n\ \t\tnodeType = elem.nodeType;\n\ \n\ \tif ( !nodeType ) {\n\ \t\t// If no nodeType, this is expected to be an array\n\ \t\twhile ( (node = elem[i++]) ) {\n\ \t\t\t// Do not traverse comment nodes\n\ \t\t\tret += getText( node );\n\ \t\t}\n\ \t} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {\n\ \t\t// Use textContent for elements\n\ \t\t// innerText usage removed for consistency of new lines (jQuery #11153)\n\ \t\tif ( typeof elem.textContent === \"string\" ) {\n\ \t\t\treturn elem.textContent;\n\ \t\t} else {\n\ \t\t\t// Traverse its children\n\ \t\t\tfor ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {\n\ \t\t\t\tret += getText( elem );\n\ \t\t\t}\n\ \t\t}\n\ \t} else if ( nodeType === 3 || nodeType === 4 ) {\n\ \t\treturn elem.nodeValue;\n\ \t}\n\ \t// Do not include comment or processing instruction nodes\n\ \n\ \treturn ret;\n\ };\n\ \n\ Expr = Sizzle.selectors = {\n\ \n\ \t// Can be adjusted by the user\n\ \tcacheLength: 50,\n\ \n\ \tcreatePseudo: markFunction,\n\ \n\ \tmatch: matchExpr,\n\ \n\ \tattrHandle: {},\n\ \n\ \tfind: {},\n\ \n\ \trelative: {\n\ \t\t\">\": { dir: \"parentNode\", first: true },\n\ \t\t\" \": { dir: \"parentNode\" },\n\ \t\t\"+\": { dir: \"previousSibling\", first: true },\n\ \t\t\"~\": { dir: \"previousSibling\" }\n\ \t},\n\ \n\ \tpreFilter: {\n\ \t\t\"ATTR\": function( match ) {\n\ \t\t\tmatch[1] = match[1].replace( runescape, funescape );\n\ \n\ \t\t\t// Move the given value to match[3] whether quoted or unquoted\n\ \t\t\tmatch[3] = ( match[3] || match[4] || match[5] || \"\" ).replace( runescape, funescape );\n\ \n\ \t\t\tif ( match[2] === \"~=\" ) {\n\ \t\t\t\tmatch[3] = \" \" + match[3] + \" \";\n\ \t\t\t}\n\ \n\ \t\t\treturn match.slice( 0, 4 );\n\ \t\t},\n\ \n\ \t\t\"CHILD\": function( match ) {\n\ \t\t\t/* matches from matchExpr[\"CHILD\"]\n\ \t\t\t\t1 type (only|nth|...)\n\ \t\t\t\t2 what (child|of-type)\n\ \t\t\t\t3 argument (even|odd|\\d*|\\d*n([+-]\\d+)?|...)\n\ \t\t\t\t4 xn-component of xn+y argument ([+-]?\\d*n|)\n\ \t\t\t\t5 sign of xn-component\n\ \t\t\t\t6 x of xn-component\n\ \t\t\t\t7 sign of y-component\n\ \t\t\t\t8 y of y-component\n\ \t\t\t*/\n\ \t\t\tmatch[1] = match[1].toLowerCase();\n\ \n\ \t\t\tif ( match[1].slice( 0, 3 ) === \"nth\" ) {\n\ \t\t\t\t// nth-* requires argument\n\ \t\t\t\tif ( !match[3] ) {\n\ \t\t\t\t\tSizzle.error( match[0] );\n\ \t\t\t\t}\n\ \n\ \t\t\t\t// numeric x and y parameters for Expr.filter.CHILD\n\ \t\t\t\t// remember that false/true cast respectively to 0/1\n\ \t\t\t\tmatch[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === \"even\" || match[3] === \"odd\" ) );\n\ \t\t\t\tmatch[5] = +( ( match[7] + match[8] ) || match[3] === \"odd\" );\n\ \n\ \t\t\t// other types prohibit arguments\n\ \t\t\t} else if ( match[3] ) {\n\ \t\t\t\tSizzle.error( match[0] );\n\ \t\t\t}\n\ \n\ \t\t\treturn match;\n\ \t\t},\n\ \n\ \t\t\"PSEUDO\": function( match ) {\n\ \t\t\tvar excess,\n\ \t\t\t\tunquoted = !match[6] && match[2];\n\ \n\ \t\t\tif ( matchExpr[\"CHILD\"].test( match[0] ) ) {\n\ \t\t\t\treturn null;\n\ \t\t\t}\n\ \n\ \t\t\t// Accept quoted arguments as-is\n\ \t\t\tif ( match[3] ) {\n\ \t\t\t\tmatch[2] = match[4] || match[5] || \"\";\n\ \n\ \t\t\t// Strip excess characters from unquoted arguments\n\ \t\t\t} else if ( unquoted && rpseudo.test( unquoted ) &&\n\ \t\t\t\t// Get excess from tokenize (recursively)\n\ \t\t\t\t(excess = tokenize( unquoted, true )) &&\n\ \t\t\t\t// advance to the next closing parenthesis\n\ \t\t\t\t(excess = unquoted.indexOf( \")\", unquoted.length - excess ) - unquoted.length) ) {\n\ \n\ \t\t\t\t// excess is a negative index\n\ \t\t\t\tmatch[0] = match[0].slice( 0, excess );\n\ \t\t\t\tmatch[2] = unquoted.slice( 0, excess );\n\ \t\t\t}\n\ \n\ \t\t\t// Return only captures needed by the pseudo filter method (type and argument)\n\ \t\t\treturn match.slice( 0, 3 );\n\ \t\t}\n\ \t},\n\ \n\ \tfilter: {\n\ \n\ \t\t\"TAG\": function( nodeNameSelector ) {\n\ \t\t\tvar nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();\n\ \t\t\treturn nodeNameSelector === \"*\" ?\n\ \t\t\t\tfunction() { return true; } :\n\ \t\t\t\tfunction( elem ) {\n\ \t\t\t\t\treturn elem.nodeName && elem.nodeName.toLowerCase() === nodeName;\n\ \t\t\t\t};\n\ \t\t},\n\ \n\ \t\t\"CLASS\": function( className ) {\n\ \t\t\tvar pattern = classCache[ className + \" \" ];\n\ \n\ \t\t\treturn pattern ||\n\ \t\t\t\t(pattern = new RegExp( \"(^|\" + whitespace + \")\" + className + \"(\" + whitespace + \"|$)\" )) &&\n\ \t\t\t\tclassCache( className, function( elem ) {\n\ \t\t\t\t\treturn pattern.test( typeof elem.className === \"string\" && elem.className || typeof elem.getAttribute !== strundefined && elem.getAttribute(\"class\") || \"\" );\n\ \t\t\t\t});\n\ \t\t},\n\ \n\ \t\t\"ATTR\": function( name, operator, check ) {\n\ \t\t\treturn function( elem ) {\n\ \t\t\t\tvar result = Sizzle.attr( elem, name );\n\ \n\ \t\t\t\tif ( result == null ) {\n\ \t\t\t\t\treturn operator === \"!=\";\n\ \t\t\t\t}\n\ \t\t\t\tif ( !operator ) {\n\ \t\t\t\t\treturn true;\n\ \t\t\t\t}\n\ \n\ \t\t\t\tresult += \"\";\n\ \n\ \t\t\t\treturn operator === \"=\" ? result === check :\n\ \t\t\t\t\toperator === \"!=\" ? result !== check :\n\ \t\t\t\t\toperator === \"^=\" ? check && result.indexOf( check ) === 0 :\n\ \t\t\t\t\toperator === \"*=\" ? check && result.indexOf( check ) > -1 :\n\ \t\t\t\t\toperator === \"$=\" ? check && result.slice( -check.length ) === check :\n\ \t\t\t\t\toperator === \"~=\" ? ( \" \" + result + \" \" ).indexOf( check ) > -1 :\n\ \t\t\t\t\toperator === \"|=\" ? result === check || result.slice( 0, check.length + 1 ) === check + \"-\" :\n\ \t\t\t\t\tfalse;\n\ \t\t\t};\n\ \t\t},\n\ \n\ \t\t\"CHILD\": function( type, what, argument, first, last ) {\n\ \t\t\tvar simple = type.slice( 0, 3 ) !== \"nth\",\n\ \t\t\t\tforward = type.slice( -4 ) !== \"last\",\n\ \t\t\t\tofType = what === \"of-type\";\n\ \n\ \t\t\treturn first === 1 && last === 0 ?\n\ \n\ \t\t\t\t// Shortcut for :nth-*(n)\n\ \t\t\t\tfunction( elem ) {\n\ \t\t\t\t\treturn !!elem.parentNode;\n\ \t\t\t\t} :\n\ \n\ \t\t\t\tfunction( elem, context, xml ) {\n\ \t\t\t\t\tvar cache, outerCache, node, diff, nodeIndex, start,\n\ \t\t\t\t\t\tdir = simple !== forward ? \"nextSibling\" : \"previousSibling\",\n\ \t\t\t\t\t\tparent = elem.parentNode,\n\ \t\t\t\t\t\tname = ofType && elem.nodeName.toLowerCase(),\n\ \t\t\t\t\t\tuseCache = !xml && !ofType;\n\ \n\ \t\t\t\t\tif ( parent ) {\n\ \n\ \t\t\t\t\t\t// :(first|last|only)-(child|of-type)\n\ \t\t\t\t\t\tif ( simple ) {\n\ \t\t\t\t\t\t\twhile ( dir ) {\n\ \t\t\t\t\t\t\t\tnode = elem;\n\ \t\t\t\t\t\t\t\twhile ( (node = node[ dir ]) ) {\n\ \t\t\t\t\t\t\t\t\tif ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) {\n\ \t\t\t\t\t\t\t\t\t\treturn false;\n\ \t\t\t\t\t\t\t\t\t}\n\ \t\t\t\t\t\t\t\t}\n\ \t\t\t\t\t\t\t\t// Reverse direction for :only-* (if we haven't yet done so)\n\ \t\t\t\t\t\t\t\tstart = dir = type === \"only\" && !start && \"nextSibling\";\n\ \t\t\t\t\t\t\t}\n\ \t\t\t\t\t\t\treturn true;\n\ \t\t\t\t\t\t}\n\ \n\ \t\t\t\t\t\tstart = [ forward ? parent.firstChild : parent.lastChild ];\n\ \n\ \t\t\t\t\t\t// non-xml :nth-child(...) stores cache data on `parent`\n\ \t\t\t\t\t\tif ( forward && useCache ) {\n\ \t\t\t\t\t\t\t// Seek `elem` from a previously-cached index\n\ \t\t\t\t\t\t\touterCache = parent[ expando ] || (parent[ expando ] = {});\n\ \t\t\t\t\t\t\tcache = outerCache[ type ] || [];\n\ \t\t\t\t\t\t\tnodeIndex = cache[0] === dirruns && cache[1];\n\ \t\t\t\t\t\t\tdiff = cache[0] === dirruns && cache[2];\n\ \t\t\t\t\t\t\tnode = nodeIndex && parent.childNodes[ nodeIndex ];\n\ \n\ \t\t\t\t\t\t\twhile ( (node = ++nodeIndex && node && node[ dir ] ||\n\ \n\ \t\t\t\t\t\t\t\t// Fallback to seeking `elem` from the start\n\ \t\t\t\t\t\t\t\t(diff = nodeIndex = 0) || start.pop()) ) {\n\ \n\ \t\t\t\t\t\t\t\t// When found, cache indexes on `parent` and break\n\ \t\t\t\t\t\t\t\tif ( node.nodeType === 1 && ++diff && node === elem ) {\n\ \t\t\t\t\t\t\t\t\touterCache[ type ] = [ dirruns, nodeIndex, diff ];\n\ \t\t\t\t\t\t\t\t\tbreak;\n\ \t\t\t\t\t\t\t\t}\n\ \t\t\t\t\t\t\t}\n\ \n\ \t\t\t\t\t\t// Use previously-cached element index if available\n\ \t\t\t\t\t\t} else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) {\n\ \t\t\t\t\t\t\tdiff = cache[1];\n\ \n\ \t\t\t\t\t\t// xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)\n\ \t\t\t\t\t\t} else {\n\ \t\t\t\t\t\t\t// Use the same loop as above to seek `elem` from the start\n\ \t\t\t\t\t\t\twhile ( (node = ++nodeIndex && node && node[ dir ] ||\n\ \t\t\t\t\t\t\t\t(diff = nodeIndex = 0) || start.pop()) ) {\n\ \n\ \t\t\t\t\t\t\t\tif ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) {\n\ \t\t\t\t\t\t\t\t\t// Cache the index of each encountered element\n\ \t\t\t\t\t\t\t\t\tif ( useCache ) {\n\ \t\t\t\t\t\t\t\t\t\t(node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ];\n\ \t\t\t\t\t\t\t\t\t}\n\ \n\ \t\t\t\t\t\t\t\t\tif ( node === elem ) {\n\ \t\t\t\t\t\t\t\t\t\tbreak;\n\ \t\t\t\t\t\t\t\t\t}\n\ \t\t\t\t\t\t\t\t}\n\ \t\t\t\t\t\t\t}\n\ \t\t\t\t\t\t}\n\ \n\ \t\t\t\t\t\t// Incorporate the offset, then check against cycle size\n\ \t\t\t\t\t\tdiff -= last;\n\ \t\t\t\t\t\treturn diff === first || ( diff % first === 0 && diff / first >= 0 );\n\ \t\t\t\t\t}\n\ \t\t\t\t};\n\ \t\t},\n\ \n\ \t\t\"PSEUDO\": function( pseudo, argument ) {\n\ \t\t\t// pseudo-class names are case-insensitive\n\ \t\t\t// http://www.w3.org/TR/selectors/#pseudo-classes\n\ \t\t\t// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters\n\ \t\t\t// Remember that setFilters inherits from pseudos\n\ \t\t\tvar args,\n\ \t\t\t\tfn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||\n\ \t\t\t\t\tSizzle.error( \"unsupported pseudo: \" + pseudo );\n\ \n\ \t\t\t// The user may use createPseudo to indicate that\n\ \t\t\t// arguments are needed to create the filter function\n\ \t\t\t// just as Sizzle does\n\ \t\t\tif ( fn[ expando ] ) {\n\ \t\t\t\treturn fn( argument );\n\ \t\t\t}\n\ \n\ \t\t\t// But maintain support for old signatures\n\ \t\t\tif ( fn.length > 1 ) {\n\ \t\t\t\targs = [ pseudo, pseudo, \"\", argument ];\n\ \t\t\t\treturn Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?\n\ \t\t\t\t\tmarkFunction(function( seed, matches ) {\n\ \t\t\t\t\t\tvar idx,\n\ \t\t\t\t\t\t\tmatched = fn( seed, argument ),\n\ \t\t\t\t\t\t\ti = matched.length;\n\ \t\t\t\t\t\twhile ( i-- ) {\n\ \t\t\t\t\t\t\tidx = indexOf.call( seed, matched[i] );\n\ \t\t\t\t\t\t\tseed[ idx ] = !( matches[ idx ] = matched[i] );\n\ \t\t\t\t\t\t}\n\ \t\t\t\t\t}) :\n\ \t\t\t\t\tfunction( elem ) {\n\ \t\t\t\t\t\treturn fn( elem, 0, args );\n\ \t\t\t\t\t};\n\ \t\t\t}\n\ \n\ \t\t\treturn fn;\n\ \t\t}\n\ \t},\n\ \n\ \tpseudos: {\n\ \t\t// Potentially complex pseudos\n\ \t\t\"not\": markFunction(function( selector ) {\n\ \t\t\t// Trim the selector passed to compile\n\ \t\t\t// to avoid treating leading and trailing\n\ \t\t\t// spaces as combinators\n\ \t\t\tvar input = [],\n\ \t\t\t\tresults = [],\n\ \t\t\t\tmatcher = compile( selector.replace( rtrim, \"$1\" ) );\n\ \n\ \t\t\treturn matcher[ expando ] ?\n\ \t\t\t\tmarkFunction(function( seed, matches, context, xml ) {\n\ \t\t\t\t\tvar elem,\n\ \t\t\t\t\t\tunmatched = matcher( seed, null, xml, [] ),\n\ \t\t\t\t\t\ti = seed.length;\n\ \n\ \t\t\t\t\t// Match elements unmatched by `matcher`\n\ \t\t\t\t\twhile ( i-- ) {\n\ \t\t\t\t\t\tif ( (elem = unmatched[i]) ) {\n\ \t\t\t\t\t\t\tseed[i] = !(matches[i] = elem);\n\ \t\t\t\t\t\t}\n\ \t\t\t\t\t}\n\ \t\t\t\t}) :\n\ \t\t\t\tfunction( elem, context, xml ) {\n\ \t\t\t\t\tinput[0] = elem;\n\ \t\t\t\t\tmatcher( input, null, xml, results );\n\ \t\t\t\t\treturn !results.pop();\n\ \t\t\t\t};\n\ \t\t}),\n\ \n\ \t\t\"has\": markFunction(function( selector ) {\n\ \t\t\treturn function( elem ) {\n\ \t\t\t\treturn Sizzle( selector, elem ).length > 0;\n\ \t\t\t};\n\ \t\t}),\n\ \n\ \t\t\"contains\": markFunction(function( text ) {\n\ \t\t\treturn function( elem ) {\n\ \t\t\t\treturn ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;\n\ \t\t\t};\n\ \t\t}),\n\ \n\ \t\t// \"Whether an element is represented by a :lang() selector\n\ \t\t// is based solely on the element's language value\n\ \t\t// being equal to the identifier C,\n\ \t\t// or beginning with the identifier C immediately followed by \"-\".\n\ \t\t// The matching of C against the element's language value is performed case-insensitively.\n\ \t\t// The identifier C does not have to be a valid language name.\"\n\ \t\t// http://www.w3.org/TR/selectors/#lang-pseudo\n\ \t\t\"lang\": markFunction( function( lang ) {\n\ \t\t\t// lang value must be a valid identifier\n\ \t\t\tif ( !ridentifier.test(lang || \"\") ) {\n\ \t\t\t\tSizzle.error( \"unsupported lang: \" + lang );\n\ \t\t\t}\n\ \t\t\tlang = lang.replace( runescape, funescape ).toLowerCase();\n\ \t\t\treturn function( elem ) {\n\ \t\t\t\tvar elemLang;\n\ \t\t\t\tdo {\n\ \t\t\t\t\tif ( (elemLang = documentIsHTML ?\n\ \t\t\t\t\t\telem.lang :\n\ \t\t\t\t\t\telem.getAttribute(\"xml:lang\") || elem.getAttribute(\"lang\")) ) {\n\ \n\ \t\t\t\t\t\telemLang = elemLang.toLowerCase();\n\ \t\t\t\t\t\treturn elemLang === lang || elemLang.indexOf( lang + \"-\" ) === 0;\n\ \t\t\t\t\t}\n\ \t\t\t\t} while ( (elem = elem.parentNode) && elem.nodeType === 1 );\n\ \t\t\t\treturn false;\n\ \t\t\t};\n\ \t\t}),\n\ \n\ \t\t// Miscellaneous\n\ \t\t\"target\": function( elem ) {\n\ \t\t\tvar hash = window.location && window.location.hash;\n\ \t\t\treturn hash && hash.slice( 1 ) === elem.id;\n\ \t\t},\n\ \n\ \t\t\"root\": function( elem ) {\n\ \t\t\treturn elem === docElem;\n\ \t\t},\n\ \n\ \t\t\"focus\": function( elem ) {\n\ \t\t\treturn elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);\n\ \t\t},\n\ \n\ \t\t// Boolean properties\n\ \t\t\"enabled\": function( elem ) {\n\ \t\t\treturn elem.disabled === false;\n\ \t\t},\n\ \n\ \t\t\"disabled\": function( elem ) {\n\ \t\t\treturn elem.disabled === true;\n\ \t\t},\n\ \n\ \t\t\"checked\": function( elem ) {\n\ \t\t\t// In CSS3, :checked should return both checked and selected elements\n\ \t\t\t// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n\ \t\t\tvar nodeName = elem.nodeName.toLowerCase();\n\ \t\t\treturn (nodeName === \"input\" && !!elem.checked) || (nodeName === \"option\" && !!elem.selected);\n\ \t\t},\n\ \n\ \t\t\"selected\": function( elem ) {\n\ \t\t\t// Accessing this property makes selected-by-default\n\ \t\t\t// options in Safari work properly\n\ \t\t\tif ( elem.parentNode ) {\n\ \t\t\t\telem.parentNode.selectedIndex;\n\ \t\t\t}\n\ \n\ \t\t\treturn elem.selected === true;\n\ \t\t},\n\ \n\ \t\t// Contents\n\ \t\t\"empty\": function( elem ) {\n\ \t\t\t// http://www.w3.org/TR/selectors/#empty-pseudo\n\ \t\t\t// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),\n\ \t\t\t// but not by others (comment: 8; processing instruction: 7; etc.)\n\ \t\t\t// nodeType < 6 works because attributes (2) do not appear as children\n\ \t\t\tfor ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {\n\ \t\t\t\tif ( elem.nodeType < 6 ) {\n\ \t\t\t\t\treturn false;\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t\treturn true;\n\ \t\t},\n\ \n\ \t\t\"parent\": function( elem ) {\n\ \t\t\treturn !Expr.pseudos[\"empty\"]( elem );\n\ \t\t},\n\ \n\ \t\t// Element/input types\n\ \t\t\"header\": function( elem ) {\n\ \t\t\treturn rheader.test( elem.nodeName );\n\ \t\t},\n\ \n\ \t\t\"input\": function( elem ) {\n\ \t\t\treturn rinputs.test( elem.nodeName );\n\ \t\t},\n\ \n\ \t\t\"button\": function( elem ) {\n\ \t\t\tvar name = elem.nodeName.toLowerCase();\n\ \t\t\treturn name === \"input\" && elem.type === \"button\" || name === \"button\";\n\ \t\t},\n\ \n\ \t\t\"text\": function( elem ) {\n\ \t\t\tvar attr;\n\ \t\t\treturn elem.nodeName.toLowerCase() === \"input\" &&\n\ \t\t\t\telem.type === \"text\" &&\n\ \n\ \t\t\t\t// Support: IE<8\n\ \t\t\t\t// New HTML5 attribute values (e.g., \"search\") appear with elem.type === \"text\"\n\ \t\t\t\t( (attr = elem.getAttribute(\"type\")) == null || attr.toLowerCase() === \"text\" );\n\ \t\t},\n\ \n\ \t\t// Position-in-collection\n\ \t\t\"first\": createPositionalPseudo(function() {\n\ \t\t\treturn [ 0 ];\n\ \t\t}),\n\ \n\ \t\t\"last\": createPositionalPseudo(function( matchIndexes, length ) {\n\ \t\t\treturn [ length - 1 ];\n\ \t\t}),\n\ \n\ \t\t\"eq\": createPositionalPseudo(function( matchIndexes, length, argument ) {\n\ \t\t\treturn [ argument < 0 ? argument + length : argument ];\n\ \t\t}),\n\ \n\ \t\t\"even\": createPositionalPseudo(function( matchIndexes, length ) {\n\ \t\t\tvar i = 0;\n\ \t\t\tfor ( ; i < length; i += 2 ) {\n\ \t\t\t\tmatchIndexes.push( i );\n\ \t\t\t}\n\ \t\t\treturn matchIndexes;\n\ \t\t}),\n\ \n\ \t\t\"odd\": createPositionalPseudo(function( matchIndexes, length ) {\n\ \t\t\tvar i = 1;\n\ \t\t\tfor ( ; i < length; i += 2 ) {\n\ \t\t\t\tmatchIndexes.push( i );\n\ \t\t\t}\n\ \t\t\treturn matchIndexes;\n\ \t\t}),\n\ \n\ \t\t\"lt\": createPositionalPseudo(function( matchIndexes, length, argument ) {\n\ \t\t\tvar i = argument < 0 ? argument + length : argument;\n\ \t\t\tfor ( ; --i >= 0; ) {\n\ \t\t\t\tmatchIndexes.push( i );\n\ \t\t\t}\n\ \t\t\treturn matchIndexes;\n\ \t\t}),\n\ \n\ \t\t\"gt\": createPositionalPseudo(function( matchIndexes, length, argument ) {\n\ \t\t\tvar i = argument < 0 ? argument + length : argument;\n\ \t\t\tfor ( ; ++i < length; ) {\n\ \t\t\t\tmatchIndexes.push( i );\n\ \t\t\t}\n\ \t\t\treturn matchIndexes;\n\ \t\t})\n\ \t}\n\ };\n\ \n\ Expr.pseudos[\"nth\"] = Expr.pseudos[\"eq\"];\n\ \n\ // Add button/input type pseudos\n\ for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {\n\ \tExpr.pseudos[ i ] = createInputPseudo( i );\n\ }\n\ for ( i in { submit: true, reset: true } ) {\n\ \tExpr.pseudos[ i ] = createButtonPseudo( i );\n\ }\n\ \n\ // Easy API for creating new setFilters\n\ function setFilters() {}\n\ setFilters.prototype = Expr.filters = Expr.pseudos;\n\ Expr.setFilters = new setFilters();\n\ \n\ tokenize = Sizzle.tokenize = function( selector, parseOnly ) {\n\ \tvar matched, match, tokens, type,\n\ \t\tsoFar, groups, preFilters,\n\ \t\tcached = tokenCache[ selector + \" \" ];\n\ \n\ \tif ( cached ) {\n\ \t\treturn parseOnly ? 0 : cached.slice( 0 );\n\ \t}\n\ \n\ \tsoFar = selector;\n\ \tgroups = [];\n\ \tpreFilters = Expr.preFilter;\n\ \n\ \twhile ( soFar ) {\n\ \n\ \t\t// Comma and first run\n\ \t\tif ( !matched || (match = rcomma.exec( soFar )) ) {\n\ \t\t\tif ( match ) {\n\ \t\t\t\t// Don't consume trailing commas as valid\n\ \t\t\t\tsoFar = soFar.slice( match[0].length ) || soFar;\n\ \t\t\t}\n\ \t\t\tgroups.push( (tokens = []) );\n\ \t\t}\n\ \n\ \t\tmatched = false;\n\ \n\ \t\t// Combinators\n\ \t\tif ( (match = rcombinators.exec( soFar )) ) {\n\ \t\t\tmatched = match.shift();\n\ \t\t\ttokens.push({\n\ \t\t\t\tvalue: matched,\n\ \t\t\t\t// Cast descendant combinators to space\n\ \t\t\t\ttype: match[0].replace( rtrim, \" \" )\n\ \t\t\t});\n\ \t\t\tsoFar = soFar.slice( matched.length );\n\ \t\t}\n\ \n\ \t\t// Filters\n\ \t\tfor ( type in Expr.filter ) {\n\ \t\t\tif ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||\n\ \t\t\t\t(match = preFilters[ type ]( match ))) ) {\n\ \t\t\t\tmatched = match.shift();\n\ \t\t\t\ttokens.push({\n\ \t\t\t\t\tvalue: matched,\n\ \t\t\t\t\ttype: type,\n\ \t\t\t\t\tmatches: match\n\ \t\t\t\t});\n\ \t\t\t\tsoFar = soFar.slice( matched.length );\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\tif ( !matched ) {\n\ \t\t\tbreak;\n\ \t\t}\n\ \t}\n\ \n\ \t// Return the length of the invalid excess\n\ \t// if we're just parsing\n\ \t// Otherwise, throw an error or return tokens\n\ \treturn parseOnly ?\n\ \t\tsoFar.length :\n\ \t\tsoFar ?\n\ \t\t\tSizzle.error( selector ) :\n\ \t\t\t// Cache the tokens\n\ \t\t\ttokenCache( selector, groups ).slice( 0 );\n\ };\n\ \n\ function toSelector( tokens ) {\n\ \tvar i = 0,\n\ \t\tlen = tokens.length,\n\ \t\tselector = \"\";\n\ \tfor ( ; i < len; i++ ) {\n\ \t\tselector += tokens[i].value;\n\ \t}\n\ \treturn selector;\n\ }\n\ \n\ function addCombinator( matcher, combinator, base ) {\n\ \tvar dir = combinator.dir,\n\ \t\tcheckNonElements = base && dir === \"parentNode\",\n\ \t\tdoneName = done++;\n\ \n\ \treturn combinator.first ?\n\ \t\t// Check against closest ancestor/preceding element\n\ \t\tfunction( elem, context, xml ) {\n\ \t\t\twhile ( (elem = elem[ dir ]) ) {\n\ \t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\ \t\t\t\t\treturn matcher( elem, context, xml );\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t} :\n\ \n\ \t\t// Check against all ancestor/preceding elements\n\ \t\tfunction( elem, context, xml ) {\n\ \t\t\tvar oldCache, outerCache,\n\ \t\t\t\tnewCache = [ dirruns, doneName ];\n\ \n\ \t\t\t// We can't set arbitrary data on XML nodes, so they don't benefit from dir caching\n\ \t\t\tif ( xml ) {\n\ \t\t\t\twhile ( (elem = elem[ dir ]) ) {\n\ \t\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\ \t\t\t\t\t\tif ( matcher( elem, context, xml ) ) {\n\ \t\t\t\t\t\t\treturn true;\n\ \t\t\t\t\t\t}\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \t\t\t} else {\n\ \t\t\t\twhile ( (elem = elem[ dir ]) ) {\n\ \t\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\ \t\t\t\t\t\touterCache = elem[ expando ] || (elem[ expando ] = {});\n\ \t\t\t\t\t\tif ( (oldCache = outerCache[ dir ]) &&\n\ \t\t\t\t\t\t\toldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {\n\ \n\ \t\t\t\t\t\t\t// Assign to newCache so results back-propagate to previous elements\n\ \t\t\t\t\t\t\treturn (newCache[ 2 ] = oldCache[ 2 ]);\n\ \t\t\t\t\t\t} else {\n\ \t\t\t\t\t\t\t// Reuse newcache so results back-propagate to previous elements\n\ \t\t\t\t\t\t\touterCache[ dir ] = newCache;\n\ \n\ \t\t\t\t\t\t\t// A match means we're done; a fail means we have to keep checking\n\ \t\t\t\t\t\t\tif ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {\n\ \t\t\t\t\t\t\t\treturn true;\n\ \t\t\t\t\t\t\t}\n\ \t\t\t\t\t\t}\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t};\n\ }\n\ \n\ function elementMatcher( matchers ) {\n\ \treturn matchers.length > 1 ?\n\ \t\tfunction( elem, context, xml ) {\n\ \t\t\tvar i = matchers.length;\n\ \t\t\twhile ( i-- ) {\n\ \t\t\t\tif ( !matchers[i]( elem, context, xml ) ) {\n\ \t\t\t\t\treturn false;\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t\treturn true;\n\ \t\t} :\n\ \t\tmatchers[0];\n\ }\n\ \n\ function multipleContexts( selector, contexts, results ) {\n\ \tvar i = 0,\n\ \t\tlen = contexts.length;\n\ \tfor ( ; i < len; i++ ) {\n\ \t\tSizzle( selector, contexts[i], results );\n\ \t}\n\ \treturn results;\n\ }\n\ \n\ function condense( unmatched, map, filter, context, xml ) {\n\ \tvar elem,\n\ \t\tnewUnmatched = [],\n\ \t\ti = 0,\n\ \t\tlen = unmatched.length,\n\ \t\tmapped = map != null;\n\ \n\ \tfor ( ; i < len; i++ ) {\n\ \t\tif ( (elem = unmatched[i]) ) {\n\ \t\t\tif ( !filter || filter( elem, context, xml ) ) {\n\ \t\t\t\tnewUnmatched.push( elem );\n\ \t\t\t\tif ( mapped ) {\n\ \t\t\t\t\tmap.push( i );\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t}\n\ \t}\n\ \n\ \treturn newUnmatched;\n\ }\n\ \n\ function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {\n\ \tif ( postFilter && !postFilter[ expando ] ) {\n\ \t\tpostFilter = setMatcher( postFilter );\n\ \t}\n\ \tif ( postFinder && !postFinder[ expando ] ) {\n\ \t\tpostFinder = setMatcher( postFinder, postSelector );\n\ \t}\n\ \treturn markFunction(function( seed, results, context, xml ) {\n\ \t\tvar temp, i, elem,\n\ \t\t\tpreMap = [],\n\ \t\t\tpostMap = [],\n\ \t\t\tpreexisting = results.length,\n\ \n\ \t\t\t// Get initial elements from seed or context\n\ \t\t\telems = seed || multipleContexts( selector || \"*\", context.nodeType ? [ context ] : context, [] ),\n\ \n\ \t\t\t// Prefilter to get matcher input, preserving a map for seed-results synchronization\n\ \t\t\tmatcherIn = preFilter && ( seed || !selector ) ?\n\ \t\t\t\tcondense( elems, preMap, preFilter, context, xml ) :\n\ \t\t\t\telems,\n\ \n\ \t\t\tmatcherOut = matcher ?\n\ \t\t\t\t// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,\n\ \t\t\t\tpostFinder || ( seed ? preFilter : preexisting || postFilter ) ?\n\ \n\ \t\t\t\t\t// ...intermediate processing is necessary\n\ \t\t\t\t\t[] :\n\ \n\ \t\t\t\t\t// ...otherwise use results directly\n\ \t\t\t\t\tresults :\n\ \t\t\t\tmatcherIn;\n\ \n\ \t\t// Find primary matches\n\ \t\tif ( matcher ) {\n\ \t\t\tmatcher( matcherIn, matcherOut, context, xml );\n\ \t\t}\n\ \n\ \t\t// Apply postFilter\n\ \t\tif ( postFilter ) {\n\ \t\t\ttemp = condense( matcherOut, postMap );\n\ \t\t\tpostFilter( temp, [], context, xml );\n\ \n\ \t\t\t// Un-match failing elements by moving them back to matcherIn\n\ \t\t\ti = temp.length;\n\ \t\t\twhile ( i-- ) {\n\ \t\t\t\tif ( (elem = temp[i]) ) {\n\ \t\t\t\t\tmatcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\tif ( seed ) {\n\ \t\t\tif ( postFinder || preFilter ) {\n\ \t\t\t\tif ( postFinder ) {\n\ \t\t\t\t\t// Get the final matcherOut by condensing this intermediate into postFinder contexts\n\ \t\t\t\t\ttemp = [];\n\ \t\t\t\t\ti = matcherOut.length;\n\ \t\t\t\t\twhile ( i-- ) {\n\ \t\t\t\t\t\tif ( (elem = matcherOut[i]) ) {\n\ \t\t\t\t\t\t\t// Restore matcherIn since elem is not yet a final match\n\ \t\t\t\t\t\t\ttemp.push( (matcherIn[i] = elem) );\n\ \t\t\t\t\t\t}\n\ \t\t\t\t\t}\n\ \t\t\t\t\tpostFinder( null, (matcherOut = []), temp, xml );\n\ \t\t\t\t}\n\ \n\ \t\t\t\t// Move matched elements from seed to results to keep them synchronized\n\ \t\t\t\ti = matcherOut.length;\n\ \t\t\t\twhile ( i-- ) {\n\ \t\t\t\t\tif ( (elem = matcherOut[i]) &&\n\ \t\t\t\t\t\t(temp = postFinder ? indexOf.call( seed, elem ) : preMap[i]) > -1 ) {\n\ \n\ \t\t\t\t\t\tseed[temp] = !(results[temp] = elem);\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \t\t\t}\n\ \n\ \t\t// Add elements to results, through postFinder if defined\n\ \t\t} else {\n\ \t\t\tmatcherOut = condense(\n\ \t\t\t\tmatcherOut === results ?\n\ \t\t\t\t\tmatcherOut.splice( preexisting, matcherOut.length ) :\n\ \t\t\t\t\tmatcherOut\n\ \t\t\t);\n\ \t\t\tif ( postFinder ) {\n\ \t\t\t\tpostFinder( null, results, matcherOut, xml );\n\ \t\t\t} else {\n\ \t\t\t\tpush.apply( results, matcherOut );\n\ \t\t\t}\n\ \t\t}\n\ \t});\n\ }\n\ \n\ function matcherFromTokens( tokens ) {\n\ \tvar checkContext, matcher, j,\n\ \t\tlen = tokens.length,\n\ \t\tleadingRelative = Expr.relative[ tokens[0].type ],\n\ \t\timplicitRelative = leadingRelative || Expr.relative[\" \"],\n\ \t\ti = leadingRelative ? 1 : 0,\n\ \n\ \t\t// The foundational matcher ensures that elements are reachable from top-level context(s)\n\ \t\tmatchContext = addCombinator( function( elem ) {\n\ \t\t\treturn elem === checkContext;\n\ \t\t}, implicitRelative, true ),\n\ \t\tmatchAnyContext = addCombinator( function( elem ) {\n\ \t\t\treturn indexOf.call( checkContext, elem ) > -1;\n\ \t\t}, implicitRelative, true ),\n\ \t\tmatchers = [ function( elem, context, xml ) {\n\ \t\t\treturn ( !leadingRelative && ( xml || context !== outermostContext ) ) || (\n\ \t\t\t\t(checkContext = context).nodeType ?\n\ \t\t\t\t\tmatchContext( elem, context, xml ) :\n\ \t\t\t\t\tmatchAnyContext( elem, context, xml ) );\n\ \t\t} ];\n\ \n\ \tfor ( ; i < len; i++ ) {\n\ \t\tif ( (matcher = Expr.relative[ tokens[i].type ]) ) {\n\ \t\t\tmatchers = [ addCombinator(elementMatcher( matchers ), matcher) ];\n\ \t\t} else {\n\ \t\t\tmatcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );\n\ \n\ \t\t\t// Return special upon seeing a positional matcher\n\ \t\t\tif ( matcher[ expando ] ) {\n\ \t\t\t\t// Find the next relative operator (if any) for proper handling\n\ \t\t\t\tj = ++i;\n\ \t\t\t\tfor ( ; j < len; j++ ) {\n\ \t\t\t\t\tif ( Expr.relative[ tokens[j].type ] ) {\n\ \t\t\t\t\t\tbreak;\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \t\t\t\treturn setMatcher(\n\ \t\t\t\t\ti > 1 && elementMatcher( matchers ),\n\ \t\t\t\t\ti > 1 && toSelector(\n\ \t\t\t\t\t\t// If the preceding token was a descendant combinator, insert an implicit any-element `*`\n\ \t\t\t\t\t\ttokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === \" \" ? \"*\" : \"\" })\n\ \t\t\t\t\t).replace( rtrim, \"$1\" ),\n\ \t\t\t\t\tmatcher,\n\ \t\t\t\t\ti < j && matcherFromTokens( tokens.slice( i, j ) ),\n\ \t\t\t\t\tj < len && matcherFromTokens( (tokens = tokens.slice( j )) ),\n\ \t\t\t\t\tj < len && toSelector( tokens )\n\ \t\t\t\t);\n\ \t\t\t}\n\ \t\t\tmatchers.push( matcher );\n\ \t\t}\n\ \t}\n\ \n\ \treturn elementMatcher( matchers );\n\ }\n\ \n\ function matcherFromGroupMatchers( elementMatchers, setMatchers ) {\n\ \tvar bySet = setMatchers.length > 0,\n\ \t\tbyElement = elementMatchers.length > 0,\n\ \t\tsuperMatcher = function( seed, context, xml, results, outermost ) {\n\ \t\t\tvar elem, j, matcher,\n\ \t\t\t\tmatchedCount = 0,\n\ \t\t\t\ti = \"0\",\n\ \t\t\t\tunmatched = seed && [],\n\ \t\t\t\tsetMatched = [],\n\ \t\t\t\tcontextBackup = outermostContext,\n\ \t\t\t\t// We must always have either seed elements or outermost context\n\ \t\t\t\telems = seed || byElement && Expr.find[\"TAG\"]( \"*\", outermost ),\n\ \t\t\t\t// Use integer dirruns iff this is the outermost matcher\n\ \t\t\t\tdirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),\n\ \t\t\t\tlen = elems.length;\n\ \n\ \t\t\tif ( outermost ) {\n\ \t\t\t\toutermostContext = context !== document && context;\n\ \t\t\t}\n\ \n\ \t\t\t// Add elements passing elementMatchers directly to results\n\ \t\t\t// Keep `i` a string if there are no elements so `matchedCount` will be \"00\" below\n\ \t\t\t// Support: IE<9, Safari\n\ \t\t\t// Tolerate NodeList properties (IE: \"length\"; Safari: ) matching elements by id\n\ \t\t\tfor ( ; i !== len && (elem = elems[i]) != null; i++ ) {\n\ \t\t\t\tif ( byElement && elem ) {\n\ \t\t\t\t\tj = 0;\n\ \t\t\t\t\twhile ( (matcher = elementMatchers[j++]) ) {\n\ \t\t\t\t\t\tif ( matcher( elem, context, xml ) ) {\n\ \t\t\t\t\t\t\tresults.push( elem );\n\ \t\t\t\t\t\t\tbreak;\n\ \t\t\t\t\t\t}\n\ \t\t\t\t\t}\n\ \t\t\t\t\tif ( outermost ) {\n\ \t\t\t\t\t\tdirruns = dirrunsUnique;\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \n\ \t\t\t\t// Track unmatched elements for set filters\n\ \t\t\t\tif ( bySet ) {\n\ \t\t\t\t\t// They will have gone through all possible matchers\n\ \t\t\t\t\tif ( (elem = !matcher && elem) ) {\n\ \t\t\t\t\t\tmatchedCount--;\n\ \t\t\t\t\t}\n\ \n\ \t\t\t\t\t// Lengthen the array for every element, matched or not\n\ \t\t\t\t\tif ( seed ) {\n\ \t\t\t\t\t\tunmatched.push( elem );\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \t\t\t}\n\ \n\ \t\t\t// Apply set filters to unmatched elements\n\ \t\t\tmatchedCount += i;\n\ \t\t\tif ( bySet && i !== matchedCount ) {\n\ \t\t\t\tj = 0;\n\ \t\t\t\twhile ( (matcher = setMatchers[j++]) ) {\n\ \t\t\t\t\tmatcher( unmatched, setMatched, context, xml );\n\ \t\t\t\t}\n\ \n\ \t\t\t\tif ( seed ) {\n\ \t\t\t\t\t// Reintegrate element matches to eliminate the need for sorting\n\ \t\t\t\t\tif ( matchedCount > 0 ) {\n\ \t\t\t\t\t\twhile ( i-- ) {\n\ \t\t\t\t\t\t\tif ( !(unmatched[i] || setMatched[i]) ) {\n\ \t\t\t\t\t\t\t\tsetMatched[i] = pop.call( results );\n\ \t\t\t\t\t\t\t}\n\ \t\t\t\t\t\t}\n\ \t\t\t\t\t}\n\ \n\ \t\t\t\t\t// Discard index placeholder values to get only actual matches\n\ \t\t\t\t\tsetMatched = condense( setMatched );\n\ \t\t\t\t}\n\ \n\ \t\t\t\t// Add matches to results\n\ \t\t\t\tpush.apply( results, setMatched );\n\ \n\ \t\t\t\t// Seedless set matches succeeding multiple successful matchers stipulate sorting\n\ \t\t\t\tif ( outermost && !seed && setMatched.length > 0 &&\n\ \t\t\t\t\t( matchedCount + setMatchers.length ) > 1 ) {\n\ \n\ \t\t\t\t\tSizzle.uniqueSort( results );\n\ \t\t\t\t}\n\ \t\t\t}\n\ \n\ \t\t\t// Override manipulation of globals by nested matchers\n\ \t\t\tif ( outermost ) {\n\ \t\t\t\tdirruns = dirrunsUnique;\n\ \t\t\t\toutermostContext = contextBackup;\n\ \t\t\t}\n\ \n\ \t\t\treturn unmatched;\n\ \t\t};\n\ \n\ \treturn bySet ?\n\ \t\tmarkFunction( superMatcher ) :\n\ \t\tsuperMatcher;\n\ }\n\ \n\ compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {\n\ \tvar i,\n\ \t\tsetMatchers = [],\n\ \t\telementMatchers = [],\n\ \t\tcached = compilerCache[ selector + \" \" ];\n\ \n\ \tif ( !cached ) {\n\ \t\t// Generate a function of recursive functions that can be used to check each element\n\ \t\tif ( !match ) {\n\ \t\t\tmatch = tokenize( selector );\n\ \t\t}\n\ \t\ti = match.length;\n\ \t\twhile ( i-- ) {\n\ \t\t\tcached = matcherFromTokens( match[i] );\n\ \t\t\tif ( cached[ expando ] ) {\n\ \t\t\t\tsetMatchers.push( cached );\n\ \t\t\t} else {\n\ \t\t\t\telementMatchers.push( cached );\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\t// Cache the compiled function\n\ \t\tcached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );\n\ \n\ \t\t// Save selector and tokenization\n\ \t\tcached.selector = selector;\n\ \t}\n\ \treturn cached;\n\ };\n\ \n\ /**\n\ * A low-level selection function that works with Sizzle's compiled\n\ * selector functions\n\ * @param {String|Function} selector A selector or a pre-compiled\n\ * selector function built with Sizzle.compile\n\ * @param {Element} context\n\ * @param {Array} [results]\n\ * @param {Array} [seed] A set of elements to match against\n\ */\n\ select = Sizzle.select = function( selector, context, results, seed ) {\n\ \tvar i, tokens, token, type, find,\n\ \t\tcompiled = typeof selector === \"function\" && selector,\n\ \t\tmatch = !seed && tokenize( (selector = compiled.selector || selector) );\n\ \n\ \tresults = results || [];\n\ \n\ \t// Try to minimize operations if there is no seed and only one group\n\ \tif ( match.length === 1 ) {\n\ \n\ \t\t// Take a shortcut and set the context if the root selector is an ID\n\ \t\ttokens = match[0] = match[0].slice( 0 );\n\ \t\tif ( tokens.length > 2 && (token = tokens[0]).type === \"ID\" &&\n\ \t\t\t\tsupport.getById && context.nodeType === 9 && documentIsHTML &&\n\ \t\t\t\tExpr.relative[ tokens[1].type ] ) {\n\ \n\ \t\t\tcontext = ( Expr.find[\"ID\"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];\n\ \t\t\tif ( !context ) {\n\ \t\t\t\treturn results;\n\ \n\ \t\t\t// Precompiled matchers will still verify ancestry, so step up a level\n\ \t\t\t} else if ( compiled ) {\n\ \t\t\t\tcontext = context.parentNode;\n\ \t\t\t}\n\ \n\ \t\t\tselector = selector.slice( tokens.shift().value.length );\n\ \t\t}\n\ \n\ \t\t// Fetch a seed set for right-to-left matching\n\ \t\ti = matchExpr[\"needsContext\"].test( selector ) ? 0 : tokens.length;\n\ \t\twhile ( i-- ) {\n\ \t\t\ttoken = tokens[i];\n\ \n\ \t\t\t// Abort if we hit a combinator\n\ \t\t\tif ( Expr.relative[ (type = token.type) ] ) {\n\ \t\t\t\tbreak;\n\ \t\t\t}\n\ \t\t\tif ( (find = Expr.find[ type ]) ) {\n\ \t\t\t\t// Search, expanding context for leading sibling combinators\n\ \t\t\t\tif ( (seed = find(\n\ \t\t\t\t\ttoken.matches[0].replace( runescape, funescape ),\n\ \t\t\t\t\trsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context\n\ \t\t\t\t)) ) {\n\ \n\ \t\t\t\t\t// If seed is empty or no tokens remain, we can return early\n\ \t\t\t\t\ttokens.splice( i, 1 );\n\ \t\t\t\t\tselector = seed.length && toSelector( tokens );\n\ \t\t\t\t\tif ( !selector ) {\n\ \t\t\t\t\t\tpush.apply( results, seed );\n\ \t\t\t\t\t\treturn results;\n\ \t\t\t\t\t}\n\ \n\ \t\t\t\t\tbreak;\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t}\n\ \t}\n\ \n\ \t// Compile and execute a filtering function if one is not provided\n\ \t// Provide `match` to avoid retokenization if we modified the selector above\n\ \t( compiled || compile( selector, match ) )(\n\ \t\tseed,\n\ \t\tcontext,\n\ \t\t!documentIsHTML,\n\ \t\tresults,\n\ \t\trsibling.test( selector ) && testContext( context.parentNode ) || context\n\ \t);\n\ \treturn results;\n\ };\n\ \n\ // One-time assignments\n\ \n\ // Sort stability\n\ support.sortStable = expando.split(\"\").sort( sortOrder ).join(\"\") === expando;\n\ \n\ // Support: Chrome<14\n\ // Always assume duplicates if they aren't passed to the comparison function\n\ support.detectDuplicates = !!hasDuplicate;\n\ \n\ // Initialize against the default document\n\ setDocument();\n\ \n\ // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)\n\ // Detached nodes confoundingly follow *each other*\n\ support.sortDetached = assert(function( div1 ) {\n\ \t// Should return 1, but returns 4 (following)\n\ \treturn div1.compareDocumentPosition( document.createElement(\"div\") ) & 1;\n\ });\n\ \n\ // Support: IE<8\n\ // Prevent attribute/property \"interpolation\"\n\ // http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx\n\ if ( !assert(function( div ) {\n\ \tdiv.innerHTML = \"\";\n\ \treturn div.firstChild.getAttribute(\"href\") === \"#\" ;\n\ }) ) {\n\ \taddHandle( \"type|href|height|width\", function( elem, name, isXML ) {\n\ \t\tif ( !isXML ) {\n\ \t\t\treturn elem.getAttribute( name, name.toLowerCase() === \"type\" ? 1 : 2 );\n\ \t\t}\n\ \t});\n\ }\n\ \n\ // Support: IE<9\n\ // Use defaultValue in place of getAttribute(\"value\")\n\ if ( !support.attributes || !assert(function( div ) {\n\ \tdiv.innerHTML = \"\";\n\ \tdiv.firstChild.setAttribute( \"value\", \"\" );\n\ \treturn div.firstChild.getAttribute( \"value\" ) === \"\";\n\ }) ) {\n\ \taddHandle( \"value\", function( elem, name, isXML ) {\n\ \t\tif ( !isXML && elem.nodeName.toLowerCase() === \"input\" ) {\n\ \t\t\treturn elem.defaultValue;\n\ \t\t}\n\ \t});\n\ }\n\ \n\ // Support: IE<9\n\ // Use getAttributeNode to fetch booleans when getAttribute lies\n\ if ( !assert(function( div ) {\n\ \treturn div.getAttribute(\"disabled\") == null;\n\ }) ) {\n\ \taddHandle( booleans, function( elem, name, isXML ) {\n\ \t\tvar val;\n\ \t\tif ( !isXML ) {\n\ \t\t\treturn elem[ name ] === true ? name.toLowerCase() :\n\ \t\t\t\t\t(val = elem.getAttributeNode( name )) && val.specified ?\n\ \t\t\t\t\tval.value :\n\ \t\t\t\tnull;\n\ \t\t}\n\ \t});\n\ }\n\ \n\ return Sizzle;\n\ \n\ })( window );\n\ \n\ \n\ \n\ jQuery.find = Sizzle;\n\ jQuery.expr = Sizzle.selectors;\n\ jQuery.expr[\":\"] = jQuery.expr.pseudos;\n\ jQuery.unique = Sizzle.uniqueSort;\n\ jQuery.text = Sizzle.getText;\n\ jQuery.isXMLDoc = Sizzle.isXML;\n\ jQuery.contains = Sizzle.contains;\n\ \n\ \n\ \n\ var rneedsContext = jQuery.expr.match.needsContext;\n\ \n\ var rsingleTag = (/^<(\\w+)\\s*\\/?>(?:<\\/\\1>|)$/);\n\ \n\ \n\ \n\ var risSimple = /^.[^:#\\[\\.,]*$/;\n\ \n\ // Implement the identical functionality for filter and not\n\ function winnow( elements, qualifier, not ) {\n\ \tif ( jQuery.isFunction( qualifier ) ) {\n\ \t\treturn jQuery.grep( elements, function( elem, i ) {\n\ \t\t\t/* jshint -W018 */\n\ \t\t\treturn !!qualifier.call( elem, i, elem ) !== not;\n\ \t\t});\n\ \n\ \t}\n\ \n\ \tif ( qualifier.nodeType ) {\n\ \t\treturn jQuery.grep( elements, function( elem ) {\n\ \t\t\treturn ( elem === qualifier ) !== not;\n\ \t\t});\n\ \n\ \t}\n\ \n\ \tif ( typeof qualifier === \"string\" ) {\n\ \t\tif ( risSimple.test( qualifier ) ) {\n\ \t\t\treturn jQuery.filter( qualifier, elements, not );\n\ \t\t}\n\ \n\ \t\tqualifier = jQuery.filter( qualifier, elements );\n\ \t}\n\ \n\ \treturn jQuery.grep( elements, function( elem ) {\n\ \t\treturn ( jQuery.inArray( elem, qualifier ) >= 0 ) !== not;\n\ \t});\n\ }\n\ \n\ jQuery.filter = function( expr, elems, not ) {\n\ \tvar elem = elems[ 0 ];\n\ \n\ \tif ( not ) {\n\ \t\texpr = \":not(\" + expr + \")\";\n\ \t}\n\ \n\ \treturn elems.length === 1 && elem.nodeType === 1 ?\n\ \t\tjQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [] :\n\ \t\tjQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {\n\ \t\t\treturn elem.nodeType === 1;\n\ \t\t}));\n\ };\n\ \n\ jQuery.fn.extend({\n\ \tfind: function( selector ) {\n\ \t\tvar i,\n\ \t\t\tret = [],\n\ \t\t\tself = this,\n\ \t\t\tlen = self.length;\n\ \n\ \t\tif ( typeof selector !== \"string\" ) {\n\ \t\t\treturn this.pushStack( jQuery( selector ).filter(function() {\n\ \t\t\t\tfor ( i = 0; i < len; i++ ) {\n\ \t\t\t\t\tif ( jQuery.contains( self[ i ], this ) ) {\n\ \t\t\t\t\t\treturn true;\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \t\t\t}) );\n\ \t\t}\n\ \n\ \t\tfor ( i = 0; i < len; i++ ) {\n\ \t\t\tjQuery.find( selector, self[ i ], ret );\n\ \t\t}\n\ \n\ \t\t// Needed because $( selector, context ) becomes $( context ).find( selector )\n\ \t\tret = this.pushStack( len > 1 ? jQuery.unique( ret ) : ret );\n\ \t\tret.selector = this.selector ? this.selector + \" \" + selector : selector;\n\ \t\treturn ret;\n\ \t},\n\ \tfilter: function( selector ) {\n\ \t\treturn this.pushStack( winnow(this, selector || [], false) );\n\ \t},\n\ \tnot: function( selector ) {\n\ \t\treturn this.pushStack( winnow(this, selector || [], true) );\n\ \t},\n\ \tis: function( selector ) {\n\ \t\treturn !!winnow(\n\ \t\t\tthis,\n\ \n\ \t\t\t// If this is a positional/relative selector, check membership in the returned set\n\ \t\t\t// so $(\"p:first\").is(\"p:last\") won't return true for a doc with two \"p\".\n\ \t\t\ttypeof selector === \"string\" && rneedsContext.test( selector ) ?\n\ \t\t\t\tjQuery( selector ) :\n\ \t\t\t\tselector || [],\n\ \t\t\tfalse\n\ \t\t).length;\n\ \t}\n\ });\n\ \n\ \n\ // Initialize a jQuery object\n\ \n\ \n\ // A central reference to the root jQuery(document)\n\ var rootjQuery,\n\ \n\ \t// Use the correct document accordingly with window argument (sandbox)\n\ \tdocument = window.document,\n\ \n\ \t// A simple way to check for HTML strings\n\ \t// Prioritize #id over to avoid XSS via location.hash (#9521)\n\ \t// Strict HTML recognition (#11290: must start with <)\n\ \trquickExpr = /^(?:\\s*(<[\\w\\W]+>)[^>]*|#([\\w-]*))$/,\n\ \n\ \tinit = jQuery.fn.init = function( selector, context ) {\n\ \t\tvar match, elem;\n\ \n\ \t\t// HANDLE: $(\"\"), $(null), $(undefined), $(false)\n\ \t\tif ( !selector ) {\n\ \t\t\treturn this;\n\ \t\t}\n\ \n\ \t\t// Handle HTML strings\n\ \t\tif ( typeof selector === \"string\" ) {\n\ \t\t\tif ( selector.charAt(0) === \"<\" && selector.charAt( selector.length - 1 ) === \">\" && selector.length >= 3 ) {\n\ \t\t\t\t// Assume that strings that start and end with <> are HTML and skip the regex check\n\ \t\t\t\tmatch = [ null, selector, null ];\n\ \n\ \t\t\t} else {\n\ \t\t\t\tmatch = rquickExpr.exec( selector );\n\ \t\t\t}\n\ \n\ \t\t\t// Match html or make sure no context is specified for #id\n\ \t\t\tif ( match && (match[1] || !context) ) {\n\ \n\ \t\t\t\t// HANDLE: $(html) -> $(array)\n\ \t\t\t\tif ( match[1] ) {\n\ \t\t\t\t\tcontext = context instanceof jQuery ? context[0] : context;\n\ \n\ \t\t\t\t\t// scripts is true for back-compat\n\ \t\t\t\t\t// Intentionally let the error be thrown if parseHTML is not present\n\ \t\t\t\t\tjQuery.merge( this, jQuery.parseHTML(\n\ \t\t\t\t\t\tmatch[1],\n\ \t\t\t\t\t\tcontext && context.nodeType ? context.ownerDocument || context : document,\n\ \t\t\t\t\t\ttrue\n\ \t\t\t\t\t) );\n\ \n\ \t\t\t\t\t// HANDLE: $(html, props)\n\ \t\t\t\t\tif ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {\n\ \t\t\t\t\t\tfor ( match in context ) {\n\ \t\t\t\t\t\t\t// Properties of context are called as methods if possible\n\ \t\t\t\t\t\t\tif ( jQuery.isFunction( this[ match ] ) ) {\n\ \t\t\t\t\t\t\t\tthis[ match ]( context[ match ] );\n\ \n\ \t\t\t\t\t\t\t// ...and otherwise set as attributes\n\ \t\t\t\t\t\t\t} else {\n\ \t\t\t\t\t\t\t\tthis.attr( match, context[ match ] );\n\ \t\t\t\t\t\t\t}\n\ \t\t\t\t\t\t}\n\ \t\t\t\t\t}\n\ \n\ \t\t\t\t\treturn this;\n\ \n\ \t\t\t\t// HANDLE: $(#id)\n\ \t\t\t\t} else {\n\ \t\t\t\t\telem = document.getElementById( match[2] );\n\ \n\ \t\t\t\t\t// Check parentNode to catch when Blackberry 4.6 returns\n\ \t\t\t\t\t// nodes that are no longer in the document #6963\n\ \t\t\t\t\tif ( elem && elem.parentNode ) {\n\ \t\t\t\t\t\t// Handle the case where IE and Opera return items\n\ \t\t\t\t\t\t// by name instead of ID\n\ \t\t\t\t\t\tif ( elem.id !== match[2] ) {\n\ \t\t\t\t\t\t\treturn rootjQuery.find( selector );\n\ \t\t\t\t\t\t}\n\ \n\ \t\t\t\t\t\t// Otherwise, we inject the element directly into the jQuery object\n\ \t\t\t\t\t\tthis.length = 1;\n\ \t\t\t\t\t\tthis[0] = elem;\n\ \t\t\t\t\t}\n\ \n\ \t\t\t\t\tthis.context = document;\n\ \t\t\t\t\tthis.selector = selector;\n\ \t\t\t\t\treturn this;\n\ \t\t\t\t}\n\ \n\ \t\t\t// HANDLE: $(expr, $(...))\n\ \t\t\t} else if ( !context || context.jquery ) {\n\ \t\t\t\treturn ( context || rootjQuery ).find( selector );\n\ \n\ \t\t\t// HANDLE: $(expr, context)\n\ \t\t\t// (which is just equivalent to: $(context).find(expr)\n\ \t\t\t} else {\n\ \t\t\t\treturn this.constructor( context ).find( selector );\n\ \t\t\t}\n\ \n\ \t\t// HANDLE: $(DOMElement)\n\ \t\t} else if ( selector.nodeType ) {\n\ \t\t\tthis.context = this[0] = selector;\n\ \t\t\tthis.length = 1;\n\ \t\t\treturn this;\n\ \n\ \t\t// HANDLE: $(function)\n\ \t\t// Shortcut for document ready\n\ \t\t} else if ( jQuery.isFunction( selector ) ) {\n\ \t\t\treturn typeof rootjQuery.ready !== \"undefined\" ?\n\ \t\t\t\trootjQuery.ready( selector ) :\n\ \t\t\t\t// Execute immediately if ready is not present\n\ \t\t\t\tselector( jQuery );\n\ \t\t}\n\ \n\ \t\tif ( selector.selector !== undefined ) {\n\ \t\t\tthis.selector = selector.selector;\n\ \t\t\tthis.context = selector.context;\n\ \t\t}\n\ \n\ \t\treturn jQuery.makeArray( selector, this );\n\ \t};\n\ \n\ // Give the init function the jQuery prototype for later instantiation\n\ init.prototype = jQuery.fn;\n\ \n\ // Initialize central reference\n\ rootjQuery = jQuery( document );\n\ \n\ \n\ var rparentsprev = /^(?:parents|prev(?:Until|All))/,\n\ \t// methods guaranteed to produce a unique set when starting from a unique set\n\ \tguaranteedUnique = {\n\ \t\tchildren: true,\n\ \t\tcontents: true,\n\ \t\tnext: true,\n\ \t\tprev: true\n\ \t};\n\ \n\ jQuery.extend({\n\ \tdir: function( elem, dir, until ) {\n\ \t\tvar matched = [],\n\ \t\t\tcur = elem[ dir ];\n\ \n\ \t\twhile ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {\n\ \t\t\tif ( cur.nodeType === 1 ) {\n\ \t\t\t\tmatched.push( cur );\n\ \t\t\t}\n\ \t\t\tcur = cur[dir];\n\ \t\t}\n\ \t\treturn matched;\n\ \t},\n\ \n\ \tsibling: function( n, elem ) {\n\ \t\tvar r = [];\n\ \n\ \t\tfor ( ; n; n = n.nextSibling ) {\n\ \t\t\tif ( n.nodeType === 1 && n !== elem ) {\n\ \t\t\t\tr.push( n );\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\treturn r;\n\ \t}\n\ });\n\ \n\ jQuery.fn.extend({\n\ \thas: function( target ) {\n\ \t\tvar i,\n\ \t\t\ttargets = jQuery( target, this ),\n\ \t\t\tlen = targets.length;\n\ \n\ \t\treturn this.filter(function() {\n\ \t\t\tfor ( i = 0; i < len; i++ ) {\n\ \t\t\t\tif ( jQuery.contains( this, targets[i] ) ) {\n\ \t\t\t\t\treturn true;\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t});\n\ \t},\n\ \n\ \tclosest: function( selectors, context ) {\n\ \t\tvar cur,\n\ \t\t\ti = 0,\n\ \t\t\tl = this.length,\n\ \t\t\tmatched = [],\n\ \t\t\tpos = rneedsContext.test( selectors ) || typeof selectors !== \"string\" ?\n\ \t\t\t\tjQuery( selectors, context || this.context ) :\n\ \t\t\t\t0;\n\ \n\ \t\tfor ( ; i < l; i++ ) {\n\ \t\t\tfor ( cur = this[i]; cur && cur !== context; cur = cur.parentNode ) {\n\ \t\t\t\t// Always skip document fragments\n\ \t\t\t\tif ( cur.nodeType < 11 && (pos ?\n\ \t\t\t\t\tpos.index(cur) > -1 :\n\ \n\ \t\t\t\t\t// Don't pass non-elements to Sizzle\n\ \t\t\t\t\tcur.nodeType === 1 &&\n\ \t\t\t\t\t\tjQuery.find.matchesSelector(cur, selectors)) ) {\n\ \n\ \t\t\t\t\tmatched.push( cur );\n\ \t\t\t\t\tbreak;\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\treturn this.pushStack( matched.length > 1 ? jQuery.unique( matched ) : matched );\n\ \t},\n\ \n\ \t// Determine the position of an element within\n\ \t// the matched set of elements\n\ \tindex: function( elem ) {\n\ \n\ \t\t// No argument, return index in parent\n\ \t\tif ( !elem ) {\n\ \t\t\treturn ( this[0] && this[0].parentNode ) ? this.first().prevAll().length : -1;\n\ \t\t}\n\ \n\ \t\t// index in selector\n\ \t\tif ( typeof elem === \"string\" ) {\n\ \t\t\treturn jQuery.inArray( this[0], jQuery( elem ) );\n\ \t\t}\n\ \n\ \t\t// Locate the position of the desired element\n\ \t\treturn jQuery.inArray(\n\ \t\t\t// If it receives a jQuery object, the first element is used\n\ \t\t\telem.jquery ? elem[0] : elem, this );\n\ \t},\n\ \n\ \tadd: function( selector, context ) {\n\ \t\treturn this.pushStack(\n\ \t\t\tjQuery.unique(\n\ \t\t\t\tjQuery.merge( this.get(), jQuery( selector, context ) )\n\ \t\t\t)\n\ \t\t);\n\ \t},\n\ \n\ \taddBack: function( selector ) {\n\ \t\treturn this.add( selector == null ?\n\ \t\t\tthis.prevObject : this.prevObject.filter(selector)\n\ \t\t);\n\ \t}\n\ });\n\ \n\ function sibling( cur, dir ) {\n\ \tdo {\n\ \t\tcur = cur[ dir ];\n\ \t} while ( cur && cur.nodeType !== 1 );\n\ \n\ \treturn cur;\n\ }\n\ \n\ jQuery.each({\n\ \tparent: function( elem ) {\n\ \t\tvar parent = elem.parentNode;\n\ \t\treturn parent && parent.nodeType !== 11 ? parent : null;\n\ \t},\n\ \tparents: function( elem ) {\n\ \t\treturn jQuery.dir( elem, \"parentNode\" );\n\ \t},\n\ \tparentsUntil: function( elem, i, until ) {\n\ \t\treturn jQuery.dir( elem, \"parentNode\", until );\n\ \t},\n\ \tnext: function( elem ) {\n\ \t\treturn sibling( elem, \"nextSibling\" );\n\ \t},\n\ \tprev: function( elem ) {\n\ \t\treturn sibling( elem, \"previousSibling\" );\n\ \t},\n\ \tnextAll: function( elem ) {\n\ \t\treturn jQuery.dir( elem, \"nextSibling\" );\n\ \t},\n\ \tprevAll: function( elem ) {\n\ \t\treturn jQuery.dir( elem, \"previousSibling\" );\n\ \t},\n\ \tnextUntil: function( elem, i, until ) {\n\ \t\treturn jQuery.dir( elem, \"nextSibling\", until );\n\ \t},\n\ \tprevUntil: function( elem, i, until ) {\n\ \t\treturn jQuery.dir( elem, \"previousSibling\", until );\n\ \t},\n\ \tsiblings: function( elem ) {\n\ \t\treturn jQuery.sibling( ( elem.parentNode || {} ).firstChild, elem );\n\ \t},\n\ \tchildren: function( elem ) {\n\ \t\treturn jQuery.sibling( elem.firstChild );\n\ \t},\n\ \tcontents: function( elem ) {\n\ \t\treturn jQuery.nodeName( elem, \"iframe\" ) ?\n\ \t\t\telem.contentDocument || elem.contentWindow.document :\n\ \t\t\tjQuery.merge( [], elem.childNodes );\n\ \t}\n\ }, function( name, fn ) {\n\ \tjQuery.fn[ name ] = function( until, selector ) {\n\ \t\tvar ret = jQuery.map( this, fn, until );\n\ \n\ \t\tif ( name.slice( -5 ) !== \"Until\" ) {\n\ \t\t\tselector = until;\n\ \t\t}\n\ \n\ \t\tif ( selector && typeof selector === \"string\" ) {\n\ \t\t\tret = jQuery.filter( selector, ret );\n\ \t\t}\n\ \n\ \t\tif ( this.length > 1 ) {\n\ \t\t\t// Remove duplicates\n\ \t\t\tif ( !guaranteedUnique[ name ] ) {\n\ \t\t\t\tret = jQuery.unique( ret );\n\ \t\t\t}\n\ \n\ \t\t\t// Reverse order for parents* and prev-derivatives\n\ \t\t\tif ( rparentsprev.test( name ) ) {\n\ \t\t\t\tret = ret.reverse();\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\treturn this.pushStack( ret );\n\ \t};\n\ });\n\ var rnotwhite = (/\\S+/g);\n\ \n\ \n\ \n\ // String to Object options format cache\n\ var optionsCache = {};\n\ \n\ // Convert String-formatted options into Object-formatted ones and store in cache\n\ function createOptions( options ) {\n\ \tvar object = optionsCache[ options ] = {};\n\ \tjQuery.each( options.match( rnotwhite ) || [], function( _, flag ) {\n\ \t\tobject[ flag ] = true;\n\ \t});\n\ \treturn object;\n\ }\n\ \n\ /*\n\ * Create a callback list using the following parameters:\n\ *\n\ *\toptions: an optional list of space-separated options that will change how\n\ *\t\t\tthe callback list behaves or a more traditional option object\n\ *\n\ * By default a callback list will act like an event callback list and can be\n\ * \"fired\" multiple times.\n\ *\n\ * Possible options:\n\ *\n\ *\tonce:\t\t\twill ensure the callback list can only be fired once (like a Deferred)\n\ *\n\ *\tmemory:\t\t\twill keep track of previous values and will call any callback added\n\ *\t\t\t\t\tafter the list has been fired right away with the latest \"memorized\"\n\ *\t\t\t\t\tvalues (like a Deferred)\n\ *\n\ *\tunique:\t\t\twill ensure a callback can only be added once (no duplicate in the list)\n\ *\n\ *\tstopOnFalse:\tinterrupt callings when a callback returns false\n\ *\n\ */\n\ jQuery.Callbacks = function( options ) {\n\ \n\ \t// Convert options from String-formatted to Object-formatted if needed\n\ \t// (we check in cache first)\n\ \toptions = typeof options === \"string\" ?\n\ \t\t( optionsCache[ options ] || createOptions( options ) ) :\n\ \t\tjQuery.extend( {}, options );\n\ \n\ \tvar // Flag to know if list is currently firing\n\ \t\tfiring,\n\ \t\t// Last fire value (for non-forgettable lists)\n\ \t\tmemory,\n\ \t\t// Flag to know if list was already fired\n\ \t\tfired,\n\ \t\t// End of the loop when firing\n\ \t\tfiringLength,\n\ \t\t// Index of currently firing callback (modified by remove if needed)\n\ \t\tfiringIndex,\n\ \t\t// First callback to fire (used internally by add and fireWith)\n\ \t\tfiringStart,\n\ \t\t// Actual callback list\n\ \t\tlist = [],\n\ \t\t// Stack of fire calls for repeatable lists\n\ \t\tstack = !options.once && [],\n\ \t\t// Fire callbacks\n\ \t\tfire = function( data ) {\n\ \t\t\tmemory = options.memory && data;\n\ \t\t\tfired = true;\n\ \t\t\tfiringIndex = firingStart || 0;\n\ \t\t\tfiringStart = 0;\n\ \t\t\tfiringLength = list.length;\n\ \t\t\tfiring = true;\n\ \t\t\tfor ( ; list && firingIndex < firingLength; firingIndex++ ) {\n\ \t\t\t\tif ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {\n\ \t\t\t\t\tmemory = false; // To prevent further calls using add\n\ \t\t\t\t\tbreak;\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t\tfiring = false;\n\ \t\t\tif ( list ) {\n\ \t\t\t\tif ( stack ) {\n\ \t\t\t\t\tif ( stack.length ) {\n\ \t\t\t\t\t\tfire( stack.shift() );\n\ \t\t\t\t\t}\n\ \t\t\t\t} else if ( memory ) {\n\ \t\t\t\t\tlist = [];\n\ \t\t\t\t} else {\n\ \t\t\t\t\tself.disable();\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t},\n\ \t\t// Actual Callbacks object\n\ \t\tself = {\n\ \t\t\t// Add a callback or a collection of callbacks to the list\n\ \t\t\tadd: function() {\n\ \t\t\t\tif ( list ) {\n\ \t\t\t\t\t// First, we save the current length\n\ \t\t\t\t\tvar start = list.length;\n\ \t\t\t\t\t(function add( args ) {\n\ \t\t\t\t\t\tjQuery.each( args, function( _, arg ) {\n\ \t\t\t\t\t\t\tvar type = jQuery.type( arg );\n\ \t\t\t\t\t\t\tif ( type === \"function\" ) {\n\ \t\t\t\t\t\t\t\tif ( !options.unique || !self.has( arg ) ) {\n\ \t\t\t\t\t\t\t\t\tlist.push( arg );\n\ \t\t\t\t\t\t\t\t}\n\ \t\t\t\t\t\t\t} else if ( arg && arg.length && type !== \"string\" ) {\n\ \t\t\t\t\t\t\t\t// Inspect recursively\n\ \t\t\t\t\t\t\t\tadd( arg );\n\ \t\t\t\t\t\t\t}\n\ \t\t\t\t\t\t});\n\ \t\t\t\t\t})( arguments );\n\ \t\t\t\t\t// Do we need to add the callbacks to the\n\ \t\t\t\t\t// current firing batch?\n\ \t\t\t\t\tif ( firing ) {\n\ \t\t\t\t\t\tfiringLength = list.length;\n\ \t\t\t\t\t// With memory, if we're not firing then\n\ \t\t\t\t\t// we should call right away\n\ \t\t\t\t\t} else if ( memory ) {\n\ \t\t\t\t\t\tfiringStart = start;\n\ \t\t\t\t\t\tfire( memory );\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \t\t\t\treturn this;\n\ \t\t\t},\n\ \t\t\t// Remove a callback from the list\n\ \t\t\tremove: function() {\n\ \t\t\t\tif ( list ) {\n\ \t\t\t\t\tjQuery.each( arguments, function( _, arg ) {\n\ \t\t\t\t\t\tvar index;\n\ \t\t\t\t\t\twhile ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {\n\ \t\t\t\t\t\t\tlist.splice( index, 1 );\n\ \t\t\t\t\t\t\t// Handle firing indexes\n\ \t\t\t\t\t\t\tif ( firing ) {\n\ \t\t\t\t\t\t\t\tif ( index <= firingLength ) {\n\ \t\t\t\t\t\t\t\t\tfiringLength--;\n\ \t\t\t\t\t\t\t\t}\n\ \t\t\t\t\t\t\t\tif ( index <= firingIndex ) {\n\ \t\t\t\t\t\t\t\t\tfiringIndex--;\n\ \t\t\t\t\t\t\t\t}\n\ \t\t\t\t\t\t\t}\n\ \t\t\t\t\t\t}\n\ \t\t\t\t\t});\n\ \t\t\t\t}\n\ \t\t\t\treturn this;\n\ \t\t\t},\n\ \t\t\t// Check if a given callback is in the list.\n\ \t\t\t// If no argument is given, return whether or not list has callbacks attached.\n\ \t\t\thas: function( fn ) {\n\ \t\t\t\treturn fn ? jQuery.inArray( fn, list ) > -1 : !!( list && list.length );\n\ \t\t\t},\n\ \t\t\t// Remove all callbacks from the list\n\ \t\t\tempty: function() {\n\ \t\t\t\tlist = [];\n\ \t\t\t\tfiringLength = 0;\n\ \t\t\t\treturn this;\n\ \t\t\t},\n\ \t\t\t// Have the list do nothing anymore\n\ \t\t\tdisable: function() {\n\ \t\t\t\tlist = stack = memory = undefined;\n\ \t\t\t\treturn this;\n\ \t\t\t},\n\ \t\t\t// Is it disabled?\n\ \t\t\tdisabled: function() {\n\ \t\t\t\treturn !list;\n\ \t\t\t},\n\ \t\t\t// Lock the list in its current state\n\ \t\t\tlock: function() {\n\ \t\t\t\tstack = undefined;\n\ \t\t\t\tif ( !memory ) {\n\ \t\t\t\t\tself.disable();\n\ \t\t\t\t}\n\ \t\t\t\treturn this;\n\ \t\t\t},\n\ \t\t\t// Is it locked?\n\ \t\t\tlocked: function() {\n\ \t\t\t\treturn !stack;\n\ \t\t\t},\n\ \t\t\t// Call all callbacks with the given context and arguments\n\ \t\t\tfireWith: function( context, args ) {\n\ \t\t\t\tif ( list && ( !fired || stack ) ) {\n\ \t\t\t\t\targs = args || [];\n\ \t\t\t\t\targs = [ context, args.slice ? args.slice() : args ];\n\ \t\t\t\t\tif ( firing ) {\n\ \t\t\t\t\t\tstack.push( args );\n\ \t\t\t\t\t} else {\n\ \t\t\t\t\t\tfire( args );\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \t\t\t\treturn this;\n\ \t\t\t},\n\ \t\t\t// Call all the callbacks with the given arguments\n\ \t\t\tfire: function() {\n\ \t\t\t\tself.fireWith( this, arguments );\n\ \t\t\t\treturn this;\n\ \t\t\t},\n\ \t\t\t// To know if the callbacks have already been called at least once\n\ \t\t\tfired: function() {\n\ \t\t\t\treturn !!fired;\n\ \t\t\t}\n\ \t\t};\n\ \n\ \treturn self;\n\ };\n\ \n\ \n\ jQuery.extend({\n\ \n\ \tDeferred: function( func ) {\n\ \t\tvar tuples = [\n\ \t\t\t\t// action, add listener, listener list, final state\n\ \t\t\t\t[ \"resolve\", \"done\", jQuery.Callbacks(\"once memory\"), \"resolved\" ],\n\ \t\t\t\t[ \"reject\", \"fail\", jQuery.Callbacks(\"once memory\"), \"rejected\" ],\n\ \t\t\t\t[ \"notify\", \"progress\", jQuery.Callbacks(\"memory\") ]\n\ \t\t\t],\n\ \t\t\tstate = \"pending\",\n\ \t\t\tpromise = {\n\ \t\t\t\tstate: function() {\n\ \t\t\t\t\treturn state;\n\ \t\t\t\t},\n\ \t\t\t\talways: function() {\n\ \t\t\t\t\tdeferred.done( arguments ).fail( arguments );\n\ \t\t\t\t\treturn this;\n\ \t\t\t\t},\n\ \t\t\t\tthen: function( /* fnDone, fnFail, fnProgress */ ) {\n\ \t\t\t\t\tvar fns = arguments;\n\ \t\t\t\t\treturn jQuery.Deferred(function( newDefer ) {\n\ \t\t\t\t\t\tjQuery.each( tuples, function( i, tuple ) {\n\ \t\t\t\t\t\t\tvar fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];\n\ \t\t\t\t\t\t\t// deferred[ done | fail | progress ] for forwarding actions to newDefer\n\ \t\t\t\t\t\t\tdeferred[ tuple[1] ](function() {\n\ \t\t\t\t\t\t\t\tvar returned = fn && fn.apply( this, arguments );\n\ \t\t\t\t\t\t\t\tif ( returned && jQuery.isFunction( returned.promise ) ) {\n\ \t\t\t\t\t\t\t\t\treturned.promise()\n\ \t\t\t\t\t\t\t\t\t\t.done( newDefer.resolve )\n\ \t\t\t\t\t\t\t\t\t\t.fail( newDefer.reject )\n\ \t\t\t\t\t\t\t\t\t\t.progress( newDefer.notify );\n\ \t\t\t\t\t\t\t\t} else {\n\ \t\t\t\t\t\t\t\t\tnewDefer[ tuple[ 0 ] + \"With\" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );\n\ \t\t\t\t\t\t\t\t}\n\ \t\t\t\t\t\t\t});\n\ \t\t\t\t\t\t});\n\ \t\t\t\t\t\tfns = null;\n\ \t\t\t\t\t}).promise();\n\ \t\t\t\t},\n\ \t\t\t\t// Get a promise for this deferred\n\ \t\t\t\t// If obj is provided, the promise aspect is added to the object\n\ \t\t\t\tpromise: function( obj ) {\n\ \t\t\t\t\treturn obj != null ? jQuery.extend( obj, promise ) : promise;\n\ \t\t\t\t}\n\ \t\t\t},\n\ \t\t\tdeferred = {};\n\ \n\ \t\t// Keep pipe for back-compat\n\ \t\tpromise.pipe = promise.then;\n\ \n\ \t\t// Add list-specific methods\n\ \t\tjQuery.each( tuples, function( i, tuple ) {\n\ \t\t\tvar list = tuple[ 2 ],\n\ \t\t\t\tstateString = tuple[ 3 ];\n\ \n\ \t\t\t// promise[ done | fail | progress ] = list.add\n\ \t\t\tpromise[ tuple[1] ] = list.add;\n\ \n\ \t\t\t// Handle state\n\ \t\t\tif ( stateString ) {\n\ \t\t\t\tlist.add(function() {\n\ \t\t\t\t\t// state = [ resolved | rejected ]\n\ \t\t\t\t\tstate = stateString;\n\ \n\ \t\t\t\t// [ reject_list | resolve_list ].disable; progress_list.lock\n\ \t\t\t\t}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );\n\ \t\t\t}\n\ \n\ \t\t\t// deferred[ resolve | reject | notify ]\n\ \t\t\tdeferred[ tuple[0] ] = function() {\n\ \t\t\t\tdeferred[ tuple[0] + \"With\" ]( this === deferred ? promise : this, arguments );\n\ \t\t\t\treturn this;\n\ \t\t\t};\n\ \t\t\tdeferred[ tuple[0] + \"With\" ] = list.fireWith;\n\ \t\t});\n\ \n\ \t\t// Make the deferred a promise\n\ \t\tpromise.promise( deferred );\n\ \n\ \t\t// Call given func if any\n\ \t\tif ( func ) {\n\ \t\t\tfunc.call( deferred, deferred );\n\ \t\t}\n\ \n\ \t\t// All done!\n\ \t\treturn deferred;\n\ \t},\n\ \n\ \t// Deferred helper\n\ \twhen: function( subordinate /* , ..., subordinateN */ ) {\n\ \t\tvar i = 0,\n\ \t\t\tresolveValues = slice.call( arguments ),\n\ \t\t\tlength = resolveValues.length,\n\ \n\ \t\t\t// the count of uncompleted subordinates\n\ \t\t\tremaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,\n\ \n\ \t\t\t// the master Deferred. If resolveValues consist of only a single Deferred, just use that.\n\ \t\t\tdeferred = remaining === 1 ? subordinate : jQuery.Deferred(),\n\ \n\ \t\t\t// Update function for both resolve and progress values\n\ \t\t\tupdateFunc = function( i, contexts, values ) {\n\ \t\t\t\treturn function( value ) {\n\ \t\t\t\t\tcontexts[ i ] = this;\n\ \t\t\t\t\tvalues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;\n\ \t\t\t\t\tif ( values === progressValues ) {\n\ \t\t\t\t\t\tdeferred.notifyWith( contexts, values );\n\ \n\ \t\t\t\t\t} else if ( !(--remaining) ) {\n\ \t\t\t\t\t\tdeferred.resolveWith( contexts, values );\n\ \t\t\t\t\t}\n\ \t\t\t\t};\n\ \t\t\t},\n\ \n\ \t\t\tprogressValues, progressContexts, resolveContexts;\n\ \n\ \t\t// add listeners to Deferred subordinates; treat others as resolved\n\ \t\tif ( length > 1 ) {\n\ \t\t\tprogressValues = new Array( length );\n\ \t\t\tprogressContexts = new Array( length );\n\ \t\t\tresolveContexts = new Array( length );\n\ \t\t\tfor ( ; i < length; i++ ) {\n\ \t\t\t\tif ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {\n\ \t\t\t\t\tresolveValues[ i ].promise()\n\ \t\t\t\t\t\t.done( updateFunc( i, resolveContexts, resolveValues ) )\n\ \t\t\t\t\t\t.fail( deferred.reject )\n\ \t\t\t\t\t\t.progress( updateFunc( i, progressContexts, progressValues ) );\n\ \t\t\t\t} else {\n\ \t\t\t\t\t--remaining;\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\t// if we're not waiting on anything, resolve the master\n\ \t\tif ( !remaining ) {\n\ \t\t\tdeferred.resolveWith( resolveContexts, resolveValues );\n\ \t\t}\n\ \n\ \t\treturn deferred.promise();\n\ \t}\n\ });\n\ \n\ \n\ // The deferred used on DOM ready\n\ var readyList;\n\ \n\ jQuery.fn.ready = function( fn ) {\n\ \t// Add the callback\n\ \tjQuery.ready.promise().done( fn );\n\ \n\ \treturn this;\n\ };\n\ \n\ jQuery.extend({\n\ \t// Is the DOM ready to be used? Set to true once it occurs.\n\ \tisReady: false,\n\ \n\ \t// A counter to track how many items to wait for before\n\ \t// the ready event fires. See #6781\n\ \treadyWait: 1,\n\ \n\ \t// Hold (or release) the ready event\n\ \tholdReady: function( hold ) {\n\ \t\tif ( hold ) {\n\ \t\t\tjQuery.readyWait++;\n\ \t\t} else {\n\ \t\t\tjQuery.ready( true );\n\ \t\t}\n\ \t},\n\ \n\ \t// Handle when the DOM is ready\n\ \tready: function( wait ) {\n\ \n\ \t\t// Abort if there are pending holds or we're already ready\n\ \t\tif ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {\n\ \t\t\treturn;\n\ \t\t}\n\ \n\ \t\t// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).\n\ \t\tif ( !document.body ) {\n\ \t\t\treturn setTimeout( jQuery.ready );\n\ \t\t}\n\ \n\ \t\t// Remember that the DOM is ready\n\ \t\tjQuery.isReady = true;\n\ \n\ \t\t// If a normal DOM Ready event fired, decrement, and wait if need be\n\ \t\tif ( wait !== true && --jQuery.readyWait > 0 ) {\n\ \t\t\treturn;\n\ \t\t}\n\ \n\ \t\t// If there are functions bound, to execute\n\ \t\treadyList.resolveWith( document, [ jQuery ] );\n\ \n\ \t\t// Trigger any bound ready events\n\ \t\tif ( jQuery.fn.triggerHandler ) {\n\ \t\t\tjQuery( document ).triggerHandler( \"ready\" );\n\ \t\t\tjQuery( document ).off( \"ready\" );\n\ \t\t}\n\ \t}\n\ });\n\ \n\ /**\n\ * Clean-up method for dom ready events\n\ */\n\ function detach() {\n\ \tif ( document.addEventListener ) {\n\ \t\tdocument.removeEventListener( \"DOMContentLoaded\", completed, false );\n\ \t\twindow.removeEventListener( \"load\", completed, false );\n\ \n\ \t} else {\n\ \t\tdocument.detachEvent( \"onreadystatechange\", completed );\n\ \t\twindow.detachEvent( \"onload\", completed );\n\ \t}\n\ }\n\ \n\ /**\n\ * The ready event handler and self cleanup method\n\ */\n\ function completed() {\n\ \t// readyState === \"complete\" is good enough for us to call the dom ready in oldIE\n\ \tif ( document.addEventListener || event.type === \"load\" || document.readyState === \"complete\" ) {\n\ \t\tdetach();\n\ \t\tjQuery.ready();\n\ \t}\n\ }\n\ \n\ jQuery.ready.promise = function( obj ) {\n\ \tif ( !readyList ) {\n\ \n\ \t\treadyList = jQuery.Deferred();\n\ \n\ \t\t// Catch cases where $(document).ready() is called after the browser event has already occurred.\n\ \t\t// we once tried to use readyState \"interactive\" here, but it caused issues like the one\n\ \t\t// discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15\n\ \t\tif ( document.readyState === \"complete\" ) {\n\ \t\t\t// Handle it asynchronously to allow scripts the opportunity to delay ready\n\ \t\t\tsetTimeout( jQuery.ready );\n\ \n\ \t\t// Standards-based browsers support DOMContentLoaded\n\ \t\t} else if ( document.addEventListener ) {\n\ \t\t\t// Use the handy event callback\n\ \t\t\tdocument.addEventListener( \"DOMContentLoaded\", completed, false );\n\ \n\ \t\t\t// A fallback to window.onload, that will always work\n\ \t\t\twindow.addEventListener( \"load\", completed, false );\n\ \n\ \t\t// If IE event model is used\n\ \t\t} else {\n\ \t\t\t// Ensure firing before onload, maybe late but safe also for iframes\n\ \t\t\tdocument.attachEvent( \"onreadystatechange\", completed );\n\ \n\ \t\t\t// A fallback to window.onload, that will always work\n\ \t\t\twindow.attachEvent( \"onload\", completed );\n\ \n\ \t\t\t// If IE and not a frame\n\ \t\t\t// continually check to see if the document is ready\n\ \t\t\tvar top = false;\n\ \n\ \t\t\ttry {\n\ \t\t\t\ttop = window.frameElement == null && document.documentElement;\n\ \t\t\t} catch(e) {}\n\ \n\ \t\t\tif ( top && top.doScroll ) {\n\ \t\t\t\t(function doScrollCheck() {\n\ \t\t\t\t\tif ( !jQuery.isReady ) {\n\ \n\ \t\t\t\t\t\ttry {\n\ \t\t\t\t\t\t\t// Use the trick by Diego Perini\n\ \t\t\t\t\t\t\t// http://javascript.nwbox.com/IEContentLoaded/\n\ \t\t\t\t\t\t\ttop.doScroll(\"left\");\n\ \t\t\t\t\t\t} catch(e) {\n\ \t\t\t\t\t\t\treturn setTimeout( doScrollCheck, 50 );\n\ \t\t\t\t\t\t}\n\ \n\ \t\t\t\t\t\t// detach all dom ready events\n\ \t\t\t\t\t\tdetach();\n\ \n\ \t\t\t\t\t\t// and execute any waiting functions\n\ \t\t\t\t\t\tjQuery.ready();\n\ \t\t\t\t\t}\n\ \t\t\t\t})();\n\ \t\t\t}\n\ \t\t}\n\ \t}\n\ \treturn readyList.promise( obj );\n\ };\n\ \n\ \n\ var strundefined = typeof undefined;\n\ \n\ \n\ \n\ // Support: IE<9\n\ // Iteration over object's inherited properties before its own\n\ var i;\n\ for ( i in jQuery( support ) ) {\n\ \tbreak;\n\ }\n\ support.ownLast = i !== \"0\";\n\ \n\ // Note: most support tests are defined in their respective modules.\n\ // false until the test is run\n\ support.inlineBlockNeedsLayout = false;\n\ \n\ // Execute ASAP in case we need to set body.style.zoom\n\ jQuery(function() {\n\ \t// Minified: var a,b,c,d\n\ \tvar val, div, body, container;\n\ \n\ \tbody = document.getElementsByTagName( \"body\" )[ 0 ];\n\ \tif ( !body || !body.style ) {\n\ \t\t// Return for frameset docs that don't have a body\n\ \t\treturn;\n\ \t}\n\ \n\ \t// Setup\n\ \tdiv = document.createElement( \"div\" );\n\ \tcontainer = document.createElement( \"div\" );\n\ \tcontainer.style.cssText = \"position:absolute;border:0;width:0;height:0;top:0;left:-9999px\";\n\ \tbody.appendChild( container ).appendChild( div );\n\ \n\ \tif ( typeof div.style.zoom !== strundefined ) {\n\ \t\t// Support: IE<8\n\ \t\t// Check if natively block-level elements act like inline-block\n\ \t\t// elements when setting their display to 'inline' and giving\n\ \t\t// them layout\n\ \t\tdiv.style.cssText = \"display:inline;margin:0;border:0;padding:1px;width:1px;zoom:1\";\n\ \n\ \t\tsupport.inlineBlockNeedsLayout = val = div.offsetWidth === 3;\n\ \t\tif ( val ) {\n\ \t\t\t// Prevent IE 6 from affecting layout for positioned elements #11048\n\ \t\t\t// Prevent IE from shrinking the body in IE 7 mode #12869\n\ \t\t\t// Support: IE<8\n\ \t\t\tbody.style.zoom = 1;\n\ \t\t}\n\ \t}\n\ \n\ \tbody.removeChild( container );\n\ });\n\ \n\ \n\ \n\ \n\ (function() {\n\ \tvar div = document.createElement( \"div\" );\n\ \n\ \t// Execute the test only if not already executed in another module.\n\ \tif (support.deleteExpando == null) {\n\ \t\t// Support: IE<9\n\ \t\tsupport.deleteExpando = true;\n\ \t\ttry {\n\ \t\t\tdelete div.test;\n\ \t\t} catch( e ) {\n\ \t\t\tsupport.deleteExpando = false;\n\ \t\t}\n\ \t}\n\ \n\ \t// Null elements to avoid leaks in IE.\n\ \tdiv = null;\n\ })();\n\ \n\ \n\ /**\n\ * Determines whether an object can have data\n\ */\n\ jQuery.acceptData = function( elem ) {\n\ \tvar noData = jQuery.noData[ (elem.nodeName + \" \").toLowerCase() ],\n\ \t\tnodeType = +elem.nodeType || 1;\n\ \n\ \t// Do not set data on non-element DOM nodes because it will not be cleared (#8335).\n\ \treturn nodeType !== 1 && nodeType !== 9 ?\n\ \t\tfalse :\n\ \n\ \t\t// Nodes accept data unless otherwise specified; rejection can be conditional\n\ \t\t!noData || noData !== true && elem.getAttribute(\"classid\") === noData;\n\ };\n\ \n\ \n\ var rbrace = /^(?:\\{[\\w\\W]*\\}|\\[[\\w\\W]*\\])$/,\n\ \trmultiDash = /([A-Z])/g;\n\ \n\ function dataAttr( elem, key, data ) {\n\ \t// If nothing was found internally, try to fetch any\n\ \t// data from the HTML5 data-* attribute\n\ \tif ( data === undefined && elem.nodeType === 1 ) {\n\ \n\ \t\tvar name = \"data-\" + key.replace( rmultiDash, \"-$1\" ).toLowerCase();\n\ \n\ \t\tdata = elem.getAttribute( name );\n\ \n\ \t\tif ( typeof data === \"string\" ) {\n\ \t\t\ttry {\n\ \t\t\t\tdata = data === \"true\" ? true :\n\ \t\t\t\t\tdata === \"false\" ? false :\n\ \t\t\t\t\tdata === \"null\" ? null :\n\ \t\t\t\t\t// Only convert to a number if it doesn't change the string\n\ \t\t\t\t\t+data + \"\" === data ? +data :\n\ \t\t\t\t\trbrace.test( data ) ? jQuery.parseJSON( data ) :\n\ \t\t\t\t\tdata;\n\ \t\t\t} catch( e ) {}\n\ \n\ \t\t\t// Make sure we set the data so it isn't changed later\n\ \t\t\tjQuery.data( elem, key, data );\n\ \n\ \t\t} else {\n\ \t\t\tdata = undefined;\n\ \t\t}\n\ \t}\n\ \n\ \treturn data;\n\ }\n\ \n\ // checks a cache object for emptiness\n\ function isEmptyDataObject( obj ) {\n\ \tvar name;\n\ \tfor ( name in obj ) {\n\ \n\ \t\t// if the public data object is empty, the private is still empty\n\ \t\tif ( name === \"data\" && jQuery.isEmptyObject( obj[name] ) ) {\n\ \t\t\tcontinue;\n\ \t\t}\n\ \t\tif ( name !== \"toJSON\" ) {\n\ \t\t\treturn false;\n\ \t\t}\n\ \t}\n\ \n\ \treturn true;\n\ }\n\ \n\ function internalData( elem, name, data, pvt /* Internal Use Only */ ) {\n\ \tif ( !jQuery.acceptData( elem ) ) {\n\ \t\treturn;\n\ \t}\n\ \n\ \tvar ret, thisCache,\n\ \t\tinternalKey = jQuery.expando,\n\ \n\ \t\t// We have to handle DOM nodes and JS objects differently because IE6-7\n\ \t\t// can't GC object references properly across the DOM-JS boundary\n\ \t\tisNode = elem.nodeType,\n\ \n\ \t\t// Only DOM nodes need the global jQuery cache; JS object data is\n\ \t\t// attached directly to the object so GC can occur automatically\n\ \t\tcache = isNode ? jQuery.cache : elem,\n\ \n\ \t\t// Only defining an ID for JS objects if its cache already exists allows\n\ \t\t// the code to shortcut on the same path as a DOM node with no cache\n\ \t\tid = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey;\n\ \n\ \t// Avoid doing any more work than we need to when trying to get data on an\n\ \t// object that has no data at all\n\ \tif ( (!id || !cache[id] || (!pvt && !cache[id].data)) && data === undefined && typeof name === \"string\" ) {\n\ \t\treturn;\n\ \t}\n\ \n\ \tif ( !id ) {\n\ \t\t// Only DOM nodes need a new unique ID for each element since their data\n\ \t\t// ends up in the global cache\n\ \t\tif ( isNode ) {\n\ \t\t\tid = elem[ internalKey ] = deletedIds.pop() || jQuery.guid++;\n\ \t\t} else {\n\ \t\t\tid = internalKey;\n\ \t\t}\n\ \t}\n\ \n\ \tif ( !cache[ id ] ) {\n\ \t\t// Avoid exposing jQuery metadata on plain JS objects when the object\n\ \t\t// is serialized using JSON.stringify\n\ \t\tcache[ id ] = isNode ? {} : { toJSON: jQuery.noop };\n\ \t}\n\ \n\ \t// An object can be passed to jQuery.data instead of a key/value pair; this gets\n\ \t// shallow copied over onto the existing cache\n\ \tif ( typeof name === \"object\" || typeof name === \"function\" ) {\n\ \t\tif ( pvt ) {\n\ \t\t\tcache[ id ] = jQuery.extend( cache[ id ], name );\n\ \t\t} else {\n\ \t\t\tcache[ id ].data = jQuery.extend( cache[ id ].data, name );\n\ \t\t}\n\ \t}\n\ \n\ \tthisCache = cache[ id ];\n\ \n\ \t// jQuery data() is stored in a separate object inside the object's internal data\n\ \t// cache in order to avoid key collisions between internal data and user-defined\n\ \t// data.\n\ \tif ( !pvt ) {\n\ \t\tif ( !thisCache.data ) {\n\ \t\t\tthisCache.data = {};\n\ \t\t}\n\ \n\ \t\tthisCache = thisCache.data;\n\ \t}\n\ \n\ \tif ( data !== undefined ) {\n\ \t\tthisCache[ jQuery.camelCase( name ) ] = data;\n\ \t}\n\ \n\ \t// Check for both converted-to-camel and non-converted data property names\n\ \t// If a data property was specified\n\ \tif ( typeof name === \"string\" ) {\n\ \n\ \t\t// First Try to find as-is property data\n\ \t\tret = thisCache[ name ];\n\ \n\ \t\t// Test for null|undefined property data\n\ \t\tif ( ret == null ) {\n\ \n\ \t\t\t// Try to find the camelCased property\n\ \t\t\tret = thisCache[ jQuery.camelCase( name ) ];\n\ \t\t}\n\ \t} else {\n\ \t\tret = thisCache;\n\ \t}\n\ \n\ \treturn ret;\n\ }\n\ \n\ function internalRemoveData( elem, name, pvt ) {\n\ \tif ( !jQuery.acceptData( elem ) ) {\n\ \t\treturn;\n\ \t}\n\ \n\ \tvar thisCache, i,\n\ \t\tisNode = elem.nodeType,\n\ \n\ \t\t// See jQuery.data for more information\n\ \t\tcache = isNode ? jQuery.cache : elem,\n\ \t\tid = isNode ? elem[ jQuery.expando ] : jQuery.expando;\n\ \n\ \t// If there is already no cache entry for this object, there is no\n\ \t// purpose in continuing\n\ \tif ( !cache[ id ] ) {\n\ \t\treturn;\n\ \t}\n\ \n\ \tif ( name ) {\n\ \n\ \t\tthisCache = pvt ? cache[ id ] : cache[ id ].data;\n\ \n\ \t\tif ( thisCache ) {\n\ \n\ \t\t\t// Support array or space separated string names for data keys\n\ \t\t\tif ( !jQuery.isArray( name ) ) {\n\ \n\ \t\t\t\t// try the string as a key before any manipulation\n\ \t\t\t\tif ( name in thisCache ) {\n\ \t\t\t\t\tname = [ name ];\n\ \t\t\t\t} else {\n\ \n\ \t\t\t\t\t// split the camel cased version by spaces unless a key with the spaces exists\n\ \t\t\t\t\tname = jQuery.camelCase( name );\n\ \t\t\t\t\tif ( name in thisCache ) {\n\ \t\t\t\t\t\tname = [ name ];\n\ \t\t\t\t\t} else {\n\ \t\t\t\t\t\tname = name.split(\" \");\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \t\t\t} else {\n\ \t\t\t\t// If \"name\" is an array of keys...\n\ \t\t\t\t// When data is initially created, via (\"key\", \"val\") signature,\n\ \t\t\t\t// keys will be converted to camelCase.\n\ \t\t\t\t// Since there is no way to tell _how_ a key was added, remove\n\ \t\t\t\t// both plain key and camelCase key. #12786\n\ \t\t\t\t// This will only penalize the array argument path.\n\ \t\t\t\tname = name.concat( jQuery.map( name, jQuery.camelCase ) );\n\ \t\t\t}\n\ \n\ \t\t\ti = name.length;\n\ \t\t\twhile ( i-- ) {\n\ \t\t\t\tdelete thisCache[ name[i] ];\n\ \t\t\t}\n\ \n\ \t\t\t// If there is no data left in the cache, we want to continue\n\ \t\t\t// and let the cache object itself get destroyed\n\ \t\t\tif ( pvt ? !isEmptyDataObject(thisCache) : !jQuery.isEmptyObject(thisCache) ) {\n\ \t\t\t\treturn;\n\ \t\t\t}\n\ \t\t}\n\ \t}\n\ \n\ \t// See jQuery.data for more information\n\ \tif ( !pvt ) {\n\ \t\tdelete cache[ id ].data;\n\ \n\ \t\t// Don't destroy the parent cache unless the internal data object\n\ \t\t// had been the only thing left in it\n\ \t\tif ( !isEmptyDataObject( cache[ id ] ) ) {\n\ \t\t\treturn;\n\ \t\t}\n\ \t}\n\ \n\ \t// Destroy the cache\n\ \tif ( isNode ) {\n\ \t\tjQuery.cleanData( [ elem ], true );\n\ \n\ \t// Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)\n\ \t/* jshint eqeqeq: false */\n\ \t} else if ( support.deleteExpando || cache != cache.window ) {\n\ \t\t/* jshint eqeqeq: true */\n\ \t\tdelete cache[ id ];\n\ \n\ \t// When all else fails, null\n\ \t} else {\n\ \t\tcache[ id ] = null;\n\ \t}\n\ }\n\ \n\ jQuery.extend({\n\ \tcache: {},\n\ \n\ \t// The following elements (space-suffixed to avoid Object.prototype collisions)\n\ \t// throw uncatchable exceptions if you attempt to set expando properties\n\ \tnoData: {\n\ \t\t\"applet \": true,\n\ \t\t\"embed \": true,\n\ \t\t// ...but Flash objects (which have this classid) *can* handle expandos\n\ \t\t\"object \": \"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000\"\n\ \t},\n\ \n\ \thasData: function( elem ) {\n\ \t\telem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];\n\ \t\treturn !!elem && !isEmptyDataObject( elem );\n\ \t},\n\ \n\ \tdata: function( elem, name, data ) {\n\ \t\treturn internalData( elem, name, data );\n\ \t},\n\ \n\ \tremoveData: function( elem, name ) {\n\ \t\treturn internalRemoveData( elem, name );\n\ \t},\n\ \n\ \t// For internal use only.\n\ \t_data: function( elem, name, data ) {\n\ \t\treturn internalData( elem, name, data, true );\n\ \t},\n\ \n\ \t_removeData: function( elem, name ) {\n\ \t\treturn internalRemoveData( elem, name, true );\n\ \t}\n\ });\n\ \n\ jQuery.fn.extend({\n\ \tdata: function( key, value ) {\n\ \t\tvar i, name, data,\n\ \t\t\telem = this[0],\n\ \t\t\tattrs = elem && elem.attributes;\n\ \n\ \t\t// Special expections of .data basically thwart jQuery.access,\n\ \t\t// so implement the relevant behavior ourselves\n\ \n\ \t\t// Gets all values\n\ \t\tif ( key === undefined ) {\n\ \t\t\tif ( this.length ) {\n\ \t\t\t\tdata = jQuery.data( elem );\n\ \n\ \t\t\t\tif ( elem.nodeType === 1 && !jQuery._data( elem, \"parsedAttrs\" ) ) {\n\ \t\t\t\t\ti = attrs.length;\n\ \t\t\t\t\twhile ( i-- ) {\n\ \n\ \t\t\t\t\t\t// Support: IE11+\n\ \t\t\t\t\t\t// The attrs elements can be null (#14894)\n\ \t\t\t\t\t\tif ( attrs[ i ] ) {\n\ \t\t\t\t\t\t\tname = attrs[ i ].name;\n\ \t\t\t\t\t\t\tif ( name.indexOf( \"data-\" ) === 0 ) {\n\ \t\t\t\t\t\t\t\tname = jQuery.camelCase( name.slice(5) );\n\ \t\t\t\t\t\t\t\tdataAttr( elem, name, data[ name ] );\n\ \t\t\t\t\t\t\t}\n\ \t\t\t\t\t\t}\n\ \t\t\t\t\t}\n\ \t\t\t\t\tjQuery._data( elem, \"parsedAttrs\", true );\n\ \t\t\t\t}\n\ \t\t\t}\n\ \n\ \t\t\treturn data;\n\ \t\t}\n\ \n\ \t\t// Sets multiple values\n\ \t\tif ( typeof key === \"object\" ) {\n\ \t\t\treturn this.each(function() {\n\ \t\t\t\tjQuery.data( this, key );\n\ \t\t\t});\n\ \t\t}\n\ \n\ \t\treturn arguments.length > 1 ?\n\ \n\ \t\t\t// Sets one value\n\ \t\t\tthis.each(function() {\n\ \t\t\t\tjQuery.data( this, key, value );\n\ \t\t\t}) :\n\ \n\ \t\t\t// Gets one value\n\ \t\t\t// Try to fetch any internally stored data first\n\ \t\t\telem ? dataAttr( elem, key, jQuery.data( elem, key ) ) : undefined;\n\ \t},\n\ \n\ \tremoveData: function( key ) {\n\ \t\treturn this.each(function() {\n\ \t\t\tjQuery.removeData( this, key );\n\ \t\t});\n\ \t}\n\ });\n\ \n\ \n\ jQuery.extend({\n\ \tqueue: function( elem, type, data ) {\n\ \t\tvar queue;\n\ \n\ \t\tif ( elem ) {\n\ \t\t\ttype = ( type || \"fx\" ) + \"queue\";\n\ \t\t\tqueue = jQuery._data( elem, type );\n\ \n\ \t\t\t// Speed up dequeue by getting out quickly if this is just a lookup\n\ \t\t\tif ( data ) {\n\ \t\t\t\tif ( !queue || jQuery.isArray(data) ) {\n\ \t\t\t\t\tqueue = jQuery._data( elem, type, jQuery.makeArray(data) );\n\ \t\t\t\t} else {\n\ \t\t\t\t\tqueue.push( data );\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t\treturn queue || [];\n\ \t\t}\n\ \t},\n\ \n\ \tdequeue: function( elem, type ) {\n\ \t\ttype = type || \"fx\";\n\ \n\ \t\tvar queue = jQuery.queue( elem, type ),\n\ \t\t\tstartLength = queue.length,\n\ \t\t\tfn = queue.shift(),\n\ \t\t\thooks = jQuery._queueHooks( elem, type ),\n\ \t\t\tnext = function() {\n\ \t\t\t\tjQuery.dequeue( elem, type );\n\ \t\t\t};\n\ \n\ \t\t// If the fx queue is dequeued, always remove the progress sentinel\n\ \t\tif ( fn === \"inprogress\" ) {\n\ \t\t\tfn = queue.shift();\n\ \t\t\tstartLength--;\n\ \t\t}\n\ \n\ \t\tif ( fn ) {\n\ \n\ \t\t\t// Add a progress sentinel to prevent the fx queue from being\n\ \t\t\t// automatically dequeued\n\ \t\t\tif ( type === \"fx\" ) {\n\ \t\t\t\tqueue.unshift( \"inprogress\" );\n\ \t\t\t}\n\ \n\ \t\t\t// clear up the last queue stop function\n\ \t\t\tdelete hooks.stop;\n\ \t\t\tfn.call( elem, next, hooks );\n\ \t\t}\n\ \n\ \t\tif ( !startLength && hooks ) {\n\ \t\t\thooks.empty.fire();\n\ \t\t}\n\ \t},\n\ \n\ \t// not intended for public consumption - generates a queueHooks object, or returns the current one\n\ \t_queueHooks: function( elem, type ) {\n\ \t\tvar key = type + \"queueHooks\";\n\ \t\treturn jQuery._data( elem, key ) || jQuery._data( elem, key, {\n\ \t\t\tempty: jQuery.Callbacks(\"once memory\").add(function() {\n\ \t\t\t\tjQuery._removeData( elem, type + \"queue\" );\n\ \t\t\t\tjQuery._removeData( elem, key );\n\ \t\t\t})\n\ \t\t});\n\ \t}\n\ });\n\ \n\ jQuery.fn.extend({\n\ \tqueue: function( type, data ) {\n\ \t\tvar setter = 2;\n\ \n\ \t\tif ( typeof type !== \"string\" ) {\n\ \t\t\tdata = type;\n\ \t\t\ttype = \"fx\";\n\ \t\t\tsetter--;\n\ \t\t}\n\ \n\ \t\tif ( arguments.length < setter ) {\n\ \t\t\treturn jQuery.queue( this[0], type );\n\ \t\t}\n\ \n\ \t\treturn data === undefined ?\n\ \t\t\tthis :\n\ \t\t\tthis.each(function() {\n\ \t\t\t\tvar queue = jQuery.queue( this, type, data );\n\ \n\ \t\t\t\t// ensure a hooks for this queue\n\ \t\t\t\tjQuery._queueHooks( this, type );\n\ \n\ \t\t\t\tif ( type === \"fx\" && queue[0] !== \"inprogress\" ) {\n\ \t\t\t\t\tjQuery.dequeue( this, type );\n\ \t\t\t\t}\n\ \t\t\t});\n\ \t},\n\ \tdequeue: function( type ) {\n\ \t\treturn this.each(function() {\n\ \t\t\tjQuery.dequeue( this, type );\n\ \t\t});\n\ \t},\n\ \tclearQueue: function( type ) {\n\ \t\treturn this.queue( type || \"fx\", [] );\n\ \t},\n\ \t// Get a promise resolved when queues of a certain type\n\ \t// are emptied (fx is the type by default)\n\ \tpromise: function( type, obj ) {\n\ \t\tvar tmp,\n\ \t\t\tcount = 1,\n\ \t\t\tdefer = jQuery.Deferred(),\n\ \t\t\telements = this,\n\ \t\t\ti = this.length,\n\ \t\t\tresolve = function() {\n\ \t\t\t\tif ( !( --count ) ) {\n\ \t\t\t\t\tdefer.resolveWith( elements, [ elements ] );\n\ \t\t\t\t}\n\ \t\t\t};\n\ \n\ \t\tif ( typeof type !== \"string\" ) {\n\ \t\t\tobj = type;\n\ \t\t\ttype = undefined;\n\ \t\t}\n\ \t\ttype = type || \"fx\";\n\ \n\ \t\twhile ( i-- ) {\n\ \t\t\ttmp = jQuery._data( elements[ i ], type + \"queueHooks\" );\n\ \t\t\tif ( tmp && tmp.empty ) {\n\ \t\t\t\tcount++;\n\ \t\t\t\ttmp.empty.add( resolve );\n\ \t\t\t}\n\ \t\t}\n\ \t\tresolve();\n\ \t\treturn defer.promise( obj );\n\ \t}\n\ });\n\ var pnum = (/[+-]?(?:\\d*\\.|)\\d+(?:[eE][+-]?\\d+|)/).source;\n\ \n\ var cssExpand = [ \"Top\", \"Right\", \"Bottom\", \"Left\" ];\n\ \n\ var isHidden = function( elem, el ) {\n\ \t\t// isHidden might be called from jQuery#filter function;\n\ \t\t// in that case, element will be second argument\n\ \t\telem = el || elem;\n\ \t\treturn jQuery.css( elem, \"display\" ) === \"none\" || !jQuery.contains( elem.ownerDocument, elem );\n\ \t};\n\ \n\ \n\ \n\ // Multifunctional method to get and set values of a collection\n\ // The value/s can optionally be executed if it's a function\n\ var access = jQuery.access = function( elems, fn, key, value, chainable, emptyGet, raw ) {\n\ \tvar i = 0,\n\ \t\tlength = elems.length,\n\ \t\tbulk = key == null;\n\ \n\ \t// Sets many values\n\ \tif ( jQuery.type( key ) === \"object\" ) {\n\ \t\tchainable = true;\n\ \t\tfor ( i in key ) {\n\ \t\t\tjQuery.access( elems, fn, i, key[i], true, emptyGet, raw );\n\ \t\t}\n\ \n\ \t// Sets one value\n\ \t} else if ( value !== undefined ) {\n\ \t\tchainable = true;\n\ \n\ \t\tif ( !jQuery.isFunction( value ) ) {\n\ \t\t\traw = true;\n\ \t\t}\n\ \n\ \t\tif ( bulk ) {\n\ \t\t\t// Bulk operations run against the entire set\n\ \t\t\tif ( raw ) {\n\ \t\t\t\tfn.call( elems, value );\n\ \t\t\t\tfn = null;\n\ \n\ \t\t\t// ...except when executing function values\n\ \t\t\t} else {\n\ \t\t\t\tbulk = fn;\n\ \t\t\t\tfn = function( elem, key, value ) {\n\ \t\t\t\t\treturn bulk.call( jQuery( elem ), value );\n\ \t\t\t\t};\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\tif ( fn ) {\n\ \t\t\tfor ( ; i < length; i++ ) {\n\ \t\t\t\tfn( elems[i], key, raw ? value : value.call( elems[i], i, fn( elems[i], key ) ) );\n\ \t\t\t}\n\ \t\t}\n\ \t}\n\ \n\ \treturn chainable ?\n\ \t\telems :\n\ \n\ \t\t// Gets\n\ \t\tbulk ?\n\ \t\t\tfn.call( elems ) :\n\ \t\t\tlength ? fn( elems[0], key ) : emptyGet;\n\ };\n\ var rcheckableType = (/^(?:checkbox|radio)$/i);\n\ \n\ \n\ \n\ (function() {\n\ \t// Minified: var a,b,c\n\ \tvar input = document.createElement( \"input\" ),\n\ \t\tdiv = document.createElement( \"div\" ),\n\ \t\tfragment = document.createDocumentFragment();\n\ \n\ \t// Setup\n\ \tdiv.innerHTML = \"
    a\";\n\ \n\ \t// IE strips leading whitespace when .innerHTML is used\n\ \tsupport.leadingWhitespace = div.firstChild.nodeType === 3;\n\ \n\ \t// Make sure that tbody elements aren't automatically inserted\n\ \t// IE will insert them into empty tables\n\ \tsupport.tbody = !div.getElementsByTagName( \"tbody\" ).length;\n\ \n\ \t// Make sure that link elements get serialized correctly by innerHTML\n\ \t// This requires a wrapper element in IE\n\ \tsupport.htmlSerialize = !!div.getElementsByTagName( \"link\" ).length;\n\ \n\ \t// Makes sure cloning an html5 element does not cause problems\n\ \t// Where outerHTML is undefined, this still works\n\ \tsupport.html5Clone =\n\ \t\tdocument.createElement( \"nav\" ).cloneNode( true ).outerHTML !== \"<:nav>\";\n\ \n\ \t// Check if a disconnected checkbox will retain its checked\n\ \t// value of true after appended to the DOM (IE6/7)\n\ \tinput.type = \"checkbox\";\n\ \tinput.checked = true;\n\ \tfragment.appendChild( input );\n\ \tsupport.appendChecked = input.checked;\n\ \n\ \t// Make sure textarea (and checkbox) defaultValue is properly cloned\n\ \t// Support: IE6-IE11+\n\ \tdiv.innerHTML = \"\";\n\ \tsupport.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;\n\ \n\ \t// #11217 - WebKit loses check when the name is after the checked attribute\n\ \tfragment.appendChild( div );\n\ \tdiv.innerHTML = \"\";\n\ \n\ \t// Support: Safari 5.1, iOS 5.1, Android 4.x, Android 2.3\n\ \t// old WebKit doesn't clone checked state correctly in fragments\n\ \tsupport.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;\n\ \n\ \t// Support: IE<9\n\ \t// Opera does not clone events (and typeof div.attachEvent === undefined).\n\ \t// IE9-10 clones events bound via attachEvent, but they don't trigger with .click()\n\ \tsupport.noCloneEvent = true;\n\ \tif ( div.attachEvent ) {\n\ \t\tdiv.attachEvent( \"onclick\", function() {\n\ \t\t\tsupport.noCloneEvent = false;\n\ \t\t});\n\ \n\ \t\tdiv.cloneNode( true ).click();\n\ \t}\n\ \n\ \t// Execute the test only if not already executed in another module.\n\ \tif (support.deleteExpando == null) {\n\ \t\t// Support: IE<9\n\ \t\tsupport.deleteExpando = true;\n\ \t\ttry {\n\ \t\t\tdelete div.test;\n\ \t\t} catch( e ) {\n\ \t\t\tsupport.deleteExpando = false;\n\ \t\t}\n\ \t}\n\ })();\n\ \n\ \n\ (function() {\n\ \tvar i, eventName,\n\ \t\tdiv = document.createElement( \"div\" );\n\ \n\ \t// Support: IE<9 (lack submit/change bubble), Firefox 23+ (lack focusin event)\n\ \tfor ( i in { submit: true, change: true, focusin: true }) {\n\ \t\teventName = \"on\" + i;\n\ \n\ \t\tif ( !(support[ i + \"Bubbles\" ] = eventName in window) ) {\n\ \t\t\t// Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP)\n\ \t\t\tdiv.setAttribute( eventName, \"t\" );\n\ \t\t\tsupport[ i + \"Bubbles\" ] = div.attributes[ eventName ].expando === false;\n\ \t\t}\n\ \t}\n\ \n\ \t// Null elements to avoid leaks in IE.\n\ \tdiv = null;\n\ })();\n\ \n\ \n\ var rformElems = /^(?:input|select|textarea)$/i,\n\ \trkeyEvent = /^key/,\n\ \trmouseEvent = /^(?:mouse|pointer|contextmenu)|click/,\n\ \trfocusMorph = /^(?:focusinfocus|focusoutblur)$/,\n\ \trtypenamespace = /^([^.]*)(?:\\.(.+)|)$/;\n\ \n\ function returnTrue() {\n\ \treturn true;\n\ }\n\ \n\ function returnFalse() {\n\ \treturn false;\n\ }\n\ \n\ function safeActiveElement() {\n\ \ttry {\n\ \t\treturn document.activeElement;\n\ \t} catch ( err ) { }\n\ }\n\ \n\ /*\n\ * Helper functions for managing events -- not part of the public interface.\n\ * Props to Dean Edwards' addEvent library for many of the ideas.\n\ */\n\ jQuery.event = {\n\ \n\ \tglobal: {},\n\ \n\ \tadd: function( elem, types, handler, data, selector ) {\n\ \t\tvar tmp, events, t, handleObjIn,\n\ \t\t\tspecial, eventHandle, handleObj,\n\ \t\t\thandlers, type, namespaces, origType,\n\ \t\t\telemData = jQuery._data( elem );\n\ \n\ \t\t// Don't attach events to noData or text/comment nodes (but allow plain objects)\n\ \t\tif ( !elemData ) {\n\ \t\t\treturn;\n\ \t\t}\n\ \n\ \t\t// Caller can pass in an object of custom data in lieu of the handler\n\ \t\tif ( handler.handler ) {\n\ \t\t\thandleObjIn = handler;\n\ \t\t\thandler = handleObjIn.handler;\n\ \t\t\tselector = handleObjIn.selector;\n\ \t\t}\n\ \n\ \t\t// Make sure that the handler has a unique ID, used to find/remove it later\n\ \t\tif ( !handler.guid ) {\n\ \t\t\thandler.guid = jQuery.guid++;\n\ \t\t}\n\ \n\ \t\t// Init the element's event structure and main handler, if this is the first\n\ \t\tif ( !(events = elemData.events) ) {\n\ \t\t\tevents = elemData.events = {};\n\ \t\t}\n\ \t\tif ( !(eventHandle = elemData.handle) ) {\n\ \t\t\teventHandle = elemData.handle = function( e ) {\n\ \t\t\t\t// Discard the second event of a jQuery.event.trigger() and\n\ \t\t\t\t// when an event is called after a page has unloaded\n\ \t\t\t\treturn typeof jQuery !== strundefined && (!e || jQuery.event.triggered !== e.type) ?\n\ \t\t\t\t\tjQuery.event.dispatch.apply( eventHandle.elem, arguments ) :\n\ \t\t\t\t\tundefined;\n\ \t\t\t};\n\ \t\t\t// Add elem as a property of the handle fn to prevent a memory leak with IE non-native events\n\ \t\t\teventHandle.elem = elem;\n\ \t\t}\n\ \n\ \t\t// Handle multiple events separated by a space\n\ \t\ttypes = ( types || \"\" ).match( rnotwhite ) || [ \"\" ];\n\ \t\tt = types.length;\n\ \t\twhile ( t-- ) {\n\ \t\t\ttmp = rtypenamespace.exec( types[t] ) || [];\n\ \t\t\ttype = origType = tmp[1];\n\ \t\t\tnamespaces = ( tmp[2] || \"\" ).split( \".\" ).sort();\n\ \n\ \t\t\t// There *must* be a type, no attaching namespace-only handlers\n\ \t\t\tif ( !type ) {\n\ \t\t\t\tcontinue;\n\ \t\t\t}\n\ \n\ \t\t\t// If event changes its type, use the special event handlers for the changed type\n\ \t\t\tspecial = jQuery.event.special[ type ] || {};\n\ \n\ \t\t\t// If selector defined, determine special event api type, otherwise given type\n\ \t\t\ttype = ( selector ? special.delegateType : special.bindType ) || type;\n\ \n\ \t\t\t// Update special based on newly reset type\n\ \t\t\tspecial = jQuery.event.special[ type ] || {};\n\ \n\ \t\t\t// handleObj is passed to all event handlers\n\ \t\t\thandleObj = jQuery.extend({\n\ \t\t\t\ttype: type,\n\ \t\t\t\torigType: origType,\n\ \t\t\t\tdata: data,\n\ \t\t\t\thandler: handler,\n\ \t\t\t\tguid: handler.guid,\n\ \t\t\t\tselector: selector,\n\ \t\t\t\tneedsContext: selector && jQuery.expr.match.needsContext.test( selector ),\n\ \t\t\t\tnamespace: namespaces.join(\".\")\n\ \t\t\t}, handleObjIn );\n\ \n\ \t\t\t// Init the event handler queue if we're the first\n\ \t\t\tif ( !(handlers = events[ type ]) ) {\n\ \t\t\t\thandlers = events[ type ] = [];\n\ \t\t\t\thandlers.delegateCount = 0;\n\ \n\ \t\t\t\t// Only use addEventListener/attachEvent if the special events handler returns false\n\ \t\t\t\tif ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {\n\ \t\t\t\t\t// Bind the global event handler to the element\n\ \t\t\t\t\tif ( elem.addEventListener ) {\n\ \t\t\t\t\t\telem.addEventListener( type, eventHandle, false );\n\ \n\ \t\t\t\t\t} else if ( elem.attachEvent ) {\n\ \t\t\t\t\t\telem.attachEvent( \"on\" + type, eventHandle );\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \t\t\t}\n\ \n\ \t\t\tif ( special.add ) {\n\ \t\t\t\tspecial.add.call( elem, handleObj );\n\ \n\ \t\t\t\tif ( !handleObj.handler.guid ) {\n\ \t\t\t\t\thandleObj.handler.guid = handler.guid;\n\ \t\t\t\t}\n\ \t\t\t}\n\ \n\ \t\t\t// Add to the element's handler list, delegates in front\n\ \t\t\tif ( selector ) {\n\ \t\t\t\thandlers.splice( handlers.delegateCount++, 0, handleObj );\n\ \t\t\t} else {\n\ \t\t\t\thandlers.push( handleObj );\n\ \t\t\t}\n\ \n\ \t\t\t// Keep track of which events have ever been used, for event optimization\n\ \t\t\tjQuery.event.global[ type ] = true;\n\ \t\t}\n\ \n\ \t\t// Nullify elem to prevent memory leaks in IE\n\ \t\telem = null;\n\ \t},\n\ \n\ \t// Detach an event or set of events from an element\n\ \tremove: function( elem, types, handler, selector, mappedTypes ) {\n\ \t\tvar j, handleObj, tmp,\n\ \t\t\torigCount, t, events,\n\ \t\t\tspecial, handlers, type,\n\ \t\t\tnamespaces, origType,\n\ \t\t\telemData = jQuery.hasData( elem ) && jQuery._data( elem );\n\ \n\ \t\tif ( !elemData || !(events = elemData.events) ) {\n\ \t\t\treturn;\n\ \t\t}\n\ \n\ \t\t// Once for each type.namespace in types; type may be omitted\n\ \t\ttypes = ( types || \"\" ).match( rnotwhite ) || [ \"\" ];\n\ \t\tt = types.length;\n\ \t\twhile ( t-- ) {\n\ \t\t\ttmp = rtypenamespace.exec( types[t] ) || [];\n\ \t\t\ttype = origType = tmp[1];\n\ \t\t\tnamespaces = ( tmp[2] || \"\" ).split( \".\" ).sort();\n\ \n\ \t\t\t// Unbind all events (on this namespace, if provided) for the element\n\ \t\t\tif ( !type ) {\n\ \t\t\t\tfor ( type in events ) {\n\ \t\t\t\t\tjQuery.event.remove( elem, type + types[ t ], handler, selector, true );\n\ \t\t\t\t}\n\ \t\t\t\tcontinue;\n\ \t\t\t}\n\ \n\ \t\t\tspecial = jQuery.event.special[ type ] || {};\n\ \t\t\ttype = ( selector ? special.delegateType : special.bindType ) || type;\n\ \t\t\thandlers = events[ type ] || [];\n\ \t\t\ttmp = tmp[2] && new RegExp( \"(^|\\\\.)\" + namespaces.join(\"\\\\.(?:.*\\\\.|)\") + \"(\\\\.|$)\" );\n\ \n\ \t\t\t// Remove matching events\n\ \t\t\torigCount = j = handlers.length;\n\ \t\t\twhile ( j-- ) {\n\ \t\t\t\thandleObj = handlers[ j ];\n\ \n\ \t\t\t\tif ( ( mappedTypes || origType === handleObj.origType ) &&\n\ \t\t\t\t\t( !handler || handler.guid === handleObj.guid ) &&\n\ \t\t\t\t\t( !tmp || tmp.test( handleObj.namespace ) ) &&\n\ \t\t\t\t\t( !selector || selector === handleObj.selector || selector === \"**\" && handleObj.selector ) ) {\n\ \t\t\t\t\thandlers.splice( j, 1 );\n\ \n\ \t\t\t\t\tif ( handleObj.selector ) {\n\ \t\t\t\t\t\thandlers.delegateCount--;\n\ \t\t\t\t\t}\n\ \t\t\t\t\tif ( special.remove ) {\n\ \t\t\t\t\t\tspecial.remove.call( elem, handleObj );\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \t\t\t}\n\ \n\ \t\t\t// Remove generic event handler if we removed something and no more handlers exist\n\ \t\t\t// (avoids potential for endless recursion during removal of special event handlers)\n\ \t\t\tif ( origCount && !handlers.length ) {\n\ \t\t\t\tif ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) {\n\ \t\t\t\t\tjQuery.removeEvent( elem, type, elemData.handle );\n\ \t\t\t\t}\n\ \n\ \t\t\t\tdelete events[ type ];\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\t// Remove the expando if it's no longer used\n\ \t\tif ( jQuery.isEmptyObject( events ) ) {\n\ \t\t\tdelete elemData.handle;\n\ \n\ \t\t\t// removeData also checks for emptiness and clears the expando if empty\n\ \t\t\t// so use it instead of delete\n\ \t\t\tjQuery._removeData( elem, \"events\" );\n\ \t\t}\n\ \t},\n\ \n\ \ttrigger: function( event, data, elem, onlyHandlers ) {\n\ \t\tvar handle, ontype, cur,\n\ \t\t\tbubbleType, special, tmp, i,\n\ \t\t\teventPath = [ elem || document ],\n\ \t\t\ttype = hasOwn.call( event, \"type\" ) ? event.type : event,\n\ \t\t\tnamespaces = hasOwn.call( event, \"namespace\" ) ? event.namespace.split(\".\") : [];\n\ \n\ \t\tcur = tmp = elem = elem || document;\n\ \n\ \t\t// Don't do events on text and comment nodes\n\ \t\tif ( elem.nodeType === 3 || elem.nodeType === 8 ) {\n\ \t\t\treturn;\n\ \t\t}\n\ \n\ \t\t// focus/blur morphs to focusin/out; ensure we're not firing them right now\n\ \t\tif ( rfocusMorph.test( type + jQuery.event.triggered ) ) {\n\ \t\t\treturn;\n\ \t\t}\n\ \n\ \t\tif ( type.indexOf(\".\") >= 0 ) {\n\ \t\t\t// Namespaced trigger; create a regexp to match event type in handle()\n\ \t\t\tnamespaces = type.split(\".\");\n\ \t\t\ttype = namespaces.shift();\n\ \t\t\tnamespaces.sort();\n\ \t\t}\n\ \t\tontype = type.indexOf(\":\") < 0 && \"on\" + type;\n\ \n\ \t\t// Caller can pass in a jQuery.Event object, Object, or just an event type string\n\ \t\tevent = event[ jQuery.expando ] ?\n\ \t\t\tevent :\n\ \t\t\tnew jQuery.Event( type, typeof event === \"object\" && event );\n\ \n\ \t\t// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)\n\ \t\tevent.isTrigger = onlyHandlers ? 2 : 3;\n\ \t\tevent.namespace = namespaces.join(\".\");\n\ \t\tevent.namespace_re = event.namespace ?\n\ \t\t\tnew RegExp( \"(^|\\\\.)\" + namespaces.join(\"\\\\.(?:.*\\\\.|)\") + \"(\\\\.|$)\" ) :\n\ \t\t\tnull;\n\ \n\ \t\t// Clean up the event in case it is being reused\n\ \t\tevent.result = undefined;\n\ \t\tif ( !event.target ) {\n\ \t\t\tevent.target = elem;\n\ \t\t}\n\ \n\ \t\t// Clone any incoming data and prepend the event, creating the handler arg list\n\ \t\tdata = data == null ?\n\ \t\t\t[ event ] :\n\ \t\t\tjQuery.makeArray( data, [ event ] );\n\ \n\ \t\t// Allow special events to draw outside the lines\n\ \t\tspecial = jQuery.event.special[ type ] || {};\n\ \t\tif ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {\n\ \t\t\treturn;\n\ \t\t}\n\ \n\ \t\t// Determine event propagation path in advance, per W3C events spec (#9951)\n\ \t\t// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)\n\ \t\tif ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {\n\ \n\ \t\t\tbubbleType = special.delegateType || type;\n\ \t\t\tif ( !rfocusMorph.test( bubbleType + type ) ) {\n\ \t\t\t\tcur = cur.parentNode;\n\ \t\t\t}\n\ \t\t\tfor ( ; cur; cur = cur.parentNode ) {\n\ \t\t\t\teventPath.push( cur );\n\ \t\t\t\ttmp = cur;\n\ \t\t\t}\n\ \n\ \t\t\t// Only add window if we got to document (e.g., not plain obj or detached DOM)\n\ \t\t\tif ( tmp === (elem.ownerDocument || document) ) {\n\ \t\t\t\teventPath.push( tmp.defaultView || tmp.parentWindow || window );\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\t// Fire handlers on the event path\n\ \t\ti = 0;\n\ \t\twhile ( (cur = eventPath[i++]) && !event.isPropagationStopped() ) {\n\ \n\ \t\t\tevent.type = i > 1 ?\n\ \t\t\t\tbubbleType :\n\ \t\t\t\tspecial.bindType || type;\n\ \n\ \t\t\t// jQuery handler\n\ \t\t\thandle = ( jQuery._data( cur, \"events\" ) || {} )[ event.type ] && jQuery._data( cur, \"handle\" );\n\ \t\t\tif ( handle ) {\n\ \t\t\t\thandle.apply( cur, data );\n\ \t\t\t}\n\ \n\ \t\t\t// Native handler\n\ \t\t\thandle = ontype && cur[ ontype ];\n\ \t\t\tif ( handle && handle.apply && jQuery.acceptData( cur ) ) {\n\ \t\t\t\tevent.result = handle.apply( cur, data );\n\ \t\t\t\tif ( event.result === false ) {\n\ \t\t\t\t\tevent.preventDefault();\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t}\n\ \t\tevent.type = type;\n\ \n\ \t\t// If nobody prevented the default action, do it now\n\ \t\tif ( !onlyHandlers && !event.isDefaultPrevented() ) {\n\ \n\ \t\t\tif ( (!special._default || special._default.apply( eventPath.pop(), data ) === false) &&\n\ \t\t\t\tjQuery.acceptData( elem ) ) {\n\ \n\ \t\t\t\t// Call a native DOM method on the target with the same name name as the event.\n\ \t\t\t\t// Can't use an .isFunction() check here because IE6/7 fails that test.\n\ \t\t\t\t// Don't do default actions on window, that's where global variables be (#6170)\n\ \t\t\t\tif ( ontype && elem[ type ] && !jQuery.isWindow( elem ) ) {\n\ \n\ \t\t\t\t\t// Don't re-trigger an onFOO event when we call its FOO() method\n\ \t\t\t\t\ttmp = elem[ ontype ];\n\ \n\ \t\t\t\t\tif ( tmp ) {\n\ \t\t\t\t\t\telem[ ontype ] = null;\n\ \t\t\t\t\t}\n\ \n\ \t\t\t\t\t// Prevent re-triggering of the same event, since we already bubbled it above\n\ \t\t\t\t\tjQuery.event.triggered = type;\n\ \t\t\t\t\ttry {\n\ \t\t\t\t\t\telem[ type ]();\n\ \t\t\t\t\t} catch ( e ) {\n\ \t\t\t\t\t\t// IE<9 dies on focus/blur to hidden element (#1486,#12518)\n\ \t\t\t\t\t\t// only reproducible on winXP IE8 native, not IE9 in IE8 mode\n\ \t\t\t\t\t}\n\ \t\t\t\t\tjQuery.event.triggered = undefined;\n\ \n\ \t\t\t\t\tif ( tmp ) {\n\ \t\t\t\t\t\telem[ ontype ] = tmp;\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\treturn event.result;\n\ \t},\n\ \n\ \tdispatch: function( event ) {\n\ \n\ \t\t// Make a writable jQuery.Event from the native event object\n\ \t\tevent = jQuery.event.fix( event );\n\ \n\ \t\tvar i, ret, handleObj, matched, j,\n\ \t\t\thandlerQueue = [],\n\ \t\t\targs = slice.call( arguments ),\n\ \t\t\thandlers = ( jQuery._data( this, \"events\" ) || {} )[ event.type ] || [],\n\ \t\t\tspecial = jQuery.event.special[ event.type ] || {};\n\ \n\ \t\t// Use the fix-ed jQuery.Event rather than the (read-only) native event\n\ \t\targs[0] = event;\n\ \t\tevent.delegateTarget = this;\n\ \n\ \t\t// Call the preDispatch hook for the mapped type, and let it bail if desired\n\ \t\tif ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {\n\ \t\t\treturn;\n\ \t\t}\n\ \n\ \t\t// Determine handlers\n\ \t\thandlerQueue = jQuery.event.handlers.call( this, event, handlers );\n\ \n\ \t\t// Run delegates first; they may want to stop propagation beneath us\n\ \t\ti = 0;\n\ \t\twhile ( (matched = handlerQueue[ i++ ]) && !event.isPropagationStopped() ) {\n\ \t\t\tevent.currentTarget = matched.elem;\n\ \n\ \t\t\tj = 0;\n\ \t\t\twhile ( (handleObj = matched.handlers[ j++ ]) && !event.isImmediatePropagationStopped() ) {\n\ \n\ \t\t\t\t// Triggered event must either 1) have no namespace, or\n\ \t\t\t\t// 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).\n\ \t\t\t\tif ( !event.namespace_re || event.namespace_re.test( handleObj.namespace ) ) {\n\ \n\ \t\t\t\t\tevent.handleObj = handleObj;\n\ \t\t\t\t\tevent.data = handleObj.data;\n\ \n\ \t\t\t\t\tret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )\n\ \t\t\t\t\t\t\t.apply( matched.elem, args );\n\ \n\ \t\t\t\t\tif ( ret !== undefined ) {\n\ \t\t\t\t\t\tif ( (event.result = ret) === false ) {\n\ \t\t\t\t\t\t\tevent.preventDefault();\n\ \t\t\t\t\t\t\tevent.stopPropagation();\n\ \t\t\t\t\t\t}\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\t// Call the postDispatch hook for the mapped type\n\ \t\tif ( special.postDispatch ) {\n\ \t\t\tspecial.postDispatch.call( this, event );\n\ \t\t}\n\ \n\ \t\treturn event.result;\n\ \t},\n\ \n\ \thandlers: function( event, handlers ) {\n\ \t\tvar sel, handleObj, matches, i,\n\ \t\t\thandlerQueue = [],\n\ \t\t\tdelegateCount = handlers.delegateCount,\n\ \t\t\tcur = event.target;\n\ \n\ \t\t// Find delegate handlers\n\ \t\t// Black-hole SVG instance trees (#13180)\n\ \t\t// Avoid non-left-click bubbling in Firefox (#3861)\n\ \t\tif ( delegateCount && cur.nodeType && (!event.button || event.type !== \"click\") ) {\n\ \n\ \t\t\t/* jshint eqeqeq: false */\n\ \t\t\tfor ( ; cur != this; cur = cur.parentNode || this ) {\n\ \t\t\t\t/* jshint eqeqeq: true */\n\ \n\ \t\t\t\t// Don't check non-elements (#13208)\n\ \t\t\t\t// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)\n\ \t\t\t\tif ( cur.nodeType === 1 && (cur.disabled !== true || event.type !== \"click\") ) {\n\ \t\t\t\t\tmatches = [];\n\ \t\t\t\t\tfor ( i = 0; i < delegateCount; i++ ) {\n\ \t\t\t\t\t\thandleObj = handlers[ i ];\n\ \n\ \t\t\t\t\t\t// Don't conflict with Object.prototype properties (#13203)\n\ \t\t\t\t\t\tsel = handleObj.selector + \" \";\n\ \n\ \t\t\t\t\t\tif ( matches[ sel ] === undefined ) {\n\ \t\t\t\t\t\t\tmatches[ sel ] = handleObj.needsContext ?\n\ \t\t\t\t\t\t\t\tjQuery( sel, this ).index( cur ) >= 0 :\n\ \t\t\t\t\t\t\t\tjQuery.find( sel, this, null, [ cur ] ).length;\n\ \t\t\t\t\t\t}\n\ \t\t\t\t\t\tif ( matches[ sel ] ) {\n\ \t\t\t\t\t\t\tmatches.push( handleObj );\n\ \t\t\t\t\t\t}\n\ \t\t\t\t\t}\n\ \t\t\t\t\tif ( matches.length ) {\n\ \t\t\t\t\t\thandlerQueue.push({ elem: cur, handlers: matches });\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\t// Add the remaining (directly-bound) handlers\n\ \t\tif ( delegateCount < handlers.length ) {\n\ \t\t\thandlerQueue.push({ elem: this, handlers: handlers.slice( delegateCount ) });\n\ \t\t}\n\ \n\ \t\treturn handlerQueue;\n\ \t},\n\ \n\ \tfix: function( event ) {\n\ \t\tif ( event[ jQuery.expando ] ) {\n\ \t\t\treturn event;\n\ \t\t}\n\ \n\ \t\t// Create a writable copy of the event object and normalize some properties\n\ \t\tvar i, prop, copy,\n\ \t\t\ttype = event.type,\n\ \t\t\toriginalEvent = event,\n\ \t\t\tfixHook = this.fixHooks[ type ];\n\ \n\ \t\tif ( !fixHook ) {\n\ \t\t\tthis.fixHooks[ type ] = fixHook =\n\ \t\t\t\trmouseEvent.test( type ) ? this.mouseHooks :\n\ \t\t\t\trkeyEvent.test( type ) ? this.keyHooks :\n\ \t\t\t\t{};\n\ \t\t}\n\ \t\tcopy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;\n\ \n\ \t\tevent = new jQuery.Event( originalEvent );\n\ \n\ \t\ti = copy.length;\n\ \t\twhile ( i-- ) {\n\ \t\t\tprop = copy[ i ];\n\ \t\t\tevent[ prop ] = originalEvent[ prop ];\n\ \t\t}\n\ \n\ \t\t// Support: IE<9\n\ \t\t// Fix target property (#1925)\n\ \t\tif ( !event.target ) {\n\ \t\t\tevent.target = originalEvent.srcElement || document;\n\ \t\t}\n\ \n\ \t\t// Support: Chrome 23+, Safari?\n\ \t\t// Target should not be a text node (#504, #13143)\n\ \t\tif ( event.target.nodeType === 3 ) {\n\ \t\t\tevent.target = event.target.parentNode;\n\ \t\t}\n\ \n\ \t\t// Support: IE<9\n\ \t\t// For mouse/key events, metaKey==false if it's undefined (#3368, #11328)\n\ \t\tevent.metaKey = !!event.metaKey;\n\ \n\ \t\treturn fixHook.filter ? fixHook.filter( event, originalEvent ) : event;\n\ \t},\n\ \n\ \t// Includes some event props shared by KeyEvent and MouseEvent\n\ \tprops: \"altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which\".split(\" \"),\n\ \n\ \tfixHooks: {},\n\ \n\ \tkeyHooks: {\n\ \t\tprops: \"char charCode key keyCode\".split(\" \"),\n\ \t\tfilter: function( event, original ) {\n\ \n\ \t\t\t// Add which for key events\n\ \t\t\tif ( event.which == null ) {\n\ \t\t\t\tevent.which = original.charCode != null ? original.charCode : original.keyCode;\n\ \t\t\t}\n\ \n\ \t\t\treturn event;\n\ \t\t}\n\ \t},\n\ \n\ \tmouseHooks: {\n\ \t\tprops: \"button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement\".split(\" \"),\n\ \t\tfilter: function( event, original ) {\n\ \t\t\tvar body, eventDoc, doc,\n\ \t\t\t\tbutton = original.button,\n\ \t\t\t\tfromElement = original.fromElement;\n\ \n\ \t\t\t// Calculate pageX/Y if missing and clientX/Y available\n\ \t\t\tif ( event.pageX == null && original.clientX != null ) {\n\ \t\t\t\teventDoc = event.target.ownerDocument || document;\n\ \t\t\t\tdoc = eventDoc.documentElement;\n\ \t\t\t\tbody = eventDoc.body;\n\ \n\ \t\t\t\tevent.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );\n\ \t\t\t\tevent.pageY = original.clientY + ( doc && doc.scrollTop || body && body.scrollTop || 0 ) - ( doc && doc.clientTop || body && body.clientTop || 0 );\n\ \t\t\t}\n\ \n\ \t\t\t// Add relatedTarget, if necessary\n\ \t\t\tif ( !event.relatedTarget && fromElement ) {\n\ \t\t\t\tevent.relatedTarget = fromElement === event.target ? original.toElement : fromElement;\n\ \t\t\t}\n\ \n\ \t\t\t// Add which for click: 1 === left; 2 === middle; 3 === right\n\ \t\t\t// Note: button is not normalized, so don't use it\n\ \t\t\tif ( !event.which && button !== undefined ) {\n\ \t\t\t\tevent.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );\n\ \t\t\t}\n\ \n\ \t\t\treturn event;\n\ \t\t}\n\ \t},\n\ \n\ \tspecial: {\n\ \t\tload: {\n\ \t\t\t// Prevent triggered image.load events from bubbling to window.load\n\ \t\t\tnoBubble: true\n\ \t\t},\n\ \t\tfocus: {\n\ \t\t\t// Fire native event if possible so blur/focus sequence is correct\n\ \t\t\ttrigger: function() {\n\ \t\t\t\tif ( this !== safeActiveElement() && this.focus ) {\n\ \t\t\t\t\ttry {\n\ \t\t\t\t\t\tthis.focus();\n\ \t\t\t\t\t\treturn false;\n\ \t\t\t\t\t} catch ( e ) {\n\ \t\t\t\t\t\t// Support: IE<9\n\ \t\t\t\t\t\t// If we error on focus to hidden element (#1486, #12518),\n\ \t\t\t\t\t\t// let .trigger() run the handlers\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \t\t\t},\n\ \t\t\tdelegateType: \"focusin\"\n\ \t\t},\n\ \t\tblur: {\n\ \t\t\ttrigger: function() {\n\ \t\t\t\tif ( this === safeActiveElement() && this.blur ) {\n\ \t\t\t\t\tthis.blur();\n\ \t\t\t\t\treturn false;\n\ \t\t\t\t}\n\ \t\t\t},\n\ \t\t\tdelegateType: \"focusout\"\n\ \t\t},\n\ \t\tclick: {\n\ \t\t\t// For checkbox, fire native event so checked state will be right\n\ \t\t\ttrigger: function() {\n\ \t\t\t\tif ( jQuery.nodeName( this, \"input\" ) && this.type === \"checkbox\" && this.click ) {\n\ \t\t\t\t\tthis.click();\n\ \t\t\t\t\treturn false;\n\ \t\t\t\t}\n\ \t\t\t},\n\ \n\ \t\t\t// For cross-browser consistency, don't fire native .click() on links\n\ \t\t\t_default: function( event ) {\n\ \t\t\t\treturn jQuery.nodeName( event.target, \"a\" );\n\ \t\t\t}\n\ \t\t},\n\ \n\ \t\tbeforeunload: {\n\ \t\t\tpostDispatch: function( event ) {\n\ \n\ \t\t\t\t// Support: Firefox 20+\n\ \t\t\t\t// Firefox doesn't alert if the returnValue field is not set.\n\ \t\t\t\tif ( event.result !== undefined && event.originalEvent ) {\n\ \t\t\t\t\tevent.originalEvent.returnValue = event.result;\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t}\n\ \t},\n\ \n\ \tsimulate: function( type, elem, event, bubble ) {\n\ \t\t// Piggyback on a donor event to simulate a different one.\n\ \t\t// Fake originalEvent to avoid donor's stopPropagation, but if the\n\ \t\t// simulated event prevents default then we do the same on the donor.\n\ \t\tvar e = jQuery.extend(\n\ \t\t\tnew jQuery.Event(),\n\ \t\t\tevent,\n\ \t\t\t{\n\ \t\t\t\ttype: type,\n\ \t\t\t\tisSimulated: true,\n\ \t\t\t\toriginalEvent: {}\n\ \t\t\t}\n\ \t\t);\n\ \t\tif ( bubble ) {\n\ \t\t\tjQuery.event.trigger( e, null, elem );\n\ \t\t} else {\n\ \t\t\tjQuery.event.dispatch.call( elem, e );\n\ \t\t}\n\ \t\tif ( e.isDefaultPrevented() ) {\n\ \t\t\tevent.preventDefault();\n\ \t\t}\n\ \t}\n\ };\n\ \n\ jQuery.removeEvent = document.removeEventListener ?\n\ \tfunction( elem, type, handle ) {\n\ \t\tif ( elem.removeEventListener ) {\n\ \t\t\telem.removeEventListener( type, handle, false );\n\ \t\t}\n\ \t} :\n\ \tfunction( elem, type, handle ) {\n\ \t\tvar name = \"on\" + type;\n\ \n\ \t\tif ( elem.detachEvent ) {\n\ \n\ \t\t\t// #8545, #7054, preventing memory leaks for custom events in IE6-8\n\ \t\t\t// detachEvent needed property on element, by name of that event, to properly expose it to GC\n\ \t\t\tif ( typeof elem[ name ] === strundefined ) {\n\ \t\t\t\telem[ name ] = null;\n\ \t\t\t}\n\ \n\ \t\t\telem.detachEvent( name, handle );\n\ \t\t}\n\ \t};\n\ \n\ jQuery.Event = function( src, props ) {\n\ \t// Allow instantiation without the 'new' keyword\n\ \tif ( !(this instanceof jQuery.Event) ) {\n\ \t\treturn new jQuery.Event( src, props );\n\ \t}\n\ \n\ \t// Event object\n\ \tif ( src && src.type ) {\n\ \t\tthis.originalEvent = src;\n\ \t\tthis.type = src.type;\n\ \n\ \t\t// Events bubbling up the document may have been marked as prevented\n\ \t\t// by a handler lower down the tree; reflect the correct value.\n\ \t\tthis.isDefaultPrevented = src.defaultPrevented ||\n\ \t\t\t\tsrc.defaultPrevented === undefined &&\n\ \t\t\t\t// Support: IE < 9, Android < 4.0\n\ \t\t\t\tsrc.returnValue === false ?\n\ \t\t\treturnTrue :\n\ \t\t\treturnFalse;\n\ \n\ \t// Event type\n\ \t} else {\n\ \t\tthis.type = src;\n\ \t}\n\ \n\ \t// Put explicitly provided properties onto the event object\n\ \tif ( props ) {\n\ \t\tjQuery.extend( this, props );\n\ \t}\n\ \n\ \t// Create a timestamp if incoming event doesn't have one\n\ \tthis.timeStamp = src && src.timeStamp || jQuery.now();\n\ \n\ \t// Mark it as fixed\n\ \tthis[ jQuery.expando ] = true;\n\ };\n\ \n\ // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding\n\ // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html\n\ jQuery.Event.prototype = {\n\ \tisDefaultPrevented: returnFalse,\n\ \tisPropagationStopped: returnFalse,\n\ \tisImmediatePropagationStopped: returnFalse,\n\ \n\ \tpreventDefault: function() {\n\ \t\tvar e = this.originalEvent;\n\ \n\ \t\tthis.isDefaultPrevented = returnTrue;\n\ \t\tif ( !e ) {\n\ \t\t\treturn;\n\ \t\t}\n\ \n\ \t\t// If preventDefault exists, run it on the original event\n\ \t\tif ( e.preventDefault ) {\n\ \t\t\te.preventDefault();\n\ \n\ \t\t// Support: IE\n\ \t\t// Otherwise set the returnValue property of the original event to false\n\ \t\t} else {\n\ \t\t\te.returnValue = false;\n\ \t\t}\n\ \t},\n\ \tstopPropagation: function() {\n\ \t\tvar e = this.originalEvent;\n\ \n\ \t\tthis.isPropagationStopped = returnTrue;\n\ \t\tif ( !e ) {\n\ \t\t\treturn;\n\ \t\t}\n\ \t\t// If stopPropagation exists, run it on the original event\n\ \t\tif ( e.stopPropagation ) {\n\ \t\t\te.stopPropagation();\n\ \t\t}\n\ \n\ \t\t// Support: IE\n\ \t\t// Set the cancelBubble property of the original event to true\n\ \t\te.cancelBubble = true;\n\ \t},\n\ \tstopImmediatePropagation: function() {\n\ \t\tvar e = this.originalEvent;\n\ \n\ \t\tthis.isImmediatePropagationStopped = returnTrue;\n\ \n\ \t\tif ( e && e.stopImmediatePropagation ) {\n\ \t\t\te.stopImmediatePropagation();\n\ \t\t}\n\ \n\ \t\tthis.stopPropagation();\n\ \t}\n\ };\n\ \n\ // Create mouseenter/leave events using mouseover/out and event-time checks\n\ jQuery.each({\n\ \tmouseenter: \"mouseover\",\n\ \tmouseleave: \"mouseout\",\n\ \tpointerenter: \"pointerover\",\n\ \tpointerleave: \"pointerout\"\n\ }, function( orig, fix ) {\n\ \tjQuery.event.special[ orig ] = {\n\ \t\tdelegateType: fix,\n\ \t\tbindType: fix,\n\ \n\ \t\thandle: function( event ) {\n\ \t\t\tvar ret,\n\ \t\t\t\ttarget = this,\n\ \t\t\t\trelated = event.relatedTarget,\n\ \t\t\t\thandleObj = event.handleObj;\n\ \n\ \t\t\t// For mousenter/leave call the handler if related is outside the target.\n\ \t\t\t// NB: No relatedTarget if the mouse left/entered the browser window\n\ \t\t\tif ( !related || (related !== target && !jQuery.contains( target, related )) ) {\n\ \t\t\t\tevent.type = handleObj.origType;\n\ \t\t\t\tret = handleObj.handler.apply( this, arguments );\n\ \t\t\t\tevent.type = fix;\n\ \t\t\t}\n\ \t\t\treturn ret;\n\ \t\t}\n\ \t};\n\ });\n\ \n\ // IE submit delegation\n\ if ( !support.submitBubbles ) {\n\ \n\ \tjQuery.event.special.submit = {\n\ \t\tsetup: function() {\n\ \t\t\t// Only need this for delegated form submit events\n\ \t\t\tif ( jQuery.nodeName( this, \"form\" ) ) {\n\ \t\t\t\treturn false;\n\ \t\t\t}\n\ \n\ \t\t\t// Lazy-add a submit handler when a descendant form may potentially be submitted\n\ \t\t\tjQuery.event.add( this, \"click._submit keypress._submit\", function( e ) {\n\ \t\t\t\t// Node name check avoids a VML-related crash in IE (#9807)\n\ \t\t\t\tvar elem = e.target,\n\ \t\t\t\t\tform = jQuery.nodeName( elem, \"input\" ) || jQuery.nodeName( elem, \"button\" ) ? elem.form : undefined;\n\ \t\t\t\tif ( form && !jQuery._data( form, \"submitBubbles\" ) ) {\n\ \t\t\t\t\tjQuery.event.add( form, \"submit._submit\", function( event ) {\n\ \t\t\t\t\t\tevent._submit_bubble = true;\n\ \t\t\t\t\t});\n\ \t\t\t\t\tjQuery._data( form, \"submitBubbles\", true );\n\ \t\t\t\t}\n\ \t\t\t});\n\ \t\t\t// return undefined since we don't need an event listener\n\ \t\t},\n\ \n\ \t\tpostDispatch: function( event ) {\n\ \t\t\t// If form was submitted by the user, bubble the event up the tree\n\ \t\t\tif ( event._submit_bubble ) {\n\ \t\t\t\tdelete event._submit_bubble;\n\ \t\t\t\tif ( this.parentNode && !event.isTrigger ) {\n\ \t\t\t\t\tjQuery.event.simulate( \"submit\", this.parentNode, event, true );\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t},\n\ \n\ \t\tteardown: function() {\n\ \t\t\t// Only need this for delegated form submit events\n\ \t\t\tif ( jQuery.nodeName( this, \"form\" ) ) {\n\ \t\t\t\treturn false;\n\ \t\t\t}\n\ \n\ \t\t\t// Remove delegated handlers; cleanData eventually reaps submit handlers attached above\n\ \t\t\tjQuery.event.remove( this, \"._submit\" );\n\ \t\t}\n\ \t};\n\ }\n\ \n\ // IE change delegation and checkbox/radio fix\n\ if ( !support.changeBubbles ) {\n\ \n\ \tjQuery.event.special.change = {\n\ \n\ \t\tsetup: function() {\n\ \n\ \t\t\tif ( rformElems.test( this.nodeName ) ) {\n\ \t\t\t\t// IE doesn't fire change on a check/radio until blur; trigger it on click\n\ \t\t\t\t// after a propertychange. Eat the blur-change in special.change.handle.\n\ \t\t\t\t// This still fires onchange a second time for check/radio after blur.\n\ \t\t\t\tif ( this.type === \"checkbox\" || this.type === \"radio\" ) {\n\ \t\t\t\t\tjQuery.event.add( this, \"propertychange._change\", function( event ) {\n\ \t\t\t\t\t\tif ( event.originalEvent.propertyName === \"checked\" ) {\n\ \t\t\t\t\t\t\tthis._just_changed = true;\n\ \t\t\t\t\t\t}\n\ \t\t\t\t\t});\n\ \t\t\t\t\tjQuery.event.add( this, \"click._change\", function( event ) {\n\ \t\t\t\t\t\tif ( this._just_changed && !event.isTrigger ) {\n\ \t\t\t\t\t\t\tthis._just_changed = false;\n\ \t\t\t\t\t\t}\n\ \t\t\t\t\t\t// Allow triggered, simulated change events (#11500)\n\ \t\t\t\t\t\tjQuery.event.simulate( \"change\", this, event, true );\n\ \t\t\t\t\t});\n\ \t\t\t\t}\n\ \t\t\t\treturn false;\n\ \t\t\t}\n\ \t\t\t// Delegated event; lazy-add a change handler on descendant inputs\n\ \t\t\tjQuery.event.add( this, \"beforeactivate._change\", function( e ) {\n\ \t\t\t\tvar elem = e.target;\n\ \n\ \t\t\t\tif ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, \"changeBubbles\" ) ) {\n\ \t\t\t\t\tjQuery.event.add( elem, \"change._change\", function( event ) {\n\ \t\t\t\t\t\tif ( this.parentNode && !event.isSimulated && !event.isTrigger ) {\n\ \t\t\t\t\t\t\tjQuery.event.simulate( \"change\", this.parentNode, event, true );\n\ \t\t\t\t\t\t}\n\ \t\t\t\t\t});\n\ \t\t\t\t\tjQuery._data( elem, \"changeBubbles\", true );\n\ \t\t\t\t}\n\ \t\t\t});\n\ \t\t},\n\ \n\ \t\thandle: function( event ) {\n\ \t\t\tvar elem = event.target;\n\ \n\ \t\t\t// Swallow native change events from checkbox/radio, we already triggered them above\n\ \t\t\tif ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== \"radio\" && elem.type !== \"checkbox\") ) {\n\ \t\t\t\treturn event.handleObj.handler.apply( this, arguments );\n\ \t\t\t}\n\ \t\t},\n\ \n\ \t\tteardown: function() {\n\ \t\t\tjQuery.event.remove( this, \"._change\" );\n\ \n\ \t\t\treturn !rformElems.test( this.nodeName );\n\ \t\t}\n\ \t};\n\ }\n\ \n\ // Create \"bubbling\" focus and blur events\n\ if ( !support.focusinBubbles ) {\n\ \tjQuery.each({ focus: \"focusin\", blur: \"focusout\" }, function( orig, fix ) {\n\ \n\ \t\t// Attach a single capturing handler on the document while someone wants focusin/focusout\n\ \t\tvar handler = function( event ) {\n\ \t\t\t\tjQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true );\n\ \t\t\t};\n\ \n\ \t\tjQuery.event.special[ fix ] = {\n\ \t\t\tsetup: function() {\n\ \t\t\t\tvar doc = this.ownerDocument || this,\n\ \t\t\t\t\tattaches = jQuery._data( doc, fix );\n\ \n\ \t\t\t\tif ( !attaches ) {\n\ \t\t\t\t\tdoc.addEventListener( orig, handler, true );\n\ \t\t\t\t}\n\ \t\t\t\tjQuery._data( doc, fix, ( attaches || 0 ) + 1 );\n\ \t\t\t},\n\ \t\t\tteardown: function() {\n\ \t\t\t\tvar doc = this.ownerDocument || this,\n\ \t\t\t\t\tattaches = jQuery._data( doc, fix ) - 1;\n\ \n\ \t\t\t\tif ( !attaches ) {\n\ \t\t\t\t\tdoc.removeEventListener( orig, handler, true );\n\ \t\t\t\t\tjQuery._removeData( doc, fix );\n\ \t\t\t\t} else {\n\ \t\t\t\t\tjQuery._data( doc, fix, attaches );\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t};\n\ \t});\n\ }\n\ \n\ jQuery.fn.extend({\n\ \n\ \ton: function( types, selector, data, fn, /*INTERNAL*/ one ) {\n\ \t\tvar type, origFn;\n\ \n\ \t\t// Types can be a map of types/handlers\n\ \t\tif ( typeof types === \"object\" ) {\n\ \t\t\t// ( types-Object, selector, data )\n\ \t\t\tif ( typeof selector !== \"string\" ) {\n\ \t\t\t\t// ( types-Object, data )\n\ \t\t\t\tdata = data || selector;\n\ \t\t\t\tselector = undefined;\n\ \t\t\t}\n\ \t\t\tfor ( type in types ) {\n\ \t\t\t\tthis.on( type, selector, data, types[ type ], one );\n\ \t\t\t}\n\ \t\t\treturn this;\n\ \t\t}\n\ \n\ \t\tif ( data == null && fn == null ) {\n\ \t\t\t// ( types, fn )\n\ \t\t\tfn = selector;\n\ \t\t\tdata = selector = undefined;\n\ \t\t} else if ( fn == null ) {\n\ \t\t\tif ( typeof selector === \"string\" ) {\n\ \t\t\t\t// ( types, selector, fn )\n\ \t\t\t\tfn = data;\n\ \t\t\t\tdata = undefined;\n\ \t\t\t} else {\n\ \t\t\t\t// ( types, data, fn )\n\ \t\t\t\tfn = data;\n\ \t\t\t\tdata = selector;\n\ \t\t\t\tselector = undefined;\n\ \t\t\t}\n\ \t\t}\n\ \t\tif ( fn === false ) {\n\ \t\t\tfn = returnFalse;\n\ \t\t} else if ( !fn ) {\n\ \t\t\treturn this;\n\ \t\t}\n\ \n\ \t\tif ( one === 1 ) {\n\ \t\t\torigFn = fn;\n\ \t\t\tfn = function( event ) {\n\ \t\t\t\t// Can use an empty set, since event contains the info\n\ \t\t\t\tjQuery().off( event );\n\ \t\t\t\treturn origFn.apply( this, arguments );\n\ \t\t\t};\n\ \t\t\t// Use same guid so caller can remove using origFn\n\ \t\t\tfn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );\n\ \t\t}\n\ \t\treturn this.each( function() {\n\ \t\t\tjQuery.event.add( this, types, fn, data, selector );\n\ \t\t});\n\ \t},\n\ \tone: function( types, selector, data, fn ) {\n\ \t\treturn this.on( types, selector, data, fn, 1 );\n\ \t},\n\ \toff: function( types, selector, fn ) {\n\ \t\tvar handleObj, type;\n\ \t\tif ( types && types.preventDefault && types.handleObj ) {\n\ \t\t\t// ( event ) dispatched jQuery.Event\n\ \t\t\thandleObj = types.handleObj;\n\ \t\t\tjQuery( types.delegateTarget ).off(\n\ \t\t\t\thandleObj.namespace ? handleObj.origType + \".\" + handleObj.namespace : handleObj.origType,\n\ \t\t\t\thandleObj.selector,\n\ \t\t\t\thandleObj.handler\n\ \t\t\t);\n\ \t\t\treturn this;\n\ \t\t}\n\ \t\tif ( typeof types === \"object\" ) {\n\ \t\t\t// ( types-object [, selector] )\n\ \t\t\tfor ( type in types ) {\n\ \t\t\t\tthis.off( type, selector, types[ type ] );\n\ \t\t\t}\n\ \t\t\treturn this;\n\ \t\t}\n\ \t\tif ( selector === false || typeof selector === \"function\" ) {\n\ \t\t\t// ( types [, fn] )\n\ \t\t\tfn = selector;\n\ \t\t\tselector = undefined;\n\ \t\t}\n\ \t\tif ( fn === false ) {\n\ \t\t\tfn = returnFalse;\n\ \t\t}\n\ \t\treturn this.each(function() {\n\ \t\t\tjQuery.event.remove( this, types, fn, selector );\n\ \t\t});\n\ \t},\n\ \n\ \ttrigger: function( type, data ) {\n\ \t\treturn this.each(function() {\n\ \t\t\tjQuery.event.trigger( type, data, this );\n\ \t\t});\n\ \t},\n\ \ttriggerHandler: function( type, data ) {\n\ \t\tvar elem = this[0];\n\ \t\tif ( elem ) {\n\ \t\t\treturn jQuery.event.trigger( type, data, elem, true );\n\ \t\t}\n\ \t}\n\ });\n\ \n\ \n\ function createSafeFragment( document ) {\n\ \tvar list = nodeNames.split( \"|\" ),\n\ \t\tsafeFrag = document.createDocumentFragment();\n\ \n\ \tif ( safeFrag.createElement ) {\n\ \t\twhile ( list.length ) {\n\ \t\t\tsafeFrag.createElement(\n\ \t\t\t\tlist.pop()\n\ \t\t\t);\n\ \t\t}\n\ \t}\n\ \treturn safeFrag;\n\ }\n\ \n\ var nodeNames = \"abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|\" +\n\ \t\t\"header|hgroup|mark|meter|nav|output|progress|section|summary|time|video\",\n\ \trinlinejQuery = / jQuery\\d+=\"(?:null|\\d+)\"/g,\n\ \trnoshimcache = new RegExp(\"<(?:\" + nodeNames + \")[\\\\s/>]\", \"i\"),\n\ \trleadingWhitespace = /^\\s+/,\n\ \trxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\\w:]+)[^>]*)\\/>/gi,\n\ \trtagName = /<([\\w:]+)/,\n\ \trtbody = /\\s*$/g,\n\ \n\ \t// We have to close these tags to support XHTML (#13200)\n\ \twrapMap = {\n\ \t\toption: [ 1, \"\" ],\n\ \t\tlegend: [ 1, \"
    \", \"
    \" ],\n\ \t\tarea: [ 1, \"\", \"\" ],\n\ \t\tparam: [ 1, \"\", \"\" ],\n\ \t\tthead: [ 1, \"\", \"
    \" ],\n\ \t\ttr: [ 2, \"\", \"
    \" ],\n\ \t\tcol: [ 2, \"\", \"
    \" ],\n\ \t\ttd: [ 3, \"\", \"
    \" ],\n\ \n\ \t\t// IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags,\n\ \t\t// unless wrapped in a div with non-breaking characters in front of it.\n\ \t\t_default: support.htmlSerialize ? [ 0, \"\", \"\" ] : [ 1, \"X
    \", \"
    \" ]\n\ \t},\n\ \tsafeFragment = createSafeFragment( document ),\n\ \tfragmentDiv = safeFragment.appendChild( document.createElement(\"div\") );\n\ \n\ wrapMap.optgroup = wrapMap.option;\n\ wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;\n\ wrapMap.th = wrapMap.td;\n\ \n\ function getAll( context, tag ) {\n\ \tvar elems, elem,\n\ \t\ti = 0,\n\ \t\tfound = typeof context.getElementsByTagName !== strundefined ? context.getElementsByTagName( tag || \"*\" ) :\n\ \t\t\ttypeof context.querySelectorAll !== strundefined ? context.querySelectorAll( tag || \"*\" ) :\n\ \t\t\tundefined;\n\ \n\ \tif ( !found ) {\n\ \t\tfor ( found = [], elems = context.childNodes || context; (elem = elems[i]) != null; i++ ) {\n\ \t\t\tif ( !tag || jQuery.nodeName( elem, tag ) ) {\n\ \t\t\t\tfound.push( elem );\n\ \t\t\t} else {\n\ \t\t\t\tjQuery.merge( found, getAll( elem, tag ) );\n\ \t\t\t}\n\ \t\t}\n\ \t}\n\ \n\ \treturn tag === undefined || tag && jQuery.nodeName( context, tag ) ?\n\ \t\tjQuery.merge( [ context ], found ) :\n\ \t\tfound;\n\ }\n\ \n\ // Used in buildFragment, fixes the defaultChecked property\n\ function fixDefaultChecked( elem ) {\n\ \tif ( rcheckableType.test( elem.type ) ) {\n\ \t\telem.defaultChecked = elem.checked;\n\ \t}\n\ }\n\ \n\ // Support: IE<8\n\ // Manipulating tables requires a tbody\n\ function manipulationTarget( elem, content ) {\n\ \treturn jQuery.nodeName( elem, \"table\" ) &&\n\ \t\tjQuery.nodeName( content.nodeType !== 11 ? content : content.firstChild, \"tr\" ) ?\n\ \n\ \t\telem.getElementsByTagName(\"tbody\")[0] ||\n\ \t\t\telem.appendChild( elem.ownerDocument.createElement(\"tbody\") ) :\n\ \t\telem;\n\ }\n\ \n\ // Replace/restore the type attribute of script elements for safe DOM manipulation\n\ function disableScript( elem ) {\n\ \telem.type = (jQuery.find.attr( elem, \"type\" ) !== null) + \"/\" + elem.type;\n\ \treturn elem;\n\ }\n\ function restoreScript( elem ) {\n\ \tvar match = rscriptTypeMasked.exec( elem.type );\n\ \tif ( match ) {\n\ \t\telem.type = match[1];\n\ \t} else {\n\ \t\telem.removeAttribute(\"type\");\n\ \t}\n\ \treturn elem;\n\ }\n\ \n\ // Mark scripts as having already been evaluated\n\ function setGlobalEval( elems, refElements ) {\n\ \tvar elem,\n\ \t\ti = 0;\n\ \tfor ( ; (elem = elems[i]) != null; i++ ) {\n\ \t\tjQuery._data( elem, \"globalEval\", !refElements || jQuery._data( refElements[i], \"globalEval\" ) );\n\ \t}\n\ }\n\ \n\ function cloneCopyEvent( src, dest ) {\n\ \n\ \tif ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {\n\ \t\treturn;\n\ \t}\n\ \n\ \tvar type, i, l,\n\ \t\toldData = jQuery._data( src ),\n\ \t\tcurData = jQuery._data( dest, oldData ),\n\ \t\tevents = oldData.events;\n\ \n\ \tif ( events ) {\n\ \t\tdelete curData.handle;\n\ \t\tcurData.events = {};\n\ \n\ \t\tfor ( type in events ) {\n\ \t\t\tfor ( i = 0, l = events[ type ].length; i < l; i++ ) {\n\ \t\t\t\tjQuery.event.add( dest, type, events[ type ][ i ] );\n\ \t\t\t}\n\ \t\t}\n\ \t}\n\ \n\ \t// make the cloned public data object a copy from the original\n\ \tif ( curData.data ) {\n\ \t\tcurData.data = jQuery.extend( {}, curData.data );\n\ \t}\n\ }\n\ \n\ function fixCloneNodeIssues( src, dest ) {\n\ \tvar nodeName, e, data;\n\ \n\ \t// We do not need to do anything for non-Elements\n\ \tif ( dest.nodeType !== 1 ) {\n\ \t\treturn;\n\ \t}\n\ \n\ \tnodeName = dest.nodeName.toLowerCase();\n\ \n\ \t// IE6-8 copies events bound via attachEvent when using cloneNode.\n\ \tif ( !support.noCloneEvent && dest[ jQuery.expando ] ) {\n\ \t\tdata = jQuery._data( dest );\n\ \n\ \t\tfor ( e in data.events ) {\n\ \t\t\tjQuery.removeEvent( dest, e, data.handle );\n\ \t\t}\n\ \n\ \t\t// Event data gets referenced instead of copied if the expando gets copied too\n\ \t\tdest.removeAttribute( jQuery.expando );\n\ \t}\n\ \n\ \t// IE blanks contents when cloning scripts, and tries to evaluate newly-set text\n\ \tif ( nodeName === \"script\" && dest.text !== src.text ) {\n\ \t\tdisableScript( dest ).text = src.text;\n\ \t\trestoreScript( dest );\n\ \n\ \t// IE6-10 improperly clones children of object elements using classid.\n\ \t// IE10 throws NoModificationAllowedError if parent is null, #12132.\n\ \t} else if ( nodeName === \"object\" ) {\n\ \t\tif ( dest.parentNode ) {\n\ \t\t\tdest.outerHTML = src.outerHTML;\n\ \t\t}\n\ \n\ \t\t// This path appears unavoidable for IE9. When cloning an object\n\ \t\t// element in IE9, the outerHTML strategy above is not sufficient.\n\ \t\t// If the src has innerHTML and the destination does not,\n\ \t\t// copy the src.innerHTML into the dest.innerHTML. #10324\n\ \t\tif ( support.html5Clone && ( src.innerHTML && !jQuery.trim(dest.innerHTML) ) ) {\n\ \t\t\tdest.innerHTML = src.innerHTML;\n\ \t\t}\n\ \n\ \t} else if ( nodeName === \"input\" && rcheckableType.test( src.type ) ) {\n\ \t\t// IE6-8 fails to persist the checked state of a cloned checkbox\n\ \t\t// or radio button. Worse, IE6-7 fail to give the cloned element\n\ \t\t// a checked appearance if the defaultChecked value isn't also set\n\ \n\ \t\tdest.defaultChecked = dest.checked = src.checked;\n\ \n\ \t\t// IE6-7 get confused and end up setting the value of a cloned\n\ \t\t// checkbox/radio button to an empty string instead of \"on\"\n\ \t\tif ( dest.value !== src.value ) {\n\ \t\t\tdest.value = src.value;\n\ \t\t}\n\ \n\ \t// IE6-8 fails to return the selected option to the default selected\n\ \t// state when cloning options\n\ \t} else if ( nodeName === \"option\" ) {\n\ \t\tdest.defaultSelected = dest.selected = src.defaultSelected;\n\ \n\ \t// IE6-8 fails to set the defaultValue to the correct value when\n\ \t// cloning other types of input fields\n\ \t} else if ( nodeName === \"input\" || nodeName === \"textarea\" ) {\n\ \t\tdest.defaultValue = src.defaultValue;\n\ \t}\n\ }\n\ \n\ jQuery.extend({\n\ \tclone: function( elem, dataAndEvents, deepDataAndEvents ) {\n\ \t\tvar destElements, node, clone, i, srcElements,\n\ \t\t\tinPage = jQuery.contains( elem.ownerDocument, elem );\n\ \n\ \t\tif ( support.html5Clone || jQuery.isXMLDoc(elem) || !rnoshimcache.test( \"<\" + elem.nodeName + \">\" ) ) {\n\ \t\t\tclone = elem.cloneNode( true );\n\ \n\ \t\t// IE<=8 does not properly clone detached, unknown element nodes\n\ \t\t} else {\n\ \t\t\tfragmentDiv.innerHTML = elem.outerHTML;\n\ \t\t\tfragmentDiv.removeChild( clone = fragmentDiv.firstChild );\n\ \t\t}\n\ \n\ \t\tif ( (!support.noCloneEvent || !support.noCloneChecked) &&\n\ \t\t\t\t(elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {\n\ \n\ \t\t\t// We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2\n\ \t\t\tdestElements = getAll( clone );\n\ \t\t\tsrcElements = getAll( elem );\n\ \n\ \t\t\t// Fix all IE cloning issues\n\ \t\t\tfor ( i = 0; (node = srcElements[i]) != null; ++i ) {\n\ \t\t\t\t// Ensure that the destination node is not null; Fixes #9587\n\ \t\t\t\tif ( destElements[i] ) {\n\ \t\t\t\t\tfixCloneNodeIssues( node, destElements[i] );\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\t// Copy the events from the original to the clone\n\ \t\tif ( dataAndEvents ) {\n\ \t\t\tif ( deepDataAndEvents ) {\n\ \t\t\t\tsrcElements = srcElements || getAll( elem );\n\ \t\t\t\tdestElements = destElements || getAll( clone );\n\ \n\ \t\t\t\tfor ( i = 0; (node = srcElements[i]) != null; i++ ) {\n\ \t\t\t\t\tcloneCopyEvent( node, destElements[i] );\n\ \t\t\t\t}\n\ \t\t\t} else {\n\ \t\t\t\tcloneCopyEvent( elem, clone );\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\t// Preserve script evaluation history\n\ \t\tdestElements = getAll( clone, \"script\" );\n\ \t\tif ( destElements.length > 0 ) {\n\ \t\t\tsetGlobalEval( destElements, !inPage && getAll( elem, \"script\" ) );\n\ \t\t}\n\ \n\ \t\tdestElements = srcElements = node = null;\n\ \n\ \t\t// Return the cloned set\n\ \t\treturn clone;\n\ \t},\n\ \n\ \tbuildFragment: function( elems, context, scripts, selection ) {\n\ \t\tvar j, elem, contains,\n\ \t\t\ttmp, tag, tbody, wrap,\n\ \t\t\tl = elems.length,\n\ \n\ \t\t\t// Ensure a safe fragment\n\ \t\t\tsafe = createSafeFragment( context ),\n\ \n\ \t\t\tnodes = [],\n\ \t\t\ti = 0;\n\ \n\ \t\tfor ( ; i < l; i++ ) {\n\ \t\t\telem = elems[ i ];\n\ \n\ \t\t\tif ( elem || elem === 0 ) {\n\ \n\ \t\t\t\t// Add nodes directly\n\ \t\t\t\tif ( jQuery.type( elem ) === \"object\" ) {\n\ \t\t\t\t\tjQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );\n\ \n\ \t\t\t\t// Convert non-html into a text node\n\ \t\t\t\t} else if ( !rhtml.test( elem ) ) {\n\ \t\t\t\t\tnodes.push( context.createTextNode( elem ) );\n\ \n\ \t\t\t\t// Convert html into DOM nodes\n\ \t\t\t\t} else {\n\ \t\t\t\t\ttmp = tmp || safe.appendChild( context.createElement(\"div\") );\n\ \n\ \t\t\t\t\t// Deserialize a standard representation\n\ \t\t\t\t\ttag = (rtagName.exec( elem ) || [ \"\", \"\" ])[ 1 ].toLowerCase();\n\ \t\t\t\t\twrap = wrapMap[ tag ] || wrapMap._default;\n\ \n\ \t\t\t\t\ttmp.innerHTML = wrap[1] + elem.replace( rxhtmlTag, \"<$1>\" ) + wrap[2];\n\ \n\ \t\t\t\t\t// Descend through wrappers to the right content\n\ \t\t\t\t\tj = wrap[0];\n\ \t\t\t\t\twhile ( j-- ) {\n\ \t\t\t\t\t\ttmp = tmp.lastChild;\n\ \t\t\t\t\t}\n\ \n\ \t\t\t\t\t// Manually add leading whitespace removed by IE\n\ \t\t\t\t\tif ( !support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {\n\ \t\t\t\t\t\tnodes.push( context.createTextNode( rleadingWhitespace.exec( elem )[0] ) );\n\ \t\t\t\t\t}\n\ \n\ \t\t\t\t\t// Remove IE's autoinserted from table fragments\n\ \t\t\t\t\tif ( !support.tbody ) {\n\ \n\ \t\t\t\t\t\t// String was a , *may* have spurious \n\ \t\t\t\t\t\telem = tag === \"table\" && !rtbody.test( elem ) ?\n\ \t\t\t\t\t\t\ttmp.firstChild :\n\ \n\ \t\t\t\t\t\t\t// String was a bare or \n\ \t\t\t\t\t\t\twrap[1] === \"
    \" && !rtbody.test( elem ) ?\n\ \t\t\t\t\t\t\t\ttmp :\n\ \t\t\t\t\t\t\t\t0;\n\ \n\ \t\t\t\t\t\tj = elem && elem.childNodes.length;\n\ \t\t\t\t\t\twhile ( j-- ) {\n\ \t\t\t\t\t\t\tif ( jQuery.nodeName( (tbody = elem.childNodes[j]), \"tbody\" ) && !tbody.childNodes.length ) {\n\ \t\t\t\t\t\t\t\telem.removeChild( tbody );\n\ \t\t\t\t\t\t\t}\n\ \t\t\t\t\t\t}\n\ \t\t\t\t\t}\n\ \n\ \t\t\t\t\tjQuery.merge( nodes, tmp.childNodes );\n\ \n\ \t\t\t\t\t// Fix #12392 for WebKit and IE > 9\n\ \t\t\t\t\ttmp.textContent = \"\";\n\ \n\ \t\t\t\t\t// Fix #12392 for oldIE\n\ \t\t\t\t\twhile ( tmp.firstChild ) {\n\ \t\t\t\t\t\ttmp.removeChild( tmp.firstChild );\n\ \t\t\t\t\t}\n\ \n\ \t\t\t\t\t// Remember the top-level container for proper cleanup\n\ \t\t\t\t\ttmp = safe.lastChild;\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\t// Fix #11356: Clear elements from fragment\n\ \t\tif ( tmp ) {\n\ \t\t\tsafe.removeChild( tmp );\n\ \t\t}\n\ \n\ \t\t// Reset defaultChecked for any radios and checkboxes\n\ \t\t// about to be appended to the DOM in IE 6/7 (#8060)\n\ \t\tif ( !support.appendChecked ) {\n\ \t\t\tjQuery.grep( getAll( nodes, \"input\" ), fixDefaultChecked );\n\ \t\t}\n\ \n\ \t\ti = 0;\n\ \t\twhile ( (elem = nodes[ i++ ]) ) {\n\ \n\ \t\t\t// #4087 - If origin and destination elements are the same, and this is\n\ \t\t\t// that element, do not do anything\n\ \t\t\tif ( selection && jQuery.inArray( elem, selection ) !== -1 ) {\n\ \t\t\t\tcontinue;\n\ \t\t\t}\n\ \n\ \t\t\tcontains = jQuery.contains( elem.ownerDocument, elem );\n\ \n\ \t\t\t// Append to fragment\n\ \t\t\ttmp = getAll( safe.appendChild( elem ), \"script\" );\n\ \n\ \t\t\t// Preserve script evaluation history\n\ \t\t\tif ( contains ) {\n\ \t\t\t\tsetGlobalEval( tmp );\n\ \t\t\t}\n\ \n\ \t\t\t// Capture executables\n\ \t\t\tif ( scripts ) {\n\ \t\t\t\tj = 0;\n\ \t\t\t\twhile ( (elem = tmp[ j++ ]) ) {\n\ \t\t\t\t\tif ( rscriptType.test( elem.type || \"\" ) ) {\n\ \t\t\t\t\t\tscripts.push( elem );\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\ttmp = null;\n\ \n\ \t\treturn safe;\n\ \t},\n\ \n\ \tcleanData: function( elems, /* internal */ acceptData ) {\n\ \t\tvar elem, type, id, data,\n\ \t\t\ti = 0,\n\ \t\t\tinternalKey = jQuery.expando,\n\ \t\t\tcache = jQuery.cache,\n\ \t\t\tdeleteExpando = support.deleteExpando,\n\ \t\t\tspecial = jQuery.event.special;\n\ \n\ \t\tfor ( ; (elem = elems[i]) != null; i++ ) {\n\ \t\t\tif ( acceptData || jQuery.acceptData( elem ) ) {\n\ \n\ \t\t\t\tid = elem[ internalKey ];\n\ \t\t\t\tdata = id && cache[ id ];\n\ \n\ \t\t\t\tif ( data ) {\n\ \t\t\t\t\tif ( data.events ) {\n\ \t\t\t\t\t\tfor ( type in data.events ) {\n\ \t\t\t\t\t\t\tif ( special[ type ] ) {\n\ \t\t\t\t\t\t\t\tjQuery.event.remove( elem, type );\n\ \n\ \t\t\t\t\t\t\t// This is a shortcut to avoid jQuery.event.remove's overhead\n\ \t\t\t\t\t\t\t} else {\n\ \t\t\t\t\t\t\t\tjQuery.removeEvent( elem, type, data.handle );\n\ \t\t\t\t\t\t\t}\n\ \t\t\t\t\t\t}\n\ \t\t\t\t\t}\n\ \n\ \t\t\t\t\t// Remove cache only if it was not already removed by jQuery.event.remove\n\ \t\t\t\t\tif ( cache[ id ] ) {\n\ \n\ \t\t\t\t\t\tdelete cache[ id ];\n\ \n\ \t\t\t\t\t\t// IE does not allow us to delete expando properties from nodes,\n\ \t\t\t\t\t\t// nor does it have a removeAttribute function on Document nodes;\n\ \t\t\t\t\t\t// we must handle all of these cases\n\ \t\t\t\t\t\tif ( deleteExpando ) {\n\ \t\t\t\t\t\t\tdelete elem[ internalKey ];\n\ \n\ \t\t\t\t\t\t} else if ( typeof elem.removeAttribute !== strundefined ) {\n\ \t\t\t\t\t\t\telem.removeAttribute( internalKey );\n\ \n\ \t\t\t\t\t\t} else {\n\ \t\t\t\t\t\t\telem[ internalKey ] = null;\n\ \t\t\t\t\t\t}\n\ \n\ \t\t\t\t\t\tdeletedIds.push( id );\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \t\t\t}\n\ \t\t}\n\ \t}\n\ });\n\ \n\ jQuery.fn.extend({\n\ \ttext: function( value ) {\n\ \t\treturn access( this, function( value ) {\n\ \t\t\treturn value === undefined ?\n\ \t\t\t\tjQuery.text( this ) :\n\ \t\t\t\tthis.empty().append( ( this[0] && this[0].ownerDocument || document ).createTextNode( value ) );\n\ \t\t}, null, value, arguments.length );\n\ \t},\n\ \n\ \tappend: function() {\n\ \t\treturn this.domManip( arguments, function( elem ) {\n\ \t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\ \t\t\t\tvar target = manipulationTarget( this, elem );\n\ \t\t\t\ttarget.appendChild( elem );\n\ \t\t\t}\n\ \t\t});\n\ \t},\n\ \n\ \tprepend: function() {\n\ \t\treturn this.domManip( arguments, function( elem ) {\n\ \t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\ \t\t\t\tvar target = manipulationTarget( this, elem );\n\ \t\t\t\ttarget.insertBefore( elem, target.firstChild );\n\ \t\t\t}\n\ \t\t});\n\ \t},\n\ \n\ \tbefore: function() {\n\ \t\treturn this.domManip( arguments, function( elem ) {\n\ \t\t\tif ( this.parentNode ) {\n\ \t\t\t\tthis.parentNode.insertBefore( elem, this );\n\ \t\t\t}\n\ \t\t});\n\ \t},\n\ \n\ \tafter: function() {\n\ \t\treturn this.domManip( arguments, function( elem ) {\n\ \t\t\tif ( this.parentNode ) {\n\ \t\t\t\tthis.parentNode.insertBefore( elem, this.nextSibling );\n\ \t\t\t}\n\ \t\t});\n\ \t},\n\ \n\ \tremove: function( selector, keepData /* Internal Use Only */ ) {\n\ \t\tvar elem,\n\ \t\t\telems = selector ? jQuery.filter( selector, this ) : this,\n\ \t\t\ti = 0;\n\ \n\ \t\tfor ( ; (elem = elems[i]) != null; i++ ) {\n\ \n\ \t\t\tif ( !keepData && elem.nodeType === 1 ) {\n\ \t\t\t\tjQuery.cleanData( getAll( elem ) );\n\ \t\t\t}\n\ \n\ \t\t\tif ( elem.parentNode ) {\n\ \t\t\t\tif ( keepData && jQuery.contains( elem.ownerDocument, elem ) ) {\n\ \t\t\t\t\tsetGlobalEval( getAll( elem, \"script\" ) );\n\ \t\t\t\t}\n\ \t\t\t\telem.parentNode.removeChild( elem );\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\treturn this;\n\ \t},\n\ \n\ \tempty: function() {\n\ \t\tvar elem,\n\ \t\t\ti = 0;\n\ \n\ \t\tfor ( ; (elem = this[i]) != null; i++ ) {\n\ \t\t\t// Remove element nodes and prevent memory leaks\n\ \t\t\tif ( elem.nodeType === 1 ) {\n\ \t\t\t\tjQuery.cleanData( getAll( elem, false ) );\n\ \t\t\t}\n\ \n\ \t\t\t// Remove any remaining nodes\n\ \t\t\twhile ( elem.firstChild ) {\n\ \t\t\t\telem.removeChild( elem.firstChild );\n\ \t\t\t}\n\ \n\ \t\t\t// If this is a select, ensure that it displays empty (#12336)\n\ \t\t\t// Support: IE<9\n\ \t\t\tif ( elem.options && jQuery.nodeName( elem, \"select\" ) ) {\n\ \t\t\t\telem.options.length = 0;\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\treturn this;\n\ \t},\n\ \n\ \tclone: function( dataAndEvents, deepDataAndEvents ) {\n\ \t\tdataAndEvents = dataAndEvents == null ? false : dataAndEvents;\n\ \t\tdeepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;\n\ \n\ \t\treturn this.map(function() {\n\ \t\t\treturn jQuery.clone( this, dataAndEvents, deepDataAndEvents );\n\ \t\t});\n\ \t},\n\ \n\ \thtml: function( value ) {\n\ \t\treturn access( this, function( value ) {\n\ \t\t\tvar elem = this[ 0 ] || {},\n\ \t\t\t\ti = 0,\n\ \t\t\t\tl = this.length;\n\ \n\ \t\t\tif ( value === undefined ) {\n\ \t\t\t\treturn elem.nodeType === 1 ?\n\ \t\t\t\t\telem.innerHTML.replace( rinlinejQuery, \"\" ) :\n\ \t\t\t\t\tundefined;\n\ \t\t\t}\n\ \n\ \t\t\t// See if we can take a shortcut and just use innerHTML\n\ \t\t\tif ( typeof value === \"string\" && !rnoInnerhtml.test( value ) &&\n\ \t\t\t\t( support.htmlSerialize || !rnoshimcache.test( value ) ) &&\n\ \t\t\t\t( support.leadingWhitespace || !rleadingWhitespace.test( value ) ) &&\n\ \t\t\t\t!wrapMap[ (rtagName.exec( value ) || [ \"\", \"\" ])[ 1 ].toLowerCase() ] ) {\n\ \n\ \t\t\t\tvalue = value.replace( rxhtmlTag, \"<$1>\" );\n\ \n\ \t\t\t\ttry {\n\ \t\t\t\t\tfor (; i < l; i++ ) {\n\ \t\t\t\t\t\t// Remove element nodes and prevent memory leaks\n\ \t\t\t\t\t\telem = this[i] || {};\n\ \t\t\t\t\t\tif ( elem.nodeType === 1 ) {\n\ \t\t\t\t\t\t\tjQuery.cleanData( getAll( elem, false ) );\n\ \t\t\t\t\t\t\telem.innerHTML = value;\n\ \t\t\t\t\t\t}\n\ \t\t\t\t\t}\n\ \n\ \t\t\t\t\telem = 0;\n\ \n\ \t\t\t\t// If using innerHTML throws an exception, use the fallback method\n\ \t\t\t\t} catch(e) {}\n\ \t\t\t}\n\ \n\ \t\t\tif ( elem ) {\n\ \t\t\t\tthis.empty().append( value );\n\ \t\t\t}\n\ \t\t}, null, value, arguments.length );\n\ \t},\n\ \n\ \treplaceWith: function() {\n\ \t\tvar arg = arguments[ 0 ];\n\ \n\ \t\t// Make the changes, replacing each context element with the new content\n\ \t\tthis.domManip( arguments, function( elem ) {\n\ \t\t\targ = this.parentNode;\n\ \n\ \t\t\tjQuery.cleanData( getAll( this ) );\n\ \n\ \t\t\tif ( arg ) {\n\ \t\t\t\targ.replaceChild( elem, this );\n\ \t\t\t}\n\ \t\t});\n\ \n\ \t\t// Force removal if there was no new content (e.g., from empty arguments)\n\ \t\treturn arg && (arg.length || arg.nodeType) ? this : this.remove();\n\ \t},\n\ \n\ \tdetach: function( selector ) {\n\ \t\treturn this.remove( selector, true );\n\ \t},\n\ \n\ \tdomManip: function( args, callback ) {\n\ \n\ \t\t// Flatten any nested arrays\n\ \t\targs = concat.apply( [], args );\n\ \n\ \t\tvar first, node, hasScripts,\n\ \t\t\tscripts, doc, fragment,\n\ \t\t\ti = 0,\n\ \t\t\tl = this.length,\n\ \t\t\tset = this,\n\ \t\t\tiNoClone = l - 1,\n\ \t\t\tvalue = args[0],\n\ \t\t\tisFunction = jQuery.isFunction( value );\n\ \n\ \t\t// We can't cloneNode fragments that contain checked, in WebKit\n\ \t\tif ( isFunction ||\n\ \t\t\t\t( l > 1 && typeof value === \"string\" &&\n\ \t\t\t\t\t!support.checkClone && rchecked.test( value ) ) ) {\n\ \t\t\treturn this.each(function( index ) {\n\ \t\t\t\tvar self = set.eq( index );\n\ \t\t\t\tif ( isFunction ) {\n\ \t\t\t\t\targs[0] = value.call( this, index, self.html() );\n\ \t\t\t\t}\n\ \t\t\t\tself.domManip( args, callback );\n\ \t\t\t});\n\ \t\t}\n\ \n\ \t\tif ( l ) {\n\ \t\t\tfragment = jQuery.buildFragment( args, this[ 0 ].ownerDocument, false, this );\n\ \t\t\tfirst = fragment.firstChild;\n\ \n\ \t\t\tif ( fragment.childNodes.length === 1 ) {\n\ \t\t\t\tfragment = first;\n\ \t\t\t}\n\ \n\ \t\t\tif ( first ) {\n\ \t\t\t\tscripts = jQuery.map( getAll( fragment, \"script\" ), disableScript );\n\ \t\t\t\thasScripts = scripts.length;\n\ \n\ \t\t\t\t// Use the original fragment for the last item instead of the first because it can end up\n\ \t\t\t\t// being emptied incorrectly in certain situations (#8070).\n\ \t\t\t\tfor ( ; i < l; i++ ) {\n\ \t\t\t\t\tnode = fragment;\n\ \n\ \t\t\t\t\tif ( i !== iNoClone ) {\n\ \t\t\t\t\t\tnode = jQuery.clone( node, true, true );\n\ \n\ \t\t\t\t\t\t// Keep references to cloned scripts for later restoration\n\ \t\t\t\t\t\tif ( hasScripts ) {\n\ \t\t\t\t\t\t\tjQuery.merge( scripts, getAll( node, \"script\" ) );\n\ \t\t\t\t\t\t}\n\ \t\t\t\t\t}\n\ \n\ \t\t\t\t\tcallback.call( this[i], node, i );\n\ \t\t\t\t}\n\ \n\ \t\t\t\tif ( hasScripts ) {\n\ \t\t\t\t\tdoc = scripts[ scripts.length - 1 ].ownerDocument;\n\ \n\ \t\t\t\t\t// Reenable scripts\n\ \t\t\t\t\tjQuery.map( scripts, restoreScript );\n\ \n\ \t\t\t\t\t// Evaluate executable scripts on first document insertion\n\ \t\t\t\t\tfor ( i = 0; i < hasScripts; i++ ) {\n\ \t\t\t\t\t\tnode = scripts[ i ];\n\ \t\t\t\t\t\tif ( rscriptType.test( node.type || \"\" ) &&\n\ \t\t\t\t\t\t\t!jQuery._data( node, \"globalEval\" ) && jQuery.contains( doc, node ) ) {\n\ \n\ \t\t\t\t\t\t\tif ( node.src ) {\n\ \t\t\t\t\t\t\t\t// Optional AJAX dependency, but won't run scripts if not present\n\ \t\t\t\t\t\t\t\tif ( jQuery._evalUrl ) {\n\ \t\t\t\t\t\t\t\t\tjQuery._evalUrl( node.src );\n\ \t\t\t\t\t\t\t\t}\n\ \t\t\t\t\t\t\t} else {\n\ \t\t\t\t\t\t\t\tjQuery.globalEval( ( node.text || node.textContent || node.innerHTML || \"\" ).replace( rcleanScript, \"\" ) );\n\ \t\t\t\t\t\t\t}\n\ \t\t\t\t\t\t}\n\ \t\t\t\t\t}\n\ \t\t\t\t}\n\ \n\ \t\t\t\t// Fix #11809: Avoid leaking memory\n\ \t\t\t\tfragment = first = null;\n\ \t\t\t}\n\ \t\t}\n\ \n\ \t\treturn this;\n\ \t}\n\ });\n\ \n\ jQuery.each({\n\ \tappendTo: \"append\",\n\ \tprependTo: \"prepend\",\n\ \tinsertBefore: \"before\",\n\ \tinsertAfter: \"after\",\n\ \treplaceAll: \"replaceWith\"\n\ }, function( name, original ) {\n\ \tjQuery.fn[ name ] = function( selector ) {\n\ \t\tvar elems,\n\ \t\t\ti = 0,\n\ \t\t\tret = [],\n\ \t\t\tinsert = jQuery( selector ),\n\ \t\t\tlast = insert.length - 1;\n\ \n\ \t\tfor ( ; i <= last; i++ ) {\n\ \t\t\telems = i === last ? this : this.clone(true);\n\ \t\t\tjQuery( insert[i] )[ original ]( elems );\n\ \n\ \t\t\t// Modern browsers can apply jQuery collections as arrays, but oldIE needs a .get()\n\ \t\t\tpush.apply( ret, elems.get() );\n\ \t\t}\n\ \n\ \t\treturn this.pushStack( ret );\n\ \t};\n\ });\n\ \n\ \n\ var iframe,\n\ \telemdisplay = {};\n\ \n\ /**\n\ * Retrieve the actual display of a element\n\ * @param {String} name nodeName of the element\n\ * @param {Object} doc Document object\n\ */\n\ // Called only from within defaultDisplay\n\ function actualDisplay( name, doc ) {\n\ \tvar style,\n\ \t\telem = jQuery( doc.createElement( name ) ).appendTo( doc.body ),\n\ \n\ \t\t// getDefaultComputedStyle might be reliably used only on attached element\n\ \t\tdisplay = window.getDefaultComputedStyle && ( style = window.getDefaultComputedStyle( elem[ 0 ] ) ) ?\n\ \n\ \t\t\t// Use of this method is a temporary fix (more like optmization) until something better comes along,\n\ \t\t\t// since it was removed from specification and supported only in FF\n\ \t\t\tstyle.display : jQuery.css( elem[ 0 ], \"display\" );\n\ \n\ \t// We don't have any data stored on the element,\n\ \t// so use \"detach\" method as fast way to get rid of the element\n\ \telem.detach();\n\ \n\ \treturn display;\n\ }\n\ \n\ /**\n\ * Try to determine the default display value of an element\n\ * @param {String} nodeName\n\ */\n\ function defaultDisplay( nodeName ) {\n\ \tvar doc = document,\n\ \t\tdisplay = elemdisplay[ nodeName ];\n\ \n\ \tif ( !display ) {\n\ \t\tdisplay = actualDisplay( nodeName, doc );\n\ \n\ \t\t// If the simple way fails, read from inside an iframe\n\ \t\tif ( display === \"none\" || !display ) {\n\ \n\ \t\t\t// Use the already-created iframe if possible\n\ \t\t\tiframe = (iframe || jQuery( \"