diff --git a/jcr-test/pom.xml b/jcr-test/pom.xml
index 7f2e141..0707f0c 100644
--- a/jcr-test/pom.xml
+++ b/jcr-test/pom.xml
@@ -5,7 +5,7 @@
wisdom-jcr
org.wisdom-framework.jcr
- 0.5.0-SNAPSHOT
+ 0.5.0
../pom.xml
4.0.0
diff --git a/modeshape-sample/node_modules/.bin/cake b/modeshape-sample/node_modules/.bin/cake
new file mode 120000
index 0000000..d95f32a
--- /dev/null
+++ b/modeshape-sample/node_modules/.bin/cake
@@ -0,0 +1 @@
+../coffee-script/bin/cake
\ No newline at end of file
diff --git a/modeshape-sample/node_modules/.bin/coffee b/modeshape-sample/node_modules/.bin/coffee
new file mode 120000
index 0000000..b57f275
--- /dev/null
+++ b/modeshape-sample/node_modules/.bin/coffee
@@ -0,0 +1 @@
+../coffee-script/bin/coffee
\ No newline at end of file
diff --git a/modeshape-sample/node_modules/.package-lock.json b/modeshape-sample/node_modules/.package-lock.json
new file mode 100644
index 0000000..39f7fb7
--- /dev/null
+++ b/modeshape-sample/node_modules/.package-lock.json
@@ -0,0 +1,20 @@
+{
+ "name": "modeshape-sample",
+ "lockfileVersion": 2,
+ "requires": true,
+ "packages": {
+ "node_modules/coffee-script": {
+ "version": "1.12.7",
+ "resolved": "https://registry.npmjs.org/coffee-script/-/coffee-script-1.12.7.tgz",
+ "integrity": "sha512-fLeEhqwymYat/MpTPUjSKHVYYl0ec2mOyALEMLmzr5i1isuG+6jfI2j2d5oBO3VIzgUXgBVIcOT9uH1TFxBckw==",
+ "deprecated": "CoffeeScript on NPM has moved to \"coffeescript\" (no hyphen)",
+ "bin": {
+ "cake": "bin/cake",
+ "coffee": "bin/coffee"
+ },
+ "engines": {
+ "node": ">=0.8.0"
+ }
+ }
+ }
+}
diff --git a/modeshape-sample/node_modules/coffee-script/LICENSE b/modeshape-sample/node_modules/coffee-script/LICENSE
new file mode 100644
index 0000000..2b8b228
--- /dev/null
+++ b/modeshape-sample/node_modules/coffee-script/LICENSE
@@ -0,0 +1,22 @@
+Copyright (c) 2009-2017 Jeremy Ashkenas
+
+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.
diff --git a/modeshape-sample/node_modules/coffee-script/README.md b/modeshape-sample/node_modules/coffee-script/README.md
new file mode 100644
index 0000000..1097e36
--- /dev/null
+++ b/modeshape-sample/node_modules/coffee-script/README.md
@@ -0,0 +1,57 @@
+ {
+ } } {
+ { { } }
+ } }{ {
+ { }{ } } _____ __ __
+ { }{ }{ { } / ____| / _|/ _|
+ .- { { } { }} -. | | ___ | |_| |_ ___ ___
+ ( { } { } { } } ) | | / _ \| _| _/ _ \/ _ \
+ |`-..________ ..-'| | |___| (_) | | | || __/ __/
+ | | \_____\___/|_| |_| \___|\___|
+ | ;--.
+ | (__ \ _____ _ _
+ | | ) ) / ____| (_) | |
+ | |/ / | (___ ___ _ __ _ _ __ | |_
+ | ( / \___ \ / __| '__| | '_ \| __|
+ | |/ ____) | (__| | | | |_) | |_
+ | | |_____/ \___|_| |_| .__/ \__|
+ `-.._________..-' | |
+ |_|
+
+CoffeeScript is a little language that compiles into JavaScript.
+
+## Installation
+
+Once you have Node.js installed:
+
+```shell
+npm install --global coffeescript
+```
+
+Leave off the `--global` if you don’t wish to install globally.
+
+## Getting Started
+
+Execute a script:
+
+```shell
+coffee /path/to/script.coffee
+```
+
+Compile a script:
+
+```shell
+coffee -c /path/to/script.coffee
+```
+
+For documentation, usage, and examples, see: http://coffeescript.org/
+
+To suggest a feature or report a bug: https://github.com/jashkenas/coffeescript/issues
+
+If you’d like to chat, drop by #coffeescript on Freenode IRC.
+
+The source repository: https://github.com/jashkenas/coffeescript.git
+
+Changelog: http://coffeescript.org/#changelog
+
+Our lovely and talented contributors are listed here: https://github.com/jashkenas/coffeescript/contributors
diff --git a/modeshape-sample/node_modules/coffee-script/bin/cake b/modeshape-sample/node_modules/coffee-script/bin/cake
new file mode 100755
index 0000000..1c6f9f5
--- /dev/null
+++ b/modeshape-sample/node_modules/coffee-script/bin/cake
@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+var path = require('path');
+var fs = require('fs');
+
+var potentialPaths = [
+ path.join(process.cwd(), 'node_modules/coffeescript/lib/coffeescript'),
+ path.join(process.cwd(), 'node_modules/coffeescript/lib/coffee-script'),
+ path.join(process.cwd(), 'node_modules/coffee-script/lib/coffee-script'),
+ path.join(__dirname, '../lib/coffee-script')
+];
+
+for (var i = 0, len = potentialPaths.length; i < len; i++) {
+ if (fs.existsSync(potentialPaths[i])) {
+ require(potentialPaths[i] + '/cake').run();
+ break;
+ }
+}
diff --git a/modeshape-sample/node_modules/coffee-script/bin/coffee b/modeshape-sample/node_modules/coffee-script/bin/coffee
new file mode 100755
index 0000000..1bcdd1e
--- /dev/null
+++ b/modeshape-sample/node_modules/coffee-script/bin/coffee
@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+var path = require('path');
+var fs = require('fs');
+
+var potentialPaths = [
+ path.join(process.cwd(), 'node_modules/coffeescript/lib/coffeescript'),
+ path.join(process.cwd(), 'node_modules/coffeescript/lib/coffee-script'),
+ path.join(process.cwd(), 'node_modules/coffee-script/lib/coffee-script'),
+ path.join(__dirname, '../lib/coffee-script')
+];
+
+for (var i = 0, len = potentialPaths.length; i < len; i++) {
+ if (fs.existsSync(potentialPaths[i])) {
+ require(potentialPaths[i] + '/command').run();
+ break;
+ }
+}
diff --git a/modeshape-sample/node_modules/coffee-script/lib/coffee-script/browser.js b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/browser.js
new file mode 100644
index 0000000..e6e5d6e
--- /dev/null
+++ b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/browser.js
@@ -0,0 +1,132 @@
+// Generated by CoffeeScript 1.12.7
+(function() {
+ var CoffeeScript, compile, runScripts,
+ indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
+
+ CoffeeScript = require('./coffee-script');
+
+ CoffeeScript.require = require;
+
+ compile = CoffeeScript.compile;
+
+ CoffeeScript["eval"] = function(code, options) {
+ if (options == null) {
+ options = {};
+ }
+ if (options.bare == null) {
+ options.bare = true;
+ }
+ return eval(compile(code, options));
+ };
+
+ CoffeeScript.run = function(code, options) {
+ if (options == null) {
+ options = {};
+ }
+ options.bare = true;
+ options.shiftLine = true;
+ return Function(compile(code, options))();
+ };
+
+ if (typeof window === "undefined" || window === null) {
+ return;
+ }
+
+ if ((typeof btoa !== "undefined" && btoa !== null) && (typeof JSON !== "undefined" && JSON !== null)) {
+ compile = function(code, options) {
+ if (options == null) {
+ options = {};
+ }
+ options.inlineMap = true;
+ return CoffeeScript.compile(code, options);
+ };
+ }
+
+ CoffeeScript.load = function(url, callback, options, hold) {
+ var xhr;
+ if (options == null) {
+ options = {};
+ }
+ if (hold == null) {
+ hold = false;
+ }
+ options.sourceFiles = [url];
+ xhr = window.ActiveXObject ? new window.ActiveXObject('Microsoft.XMLHTTP') : new window.XMLHttpRequest();
+ xhr.open('GET', url, true);
+ if ('overrideMimeType' in xhr) {
+ xhr.overrideMimeType('text/plain');
+ }
+ xhr.onreadystatechange = function() {
+ var param, ref;
+ if (xhr.readyState === 4) {
+ if ((ref = xhr.status) === 0 || ref === 200) {
+ param = [xhr.responseText, options];
+ if (!hold) {
+ CoffeeScript.run.apply(CoffeeScript, param);
+ }
+ } else {
+ throw new Error("Could not load " + url);
+ }
+ if (callback) {
+ return callback(param);
+ }
+ }
+ };
+ return xhr.send(null);
+ };
+
+ runScripts = function() {
+ var coffees, coffeetypes, execute, fn, i, index, j, len, s, script, scripts;
+ scripts = window.document.getElementsByTagName('script');
+ coffeetypes = ['text/coffeescript', 'text/literate-coffeescript'];
+ coffees = (function() {
+ var j, len, ref, results;
+ results = [];
+ for (j = 0, len = scripts.length; j < len; j++) {
+ s = scripts[j];
+ if (ref = s.type, indexOf.call(coffeetypes, ref) >= 0) {
+ results.push(s);
+ }
+ }
+ return results;
+ })();
+ index = 0;
+ execute = function() {
+ var param;
+ param = coffees[index];
+ if (param instanceof Array) {
+ CoffeeScript.run.apply(CoffeeScript, param);
+ index++;
+ return execute();
+ }
+ };
+ fn = function(script, i) {
+ var options, source;
+ options = {
+ literate: script.type === coffeetypes[1]
+ };
+ source = script.src || script.getAttribute('data-src');
+ if (source) {
+ return CoffeeScript.load(source, function(param) {
+ coffees[i] = param;
+ return execute();
+ }, options, true);
+ } else {
+ options.sourceFiles = ['embedded'];
+ return coffees[i] = [script.innerHTML, options];
+ }
+ };
+ for (i = j = 0, len = coffees.length; j < len; i = ++j) {
+ script = coffees[i];
+ fn(script, i);
+ }
+ return execute();
+ };
+
+ if (window.addEventListener) {
+ window.addEventListener('DOMContentLoaded', runScripts, false);
+ } else {
+ window.attachEvent('onload', runScripts);
+ }
+
+}).call(this);
diff --git a/modeshape-sample/node_modules/coffee-script/lib/coffee-script/cake.js b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/cake.js
new file mode 100644
index 0000000..d7155fc
--- /dev/null
+++ b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/cake.js
@@ -0,0 +1,114 @@
+// Generated by CoffeeScript 1.12.7
+(function() {
+ var CoffeeScript, cakefileDirectory, fatalError, fs, helpers, missingTask, oparse, options, optparse, path, printTasks, switches, tasks;
+
+ fs = require('fs');
+
+ path = require('path');
+
+ helpers = require('./helpers');
+
+ optparse = require('./optparse');
+
+ CoffeeScript = require('./coffee-script');
+
+ CoffeeScript.register();
+
+ tasks = {};
+
+ options = {};
+
+ switches = [];
+
+ oparse = null;
+
+ helpers.extend(global, {
+ task: function(name, description, action) {
+ var ref;
+ if (!action) {
+ ref = [description, action], action = ref[0], description = ref[1];
+ }
+ return tasks[name] = {
+ name: name,
+ description: description,
+ action: action
+ };
+ },
+ option: function(letter, flag, description) {
+ return switches.push([letter, flag, description]);
+ },
+ invoke: function(name) {
+ if (!tasks[name]) {
+ missingTask(name);
+ }
+ return tasks[name].action(options);
+ }
+ });
+
+ exports.run = function() {
+ var arg, args, e, i, len, ref, results;
+ global.__originalDirname = fs.realpathSync('.');
+ process.chdir(cakefileDirectory(__originalDirname));
+ args = process.argv.slice(2);
+ CoffeeScript.run(fs.readFileSync('Cakefile').toString(), {
+ filename: 'Cakefile'
+ });
+ oparse = new optparse.OptionParser(switches);
+ if (!args.length) {
+ return printTasks();
+ }
+ try {
+ options = oparse.parse(args);
+ } catch (error) {
+ e = error;
+ return fatalError("" + e);
+ }
+ ref = options["arguments"];
+ results = [];
+ for (i = 0, len = ref.length; i < len; i++) {
+ arg = ref[i];
+ results.push(invoke(arg));
+ }
+ return results;
+ };
+
+ printTasks = function() {
+ var cakefilePath, desc, name, relative, spaces, task;
+ relative = path.relative || path.resolve;
+ cakefilePath = path.join(relative(__originalDirname, process.cwd()), 'Cakefile');
+ console.log(cakefilePath + " defines the following tasks:\n");
+ for (name in tasks) {
+ task = tasks[name];
+ spaces = 20 - name.length;
+ spaces = spaces > 0 ? Array(spaces + 1).join(' ') : '';
+ desc = task.description ? "# " + task.description : '';
+ console.log("cake " + name + spaces + " " + desc);
+ }
+ if (switches.length) {
+ return console.log(oparse.help());
+ }
+ };
+
+ fatalError = function(message) {
+ console.error(message + '\n');
+ console.log('To see a list of all tasks/options, run "cake"');
+ return process.exit(1);
+ };
+
+ missingTask = function(task) {
+ return fatalError("No such task: " + task);
+ };
+
+ cakefileDirectory = function(dir) {
+ var parent;
+ if (fs.existsSync(path.join(dir, 'Cakefile'))) {
+ return dir;
+ }
+ parent = path.normalize(path.join(dir, '..'));
+ if (parent !== dir) {
+ return cakefileDirectory(parent);
+ }
+ throw new Error("Cakefile not found in " + (process.cwd()));
+ };
+
+}).call(this);
diff --git a/modeshape-sample/node_modules/coffee-script/lib/coffee-script/coffee-script.js b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/coffee-script.js
new file mode 100644
index 0000000..7e77237
--- /dev/null
+++ b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/coffee-script.js
@@ -0,0 +1,426 @@
+// Generated by CoffeeScript 1.12.7
+(function() {
+ var Lexer, SourceMap, base64encode, compile, ext, fn1, formatSourcePosition, fs, getSourceMap, helpers, i, len, lexer, packageJson, parser, path, ref, sourceMaps, sources, vm, withPrettyErrors,
+ hasProp = {}.hasOwnProperty;
+
+ fs = require('fs');
+
+ vm = require('vm');
+
+ path = require('path');
+
+ Lexer = require('./lexer').Lexer;
+
+ parser = require('./parser').parser;
+
+ helpers = require('./helpers');
+
+ SourceMap = require('./sourcemap');
+
+ packageJson = require('../../package.json');
+
+ exports.VERSION = packageJson.version;
+
+ exports.FILE_EXTENSIONS = ['.coffee', '.litcoffee', '.coffee.md'];
+
+ exports.helpers = helpers;
+
+ base64encode = function(src) {
+ switch (false) {
+ case typeof Buffer !== 'function':
+ return new Buffer(src).toString('base64');
+ case typeof btoa !== 'function':
+ return btoa(encodeURIComponent(src).replace(/%([0-9A-F]{2})/g, function(match, p1) {
+ return String.fromCharCode('0x' + p1);
+ }));
+ default:
+ throw new Error('Unable to base64 encode inline sourcemap.');
+ }
+ };
+
+ withPrettyErrors = function(fn) {
+ return function(code, options) {
+ var err;
+ if (options == null) {
+ options = {};
+ }
+ try {
+ return fn.call(this, code, options);
+ } catch (error) {
+ err = error;
+ if (typeof code !== 'string') {
+ throw err;
+ }
+ throw helpers.updateSyntaxError(err, code, options.filename);
+ }
+ };
+ };
+
+ sources = {};
+
+ sourceMaps = {};
+
+ exports.compile = compile = withPrettyErrors(function(code, options) {
+ var currentColumn, currentLine, encoded, extend, filename, fragment, fragments, generateSourceMap, header, i, j, js, len, len1, map, merge, newLines, ref, ref1, sourceMapDataURI, sourceURL, token, tokens, v3SourceMap;
+ merge = helpers.merge, extend = helpers.extend;
+ options = extend({}, options);
+ generateSourceMap = options.sourceMap || options.inlineMap || (options.filename == null);
+ filename = options.filename || '';
+ sources[filename] = code;
+ if (generateSourceMap) {
+ map = new SourceMap;
+ }
+ tokens = lexer.tokenize(code, options);
+ options.referencedVars = (function() {
+ var i, len, results;
+ results = [];
+ for (i = 0, len = tokens.length; i < len; i++) {
+ token = tokens[i];
+ if (token[0] === 'IDENTIFIER') {
+ results.push(token[1]);
+ }
+ }
+ return results;
+ })();
+ if (!((options.bare != null) && options.bare === true)) {
+ for (i = 0, len = tokens.length; i < len; i++) {
+ token = tokens[i];
+ if ((ref = token[0]) === 'IMPORT' || ref === 'EXPORT') {
+ options.bare = true;
+ break;
+ }
+ }
+ }
+ fragments = parser.parse(tokens).compileToFragments(options);
+ currentLine = 0;
+ if (options.header) {
+ currentLine += 1;
+ }
+ if (options.shiftLine) {
+ currentLine += 1;
+ }
+ currentColumn = 0;
+ js = "";
+ for (j = 0, len1 = fragments.length; j < len1; j++) {
+ fragment = fragments[j];
+ if (generateSourceMap) {
+ if (fragment.locationData && !/^[;\s]*$/.test(fragment.code)) {
+ map.add([fragment.locationData.first_line, fragment.locationData.first_column], [currentLine, currentColumn], {
+ noReplace: true
+ });
+ }
+ newLines = helpers.count(fragment.code, "\n");
+ currentLine += newLines;
+ if (newLines) {
+ currentColumn = fragment.code.length - (fragment.code.lastIndexOf("\n") + 1);
+ } else {
+ currentColumn += fragment.code.length;
+ }
+ }
+ js += fragment.code;
+ }
+ if (options.header) {
+ header = "Generated by CoffeeScript " + this.VERSION;
+ js = "// " + header + "\n" + js;
+ }
+ if (generateSourceMap) {
+ v3SourceMap = map.generate(options, code);
+ sourceMaps[filename] = map;
+ }
+ if (options.inlineMap) {
+ encoded = base64encode(JSON.stringify(v3SourceMap));
+ sourceMapDataURI = "//# sourceMappingURL=data:application/json;base64," + encoded;
+ sourceURL = "//# sourceURL=" + ((ref1 = options.filename) != null ? ref1 : 'coffeescript');
+ js = js + "\n" + sourceMapDataURI + "\n" + sourceURL;
+ }
+ if (options.sourceMap) {
+ return {
+ js: js,
+ sourceMap: map,
+ v3SourceMap: JSON.stringify(v3SourceMap, null, 2)
+ };
+ } else {
+ return js;
+ }
+ });
+
+ exports.tokens = withPrettyErrors(function(code, options) {
+ return lexer.tokenize(code, options);
+ });
+
+ exports.nodes = withPrettyErrors(function(source, options) {
+ if (typeof source === 'string') {
+ return parser.parse(lexer.tokenize(source, options));
+ } else {
+ return parser.parse(source);
+ }
+ });
+
+ exports.run = function(code, options) {
+ var answer, dir, mainModule, ref;
+ if (options == null) {
+ options = {};
+ }
+ mainModule = require.main;
+ mainModule.filename = process.argv[1] = options.filename ? fs.realpathSync(options.filename) : '';
+ mainModule.moduleCache && (mainModule.moduleCache = {});
+ dir = options.filename != null ? path.dirname(fs.realpathSync(options.filename)) : fs.realpathSync('.');
+ mainModule.paths = require('module')._nodeModulePaths(dir);
+ if (!helpers.isCoffee(mainModule.filename) || require.extensions) {
+ answer = compile(code, options);
+ code = (ref = answer.js) != null ? ref : answer;
+ }
+ return mainModule._compile(code, mainModule.filename);
+ };
+
+ exports["eval"] = function(code, options) {
+ var Module, _module, _require, createContext, i, isContext, js, k, len, o, r, ref, ref1, ref2, ref3, sandbox, v;
+ if (options == null) {
+ options = {};
+ }
+ if (!(code = code.trim())) {
+ return;
+ }
+ createContext = (ref = vm.Script.createContext) != null ? ref : vm.createContext;
+ isContext = (ref1 = vm.isContext) != null ? ref1 : function(ctx) {
+ return options.sandbox instanceof createContext().constructor;
+ };
+ if (createContext) {
+ if (options.sandbox != null) {
+ if (isContext(options.sandbox)) {
+ sandbox = options.sandbox;
+ } else {
+ sandbox = createContext();
+ ref2 = options.sandbox;
+ for (k in ref2) {
+ if (!hasProp.call(ref2, k)) continue;
+ v = ref2[k];
+ sandbox[k] = v;
+ }
+ }
+ sandbox.global = sandbox.root = sandbox.GLOBAL = sandbox;
+ } else {
+ sandbox = global;
+ }
+ sandbox.__filename = options.filename || 'eval';
+ sandbox.__dirname = path.dirname(sandbox.__filename);
+ if (!(sandbox !== global || sandbox.module || sandbox.require)) {
+ Module = require('module');
+ sandbox.module = _module = new Module(options.modulename || 'eval');
+ sandbox.require = _require = function(path) {
+ return Module._load(path, _module, true);
+ };
+ _module.filename = sandbox.__filename;
+ ref3 = Object.getOwnPropertyNames(require);
+ for (i = 0, len = ref3.length; i < len; i++) {
+ r = ref3[i];
+ if (r !== 'paths' && r !== 'arguments' && r !== 'caller') {
+ _require[r] = require[r];
+ }
+ }
+ _require.paths = _module.paths = Module._nodeModulePaths(process.cwd());
+ _require.resolve = function(request) {
+ return Module._resolveFilename(request, _module);
+ };
+ }
+ }
+ o = {};
+ for (k in options) {
+ if (!hasProp.call(options, k)) continue;
+ v = options[k];
+ o[k] = v;
+ }
+ o.bare = true;
+ js = compile(code, o);
+ if (sandbox === global) {
+ return vm.runInThisContext(js);
+ } else {
+ return vm.runInContext(js, sandbox);
+ }
+ };
+
+ exports.register = function() {
+ return require('./register');
+ };
+
+ if (require.extensions) {
+ ref = this.FILE_EXTENSIONS;
+ fn1 = function(ext) {
+ var base;
+ return (base = require.extensions)[ext] != null ? base[ext] : base[ext] = function() {
+ throw new Error("Use CoffeeScript.register() or require the coffee-script/register module to require " + ext + " files.");
+ };
+ };
+ for (i = 0, len = ref.length; i < len; i++) {
+ ext = ref[i];
+ fn1(ext);
+ }
+ }
+
+ exports._compileFile = function(filename, sourceMap, inlineMap) {
+ var answer, err, raw, stripped;
+ if (sourceMap == null) {
+ sourceMap = false;
+ }
+ if (inlineMap == null) {
+ inlineMap = false;
+ }
+ raw = fs.readFileSync(filename, 'utf8');
+ stripped = raw.charCodeAt(0) === 0xFEFF ? raw.substring(1) : raw;
+ try {
+ answer = compile(stripped, {
+ filename: filename,
+ sourceMap: sourceMap,
+ inlineMap: inlineMap,
+ sourceFiles: [filename],
+ literate: helpers.isLiterate(filename)
+ });
+ } catch (error) {
+ err = error;
+ throw helpers.updateSyntaxError(err, stripped, filename);
+ }
+ return answer;
+ };
+
+ lexer = new Lexer;
+
+ parser.lexer = {
+ lex: function() {
+ var tag, token;
+ token = parser.tokens[this.pos++];
+ if (token) {
+ tag = token[0], this.yytext = token[1], this.yylloc = token[2];
+ parser.errorToken = token.origin || token;
+ this.yylineno = this.yylloc.first_line;
+ } else {
+ tag = '';
+ }
+ return tag;
+ },
+ setInput: function(tokens) {
+ parser.tokens = tokens;
+ return this.pos = 0;
+ },
+ upcomingInput: function() {
+ return "";
+ }
+ };
+
+ parser.yy = require('./nodes');
+
+ parser.yy.parseError = function(message, arg) {
+ var errorLoc, errorTag, errorText, errorToken, token, tokens;
+ token = arg.token;
+ errorToken = parser.errorToken, tokens = parser.tokens;
+ errorTag = errorToken[0], errorText = errorToken[1], errorLoc = errorToken[2];
+ errorText = (function() {
+ switch (false) {
+ case errorToken !== tokens[tokens.length - 1]:
+ return 'end of input';
+ case errorTag !== 'INDENT' && errorTag !== 'OUTDENT':
+ return 'indentation';
+ case errorTag !== 'IDENTIFIER' && errorTag !== 'NUMBER' && errorTag !== 'INFINITY' && errorTag !== 'STRING' && errorTag !== 'STRING_START' && errorTag !== 'REGEX' && errorTag !== 'REGEX_START':
+ return errorTag.replace(/_START$/, '').toLowerCase();
+ default:
+ return helpers.nameWhitespaceCharacter(errorText);
+ }
+ })();
+ return helpers.throwSyntaxError("unexpected " + errorText, errorLoc);
+ };
+
+ formatSourcePosition = function(frame, getSourceMapping) {
+ var as, column, fileLocation, filename, functionName, isConstructor, isMethodCall, line, methodName, source, tp, typeName;
+ filename = void 0;
+ fileLocation = '';
+ if (frame.isNative()) {
+ fileLocation = "native";
+ } else {
+ if (frame.isEval()) {
+ filename = frame.getScriptNameOrSourceURL();
+ if (!filename) {
+ fileLocation = (frame.getEvalOrigin()) + ", ";
+ }
+ } else {
+ filename = frame.getFileName();
+ }
+ filename || (filename = "");
+ line = frame.getLineNumber();
+ column = frame.getColumnNumber();
+ source = getSourceMapping(filename, line, column);
+ fileLocation = source ? filename + ":" + source[0] + ":" + source[1] : filename + ":" + line + ":" + column;
+ }
+ functionName = frame.getFunctionName();
+ isConstructor = frame.isConstructor();
+ isMethodCall = !(frame.isToplevel() || isConstructor);
+ if (isMethodCall) {
+ methodName = frame.getMethodName();
+ typeName = frame.getTypeName();
+ if (functionName) {
+ tp = as = '';
+ if (typeName && functionName.indexOf(typeName)) {
+ tp = typeName + ".";
+ }
+ if (methodName && functionName.indexOf("." + methodName) !== functionName.length - methodName.length - 1) {
+ as = " [as " + methodName + "]";
+ }
+ return "" + tp + functionName + as + " (" + fileLocation + ")";
+ } else {
+ return typeName + "." + (methodName || '') + " (" + fileLocation + ")";
+ }
+ } else if (isConstructor) {
+ return "new " + (functionName || '') + " (" + fileLocation + ")";
+ } else if (functionName) {
+ return functionName + " (" + fileLocation + ")";
+ } else {
+ return fileLocation;
+ }
+ };
+
+ getSourceMap = function(filename) {
+ var answer;
+ if (sourceMaps[filename] != null) {
+ return sourceMaps[filename];
+ } else if (sourceMaps[''] != null) {
+ return sourceMaps[''];
+ } else if (sources[filename] != null) {
+ answer = compile(sources[filename], {
+ filename: filename,
+ sourceMap: true,
+ literate: helpers.isLiterate(filename)
+ });
+ return answer.sourceMap;
+ } else {
+ return null;
+ }
+ };
+
+ Error.prepareStackTrace = function(err, stack) {
+ var frame, frames, getSourceMapping;
+ getSourceMapping = function(filename, line, column) {
+ var answer, sourceMap;
+ sourceMap = getSourceMap(filename);
+ if (sourceMap != null) {
+ answer = sourceMap.sourceLocation([line - 1, column - 1]);
+ }
+ if (answer != null) {
+ return [answer[0] + 1, answer[1] + 1];
+ } else {
+ return null;
+ }
+ };
+ frames = (function() {
+ var j, len1, results;
+ results = [];
+ for (j = 0, len1 = stack.length; j < len1; j++) {
+ frame = stack[j];
+ if (frame.getFunction() === exports.run) {
+ break;
+ }
+ results.push(" at " + (formatSourcePosition(frame, getSourceMapping)));
+ }
+ return results;
+ })();
+ return (err.toString()) + "\n" + (frames.join('\n')) + "\n";
+ };
+
+}).call(this);
diff --git a/modeshape-sample/node_modules/coffee-script/lib/coffee-script/command.js b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/command.js
new file mode 100644
index 0000000..59f11ac
--- /dev/null
+++ b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/command.js
@@ -0,0 +1,610 @@
+// Generated by CoffeeScript 1.12.7
+(function() {
+ var BANNER, CoffeeScript, EventEmitter, SWITCHES, compileJoin, compileOptions, compilePath, compileScript, compileStdio, exec, findDirectoryIndex, forkNode, fs, helpers, hidden, joinTimeout, makePrelude, mkdirp, notSources, optionParser, optparse, opts, outputPath, parseOptions, path, printLine, printTokens, printWarn, ref, removeSource, removeSourceDir, silentUnlink, sourceCode, sources, spawn, timeLog, usage, useWinPathSep, version, wait, watch, watchDir, watchedDirs, writeJs,
+ indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
+
+ fs = require('fs');
+
+ path = require('path');
+
+ helpers = require('./helpers');
+
+ optparse = require('./optparse');
+
+ CoffeeScript = require('./coffee-script');
+
+ ref = require('child_process'), spawn = ref.spawn, exec = ref.exec;
+
+ EventEmitter = require('events').EventEmitter;
+
+ useWinPathSep = path.sep === '\\';
+
+ helpers.extend(CoffeeScript, new EventEmitter);
+
+ printLine = function(line) {
+ return process.stdout.write(line + '\n');
+ };
+
+ printWarn = function(line) {
+ return process.stderr.write(line + '\n');
+ };
+
+ hidden = function(file) {
+ return /^\.|~$/.test(file);
+ };
+
+ BANNER = 'Usage: coffee [options] path/to/script.coffee -- [args]\n\nIf called without options, `coffee` will run your script.';
+
+ SWITCHES = [['-b', '--bare', 'compile without a top-level function wrapper'], ['-c', '--compile', 'compile to JavaScript and save as .js files'], ['-e', '--eval', 'pass a string from the command line as input'], ['-h', '--help', 'display this help message'], ['-i', '--interactive', 'run an interactive CoffeeScript REPL'], ['-j', '--join [FILE]', 'concatenate the source CoffeeScript before compiling'], ['-m', '--map', 'generate source map and save as .js.map files'], ['-M', '--inline-map', 'generate source map and include it directly in output'], ['-n', '--nodes', 'print out the parse tree that the parser produces'], ['--nodejs [ARGS]', 'pass options directly to the "node" binary'], ['--no-header', 'suppress the "Generated by" header'], ['-o', '--output [DIR]', 'set the output directory for compiled JavaScript'], ['-p', '--print', 'print out the compiled JavaScript'], ['-r', '--require [MODULE*]', 'require the given module before eval or REPL'], ['-s', '--stdio', 'listen for and compile scripts over stdio'], ['-l', '--literate', 'treat stdio as literate style coffee-script'], ['-t', '--tokens', 'print out the tokens that the lexer/rewriter produce'], ['-v', '--version', 'display the version number'], ['-w', '--watch', 'watch scripts for changes and rerun commands']];
+
+ opts = {};
+
+ sources = [];
+
+ sourceCode = [];
+
+ notSources = {};
+
+ watchedDirs = {};
+
+ optionParser = null;
+
+ exports.run = function() {
+ var i, len, literals, ref1, replCliOpts, results, source;
+ parseOptions();
+ replCliOpts = {
+ useGlobal: true
+ };
+ if (opts.require) {
+ opts.prelude = makePrelude(opts.require);
+ }
+ replCliOpts.prelude = opts.prelude;
+ if (opts.nodejs) {
+ return forkNode();
+ }
+ if (opts.help) {
+ return usage();
+ }
+ if (opts.version) {
+ return version();
+ }
+ if (opts.interactive) {
+ return require('./repl').start(replCliOpts);
+ }
+ if (opts.stdio) {
+ return compileStdio();
+ }
+ if (opts["eval"]) {
+ return compileScript(null, opts["arguments"][0]);
+ }
+ if (!opts["arguments"].length) {
+ return require('./repl').start(replCliOpts);
+ }
+ literals = opts.run ? opts["arguments"].splice(1) : [];
+ process.argv = process.argv.slice(0, 2).concat(literals);
+ process.argv[0] = 'coffee';
+ if (opts.output) {
+ opts.output = path.resolve(opts.output);
+ }
+ if (opts.join) {
+ opts.join = path.resolve(opts.join);
+ console.error('\nThe --join option is deprecated and will be removed in a future version.\n\nIf for some reason it\'s necessary to share local variables between files,\nreplace...\n\n $ coffee --compile --join bundle.js -- a.coffee b.coffee c.coffee\n\nwith...\n\n $ cat a.coffee b.coffee c.coffee | coffee --compile --stdio > bundle.js\n');
+ }
+ ref1 = opts["arguments"];
+ results = [];
+ for (i = 0, len = ref1.length; i < len; i++) {
+ source = ref1[i];
+ source = path.resolve(source);
+ results.push(compilePath(source, true, source));
+ }
+ return results;
+ };
+
+ makePrelude = function(requires) {
+ return requires.map(function(module) {
+ var _, match, name;
+ if (match = module.match(/^(.*)=(.*)$/)) {
+ _ = match[0], name = match[1], module = match[2];
+ }
+ name || (name = helpers.baseFileName(module, true, useWinPathSep));
+ return name + " = require('" + module + "')";
+ }).join(';');
+ };
+
+ compilePath = function(source, topLevel, base) {
+ var code, err, file, files, i, len, results, stats;
+ if (indexOf.call(sources, source) >= 0 || watchedDirs[source] || !topLevel && (notSources[source] || hidden(source))) {
+ return;
+ }
+ try {
+ stats = fs.statSync(source);
+ } catch (error) {
+ err = error;
+ if (err.code === 'ENOENT') {
+ console.error("File not found: " + source);
+ process.exit(1);
+ }
+ throw err;
+ }
+ if (stats.isDirectory()) {
+ if (path.basename(source) === 'node_modules') {
+ notSources[source] = true;
+ return;
+ }
+ if (opts.run) {
+ compilePath(findDirectoryIndex(source), topLevel, base);
+ return;
+ }
+ if (opts.watch) {
+ watchDir(source, base);
+ }
+ try {
+ files = fs.readdirSync(source);
+ } catch (error) {
+ err = error;
+ if (err.code === 'ENOENT') {
+ return;
+ } else {
+ throw err;
+ }
+ }
+ results = [];
+ for (i = 0, len = files.length; i < len; i++) {
+ file = files[i];
+ results.push(compilePath(path.join(source, file), false, base));
+ }
+ return results;
+ } else if (topLevel || helpers.isCoffee(source)) {
+ sources.push(source);
+ sourceCode.push(null);
+ delete notSources[source];
+ if (opts.watch) {
+ watch(source, base);
+ }
+ try {
+ code = fs.readFileSync(source);
+ } catch (error) {
+ err = error;
+ if (err.code === 'ENOENT') {
+ return;
+ } else {
+ throw err;
+ }
+ }
+ return compileScript(source, code.toString(), base);
+ } else {
+ return notSources[source] = true;
+ }
+ };
+
+ findDirectoryIndex = function(source) {
+ var err, ext, i, index, len, ref1;
+ ref1 = CoffeeScript.FILE_EXTENSIONS;
+ for (i = 0, len = ref1.length; i < len; i++) {
+ ext = ref1[i];
+ index = path.join(source, "index" + ext);
+ try {
+ if ((fs.statSync(index)).isFile()) {
+ return index;
+ }
+ } catch (error) {
+ err = error;
+ if (err.code !== 'ENOENT') {
+ throw err;
+ }
+ }
+ }
+ console.error("Missing index.coffee or index.litcoffee in " + source);
+ return process.exit(1);
+ };
+
+ compileScript = function(file, input, base) {
+ var compiled, err, message, o, options, t, task;
+ if (base == null) {
+ base = null;
+ }
+ o = opts;
+ options = compileOptions(file, base);
+ try {
+ t = task = {
+ file: file,
+ input: input,
+ options: options
+ };
+ CoffeeScript.emit('compile', task);
+ if (o.tokens) {
+ return printTokens(CoffeeScript.tokens(t.input, t.options));
+ } else if (o.nodes) {
+ return printLine(CoffeeScript.nodes(t.input, t.options).toString().trim());
+ } else if (o.run) {
+ CoffeeScript.register();
+ if (opts.prelude) {
+ CoffeeScript["eval"](opts.prelude, t.options);
+ }
+ return CoffeeScript.run(t.input, t.options);
+ } else if (o.join && t.file !== o.join) {
+ if (helpers.isLiterate(file)) {
+ t.input = helpers.invertLiterate(t.input);
+ }
+ sourceCode[sources.indexOf(t.file)] = t.input;
+ return compileJoin();
+ } else {
+ compiled = CoffeeScript.compile(t.input, t.options);
+ t.output = compiled;
+ if (o.map) {
+ t.output = compiled.js;
+ t.sourceMap = compiled.v3SourceMap;
+ }
+ CoffeeScript.emit('success', task);
+ if (o.print) {
+ return printLine(t.output.trim());
+ } else if (o.compile || o.map) {
+ return writeJs(base, t.file, t.output, options.jsPath, t.sourceMap);
+ }
+ }
+ } catch (error) {
+ err = error;
+ CoffeeScript.emit('failure', err, task);
+ if (CoffeeScript.listeners('failure').length) {
+ return;
+ }
+ message = (err != null ? err.stack : void 0) || ("" + err);
+ if (o.watch) {
+ return printLine(message + '\x07');
+ } else {
+ printWarn(message);
+ return process.exit(1);
+ }
+ }
+ };
+
+ compileStdio = function() {
+ var buffers, stdin;
+ buffers = [];
+ stdin = process.openStdin();
+ stdin.on('data', function(buffer) {
+ if (buffer) {
+ return buffers.push(buffer);
+ }
+ });
+ return stdin.on('end', function() {
+ return compileScript(null, Buffer.concat(buffers).toString());
+ });
+ };
+
+ joinTimeout = null;
+
+ compileJoin = function() {
+ if (!opts.join) {
+ return;
+ }
+ if (!sourceCode.some(function(code) {
+ return code === null;
+ })) {
+ clearTimeout(joinTimeout);
+ return joinTimeout = wait(100, function() {
+ return compileScript(opts.join, sourceCode.join('\n'), opts.join);
+ });
+ }
+ };
+
+ watch = function(source, base) {
+ var compile, compileTimeout, err, prevStats, rewatch, startWatcher, watchErr, watcher;
+ watcher = null;
+ prevStats = null;
+ compileTimeout = null;
+ watchErr = function(err) {
+ if (err.code !== 'ENOENT') {
+ throw err;
+ }
+ if (indexOf.call(sources, source) < 0) {
+ return;
+ }
+ try {
+ rewatch();
+ return compile();
+ } catch (error) {
+ removeSource(source, base);
+ return compileJoin();
+ }
+ };
+ compile = function() {
+ clearTimeout(compileTimeout);
+ return compileTimeout = wait(25, function() {
+ return fs.stat(source, function(err, stats) {
+ if (err) {
+ return watchErr(err);
+ }
+ if (prevStats && stats.size === prevStats.size && stats.mtime.getTime() === prevStats.mtime.getTime()) {
+ return rewatch();
+ }
+ prevStats = stats;
+ return fs.readFile(source, function(err, code) {
+ if (err) {
+ return watchErr(err);
+ }
+ compileScript(source, code.toString(), base);
+ return rewatch();
+ });
+ });
+ });
+ };
+ startWatcher = function() {
+ return watcher = fs.watch(source).on('change', compile).on('error', function(err) {
+ if (err.code !== 'EPERM') {
+ throw err;
+ }
+ return removeSource(source, base);
+ });
+ };
+ rewatch = function() {
+ if (watcher != null) {
+ watcher.close();
+ }
+ return startWatcher();
+ };
+ try {
+ return startWatcher();
+ } catch (error) {
+ err = error;
+ return watchErr(err);
+ }
+ };
+
+ watchDir = function(source, base) {
+ var err, readdirTimeout, startWatcher, stopWatcher, watcher;
+ watcher = null;
+ readdirTimeout = null;
+ startWatcher = function() {
+ return watcher = fs.watch(source).on('error', function(err) {
+ if (err.code !== 'EPERM') {
+ throw err;
+ }
+ return stopWatcher();
+ }).on('change', function() {
+ clearTimeout(readdirTimeout);
+ return readdirTimeout = wait(25, function() {
+ var err, file, files, i, len, results;
+ try {
+ files = fs.readdirSync(source);
+ } catch (error) {
+ err = error;
+ if (err.code !== 'ENOENT') {
+ throw err;
+ }
+ return stopWatcher();
+ }
+ results = [];
+ for (i = 0, len = files.length; i < len; i++) {
+ file = files[i];
+ results.push(compilePath(path.join(source, file), false, base));
+ }
+ return results;
+ });
+ });
+ };
+ stopWatcher = function() {
+ watcher.close();
+ return removeSourceDir(source, base);
+ };
+ watchedDirs[source] = true;
+ try {
+ return startWatcher();
+ } catch (error) {
+ err = error;
+ if (err.code !== 'ENOENT') {
+ throw err;
+ }
+ }
+ };
+
+ removeSourceDir = function(source, base) {
+ var file, i, len, sourcesChanged;
+ delete watchedDirs[source];
+ sourcesChanged = false;
+ for (i = 0, len = sources.length; i < len; i++) {
+ file = sources[i];
+ if (!(source === path.dirname(file))) {
+ continue;
+ }
+ removeSource(file, base);
+ sourcesChanged = true;
+ }
+ if (sourcesChanged) {
+ return compileJoin();
+ }
+ };
+
+ removeSource = function(source, base) {
+ var index;
+ index = sources.indexOf(source);
+ sources.splice(index, 1);
+ sourceCode.splice(index, 1);
+ if (!opts.join) {
+ silentUnlink(outputPath(source, base));
+ silentUnlink(outputPath(source, base, '.js.map'));
+ return timeLog("removed " + source);
+ }
+ };
+
+ silentUnlink = function(path) {
+ var err, ref1;
+ try {
+ return fs.unlinkSync(path);
+ } catch (error) {
+ err = error;
+ if ((ref1 = err.code) !== 'ENOENT' && ref1 !== 'EPERM') {
+ throw err;
+ }
+ }
+ };
+
+ outputPath = function(source, base, extension) {
+ var basename, dir, srcDir;
+ if (extension == null) {
+ extension = ".js";
+ }
+ basename = helpers.baseFileName(source, true, useWinPathSep);
+ srcDir = path.dirname(source);
+ if (!opts.output) {
+ dir = srcDir;
+ } else if (source === base) {
+ dir = opts.output;
+ } else {
+ dir = path.join(opts.output, path.relative(base, srcDir));
+ }
+ return path.join(dir, basename + extension);
+ };
+
+ mkdirp = function(dir, fn) {
+ var mkdirs, mode;
+ mode = 0x1ff & ~process.umask();
+ return (mkdirs = function(p, fn) {
+ return fs.exists(p, function(exists) {
+ if (exists) {
+ return fn();
+ } else {
+ return mkdirs(path.dirname(p), function() {
+ return fs.mkdir(p, mode, function(err) {
+ if (err) {
+ return fn(err);
+ }
+ return fn();
+ });
+ });
+ }
+ });
+ })(dir, fn);
+ };
+
+ writeJs = function(base, sourcePath, js, jsPath, generatedSourceMap) {
+ var compile, jsDir, sourceMapPath;
+ if (generatedSourceMap == null) {
+ generatedSourceMap = null;
+ }
+ sourceMapPath = outputPath(sourcePath, base, ".js.map");
+ jsDir = path.dirname(jsPath);
+ compile = function() {
+ if (opts.compile) {
+ if (js.length <= 0) {
+ js = ' ';
+ }
+ if (generatedSourceMap) {
+ js = js + "\n//# sourceMappingURL=" + (helpers.baseFileName(sourceMapPath, false, useWinPathSep)) + "\n";
+ }
+ fs.writeFile(jsPath, js, function(err) {
+ if (err) {
+ printLine(err.message);
+ return process.exit(1);
+ } else if (opts.compile && opts.watch) {
+ return timeLog("compiled " + sourcePath);
+ }
+ });
+ }
+ if (generatedSourceMap) {
+ return fs.writeFile(sourceMapPath, generatedSourceMap, function(err) {
+ if (err) {
+ printLine("Could not write source map: " + err.message);
+ return process.exit(1);
+ }
+ });
+ }
+ };
+ return fs.exists(jsDir, function(itExists) {
+ if (itExists) {
+ return compile();
+ } else {
+ return mkdirp(jsDir, compile);
+ }
+ });
+ };
+
+ wait = function(milliseconds, func) {
+ return setTimeout(func, milliseconds);
+ };
+
+ timeLog = function(message) {
+ return console.log(((new Date).toLocaleTimeString()) + " - " + message);
+ };
+
+ printTokens = function(tokens) {
+ var strings, tag, token, value;
+ strings = (function() {
+ var i, len, results;
+ results = [];
+ for (i = 0, len = tokens.length; i < len; i++) {
+ token = tokens[i];
+ tag = token[0];
+ value = token[1].toString().replace(/\n/, '\\n');
+ results.push("[" + tag + " " + value + "]");
+ }
+ return results;
+ })();
+ return printLine(strings.join(' '));
+ };
+
+ parseOptions = function() {
+ var o;
+ optionParser = new optparse.OptionParser(SWITCHES, BANNER);
+ o = opts = optionParser.parse(process.argv.slice(2));
+ o.compile || (o.compile = !!o.output);
+ o.run = !(o.compile || o.print || o.map);
+ return o.print = !!(o.print || (o["eval"] || o.stdio && o.compile));
+ };
+
+ compileOptions = function(filename, base) {
+ var answer, cwd, jsDir, jsPath;
+ answer = {
+ filename: filename,
+ literate: opts.literate || helpers.isLiterate(filename),
+ bare: opts.bare,
+ header: opts.compile && !opts['no-header'],
+ sourceMap: opts.map,
+ inlineMap: opts['inline-map']
+ };
+ if (filename) {
+ if (base) {
+ cwd = process.cwd();
+ jsPath = outputPath(filename, base);
+ jsDir = path.dirname(jsPath);
+ answer = helpers.merge(answer, {
+ jsPath: jsPath,
+ sourceRoot: path.relative(jsDir, cwd),
+ sourceFiles: [path.relative(cwd, filename)],
+ generatedFile: helpers.baseFileName(jsPath, false, useWinPathSep)
+ });
+ } else {
+ answer = helpers.merge(answer, {
+ sourceRoot: "",
+ sourceFiles: [helpers.baseFileName(filename, false, useWinPathSep)],
+ generatedFile: helpers.baseFileName(filename, true, useWinPathSep) + ".js"
+ });
+ }
+ }
+ return answer;
+ };
+
+ forkNode = function() {
+ var args, nodeArgs, p;
+ nodeArgs = opts.nodejs.split(/\s+/);
+ args = process.argv.slice(1);
+ args.splice(args.indexOf('--nodejs'), 2);
+ p = spawn(process.execPath, nodeArgs.concat(args), {
+ cwd: process.cwd(),
+ env: process.env,
+ stdio: [0, 1, 2]
+ });
+ return p.on('exit', function(code) {
+ return process.exit(code);
+ });
+ };
+
+ usage = function() {
+ return printLine((new optparse.OptionParser(SWITCHES, BANNER)).help());
+ };
+
+ version = function() {
+ return printLine("CoffeeScript version " + CoffeeScript.VERSION);
+ };
+
+}).call(this);
diff --git a/modeshape-sample/node_modules/coffee-script/lib/coffee-script/grammar.js b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/grammar.js
new file mode 100644
index 0000000..b0f6e80
--- /dev/null
+++ b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/grammar.js
@@ -0,0 +1,816 @@
+// Generated by CoffeeScript 1.12.7
+(function() {
+ var Parser, alt, alternatives, grammar, name, o, operators, token, tokens, unwrap;
+
+ Parser = require('jison').Parser;
+
+ unwrap = /^function\s*\(\)\s*\{\s*return\s*([\s\S]*);\s*\}/;
+
+ o = function(patternString, action, options) {
+ var addLocationDataFn, match, patternCount;
+ patternString = patternString.replace(/\s{2,}/g, ' ');
+ patternCount = patternString.split(' ').length;
+ if (!action) {
+ return [patternString, '$$ = $1;', options];
+ }
+ action = (match = unwrap.exec(action)) ? match[1] : "(" + action + "())";
+ action = action.replace(/\bnew /g, '$&yy.');
+ action = action.replace(/\b(?:Block\.wrap|extend)\b/g, 'yy.$&');
+ addLocationDataFn = function(first, last) {
+ if (!last) {
+ return "yy.addLocationDataFn(@" + first + ")";
+ } else {
+ return "yy.addLocationDataFn(@" + first + ", @" + last + ")";
+ }
+ };
+ action = action.replace(/LOC\(([0-9]*)\)/g, addLocationDataFn('$1'));
+ action = action.replace(/LOC\(([0-9]*),\s*([0-9]*)\)/g, addLocationDataFn('$1', '$2'));
+ return [patternString, "$$ = " + (addLocationDataFn(1, patternCount)) + "(" + action + ");", options];
+ };
+
+ grammar = {
+ Root: [
+ o('', function() {
+ return new Block;
+ }), o('Body')
+ ],
+ Body: [
+ o('Line', function() {
+ return Block.wrap([$1]);
+ }), o('Body TERMINATOR Line', function() {
+ return $1.push($3);
+ }), o('Body TERMINATOR')
+ ],
+ Line: [o('Expression'), o('Statement'), o('YieldReturn')],
+ Statement: [
+ o('Return'), o('Comment'), o('STATEMENT', function() {
+ return new StatementLiteral($1);
+ }), o('Import'), o('Export')
+ ],
+ Expression: [o('Value'), o('Invocation'), o('Code'), o('Operation'), o('Assign'), o('If'), o('Try'), o('While'), o('For'), o('Switch'), o('Class'), o('Throw'), o('Yield')],
+ Yield: [
+ o('YIELD', function() {
+ return new Op($1, new Value(new Literal('')));
+ }), o('YIELD Expression', function() {
+ return new Op($1, $2);
+ }), o('YIELD FROM Expression', function() {
+ return new Op($1.concat($2), $3);
+ })
+ ],
+ Block: [
+ o('INDENT OUTDENT', function() {
+ return new Block;
+ }), o('INDENT Body OUTDENT', function() {
+ return $2;
+ })
+ ],
+ Identifier: [
+ o('IDENTIFIER', function() {
+ return new IdentifierLiteral($1);
+ })
+ ],
+ Property: [
+ o('PROPERTY', function() {
+ return new PropertyName($1);
+ })
+ ],
+ AlphaNumeric: [
+ o('NUMBER', function() {
+ return new NumberLiteral($1);
+ }), o('String')
+ ],
+ String: [
+ o('STRING', function() {
+ return new StringLiteral($1);
+ }), o('STRING_START Body STRING_END', function() {
+ return new StringWithInterpolations($2);
+ })
+ ],
+ Regex: [
+ o('REGEX', function() {
+ return new RegexLiteral($1);
+ }), o('REGEX_START Invocation REGEX_END', function() {
+ return new RegexWithInterpolations($2.args);
+ })
+ ],
+ Literal: [
+ o('AlphaNumeric'), o('JS', function() {
+ return new PassthroughLiteral($1);
+ }), o('Regex'), o('UNDEFINED', function() {
+ return new UndefinedLiteral;
+ }), o('NULL', function() {
+ return new NullLiteral;
+ }), o('BOOL', function() {
+ return new BooleanLiteral($1);
+ }), o('INFINITY', function() {
+ return new InfinityLiteral($1);
+ }), o('NAN', function() {
+ return new NaNLiteral;
+ })
+ ],
+ Assign: [
+ o('Assignable = Expression', function() {
+ return new Assign($1, $3);
+ }), o('Assignable = TERMINATOR Expression', function() {
+ return new Assign($1, $4);
+ }), o('Assignable = INDENT Expression OUTDENT', function() {
+ return new Assign($1, $4);
+ })
+ ],
+ AssignObj: [
+ o('ObjAssignable', function() {
+ return new Value($1);
+ }), o('ObjAssignable : Expression', function() {
+ return new Assign(LOC(1)(new Value($1)), $3, 'object', {
+ operatorToken: LOC(2)(new Literal($2))
+ });
+ }), o('ObjAssignable : INDENT Expression OUTDENT', function() {
+ return new Assign(LOC(1)(new Value($1)), $4, 'object', {
+ operatorToken: LOC(2)(new Literal($2))
+ });
+ }), o('SimpleObjAssignable = Expression', function() {
+ return new Assign(LOC(1)(new Value($1)), $3, null, {
+ operatorToken: LOC(2)(new Literal($2))
+ });
+ }), o('SimpleObjAssignable = INDENT Expression OUTDENT', function() {
+ return new Assign(LOC(1)(new Value($1)), $4, null, {
+ operatorToken: LOC(2)(new Literal($2))
+ });
+ }), o('Comment')
+ ],
+ SimpleObjAssignable: [o('Identifier'), o('Property'), o('ThisProperty')],
+ ObjAssignable: [o('SimpleObjAssignable'), o('AlphaNumeric')],
+ Return: [
+ o('RETURN Expression', function() {
+ return new Return($2);
+ }), o('RETURN INDENT Object OUTDENT', function() {
+ return new Return(new Value($3));
+ }), o('RETURN', function() {
+ return new Return;
+ })
+ ],
+ YieldReturn: [
+ o('YIELD RETURN Expression', function() {
+ return new YieldReturn($3);
+ }), o('YIELD RETURN', function() {
+ return new YieldReturn;
+ })
+ ],
+ Comment: [
+ o('HERECOMMENT', function() {
+ return new Comment($1);
+ })
+ ],
+ Code: [
+ o('PARAM_START ParamList PARAM_END FuncGlyph Block', function() {
+ return new Code($2, $5, $4);
+ }), o('FuncGlyph Block', function() {
+ return new Code([], $2, $1);
+ })
+ ],
+ FuncGlyph: [
+ o('->', function() {
+ return 'func';
+ }), o('=>', function() {
+ return 'boundfunc';
+ })
+ ],
+ OptComma: [o(''), o(',')],
+ ParamList: [
+ o('', function() {
+ return [];
+ }), o('Param', function() {
+ return [$1];
+ }), o('ParamList , Param', function() {
+ return $1.concat($3);
+ }), o('ParamList OptComma TERMINATOR Param', function() {
+ return $1.concat($4);
+ }), o('ParamList OptComma INDENT ParamList OptComma OUTDENT', function() {
+ return $1.concat($4);
+ })
+ ],
+ Param: [
+ o('ParamVar', function() {
+ return new Param($1);
+ }), o('ParamVar ...', function() {
+ return new Param($1, null, true);
+ }), o('ParamVar = Expression', function() {
+ return new Param($1, $3);
+ }), o('...', function() {
+ return new Expansion;
+ })
+ ],
+ ParamVar: [o('Identifier'), o('ThisProperty'), o('Array'), o('Object')],
+ Splat: [
+ o('Expression ...', function() {
+ return new Splat($1);
+ })
+ ],
+ SimpleAssignable: [
+ o('Identifier', function() {
+ return new Value($1);
+ }), o('Value Accessor', function() {
+ return $1.add($2);
+ }), o('Invocation Accessor', function() {
+ return new Value($1, [].concat($2));
+ }), o('ThisProperty')
+ ],
+ Assignable: [
+ o('SimpleAssignable'), o('Array', function() {
+ return new Value($1);
+ }), o('Object', function() {
+ return new Value($1);
+ })
+ ],
+ Value: [
+ o('Assignable'), o('Literal', function() {
+ return new Value($1);
+ }), o('Parenthetical', function() {
+ return new Value($1);
+ }), o('Range', function() {
+ return new Value($1);
+ }), o('This')
+ ],
+ Accessor: [
+ o('. Property', function() {
+ return new Access($2);
+ }), o('?. Property', function() {
+ return new Access($2, 'soak');
+ }), o(':: Property', function() {
+ return [LOC(1)(new Access(new PropertyName('prototype'))), LOC(2)(new Access($2))];
+ }), o('?:: Property', function() {
+ return [LOC(1)(new Access(new PropertyName('prototype'), 'soak')), LOC(2)(new Access($2))];
+ }), o('::', function() {
+ return new Access(new PropertyName('prototype'));
+ }), o('Index')
+ ],
+ Index: [
+ o('INDEX_START IndexValue INDEX_END', function() {
+ return $2;
+ }), o('INDEX_SOAK Index', function() {
+ return extend($2, {
+ soak: true
+ });
+ })
+ ],
+ IndexValue: [
+ o('Expression', function() {
+ return new Index($1);
+ }), o('Slice', function() {
+ return new Slice($1);
+ })
+ ],
+ Object: [
+ o('{ AssignList OptComma }', function() {
+ return new Obj($2, $1.generated);
+ })
+ ],
+ AssignList: [
+ o('', function() {
+ return [];
+ }), o('AssignObj', function() {
+ return [$1];
+ }), o('AssignList , AssignObj', function() {
+ return $1.concat($3);
+ }), o('AssignList OptComma TERMINATOR AssignObj', function() {
+ return $1.concat($4);
+ }), o('AssignList OptComma INDENT AssignList OptComma OUTDENT', function() {
+ return $1.concat($4);
+ })
+ ],
+ Class: [
+ o('CLASS', function() {
+ return new Class;
+ }), o('CLASS Block', function() {
+ return new Class(null, null, $2);
+ }), o('CLASS EXTENDS Expression', function() {
+ return new Class(null, $3);
+ }), o('CLASS EXTENDS Expression Block', function() {
+ return new Class(null, $3, $4);
+ }), o('CLASS SimpleAssignable', function() {
+ return new Class($2);
+ }), o('CLASS SimpleAssignable Block', function() {
+ return new Class($2, null, $3);
+ }), o('CLASS SimpleAssignable EXTENDS Expression', function() {
+ return new Class($2, $4);
+ }), o('CLASS SimpleAssignable EXTENDS Expression Block', function() {
+ return new Class($2, $4, $5);
+ })
+ ],
+ Import: [
+ o('IMPORT String', function() {
+ return new ImportDeclaration(null, $2);
+ }), o('IMPORT ImportDefaultSpecifier FROM String', function() {
+ return new ImportDeclaration(new ImportClause($2, null), $4);
+ }), o('IMPORT ImportNamespaceSpecifier FROM String', function() {
+ return new ImportDeclaration(new ImportClause(null, $2), $4);
+ }), o('IMPORT { } FROM String', function() {
+ return new ImportDeclaration(new ImportClause(null, new ImportSpecifierList([])), $5);
+ }), o('IMPORT { ImportSpecifierList OptComma } FROM String', function() {
+ return new ImportDeclaration(new ImportClause(null, new ImportSpecifierList($3)), $7);
+ }), o('IMPORT ImportDefaultSpecifier , ImportNamespaceSpecifier FROM String', function() {
+ return new ImportDeclaration(new ImportClause($2, $4), $6);
+ }), o('IMPORT ImportDefaultSpecifier , { ImportSpecifierList OptComma } FROM String', function() {
+ return new ImportDeclaration(new ImportClause($2, new ImportSpecifierList($5)), $9);
+ })
+ ],
+ ImportSpecifierList: [
+ o('ImportSpecifier', function() {
+ return [$1];
+ }), o('ImportSpecifierList , ImportSpecifier', function() {
+ return $1.concat($3);
+ }), o('ImportSpecifierList OptComma TERMINATOR ImportSpecifier', function() {
+ return $1.concat($4);
+ }), o('INDENT ImportSpecifierList OptComma OUTDENT', function() {
+ return $2;
+ }), o('ImportSpecifierList OptComma INDENT ImportSpecifierList OptComma OUTDENT', function() {
+ return $1.concat($4);
+ })
+ ],
+ ImportSpecifier: [
+ o('Identifier', function() {
+ return new ImportSpecifier($1);
+ }), o('Identifier AS Identifier', function() {
+ return new ImportSpecifier($1, $3);
+ }), o('DEFAULT', function() {
+ return new ImportSpecifier(new Literal($1));
+ }), o('DEFAULT AS Identifier', function() {
+ return new ImportSpecifier(new Literal($1), $3);
+ })
+ ],
+ ImportDefaultSpecifier: [
+ o('Identifier', function() {
+ return new ImportDefaultSpecifier($1);
+ })
+ ],
+ ImportNamespaceSpecifier: [
+ o('IMPORT_ALL AS Identifier', function() {
+ return new ImportNamespaceSpecifier(new Literal($1), $3);
+ })
+ ],
+ Export: [
+ o('EXPORT { }', function() {
+ return new ExportNamedDeclaration(new ExportSpecifierList([]));
+ }), o('EXPORT { ExportSpecifierList OptComma }', function() {
+ return new ExportNamedDeclaration(new ExportSpecifierList($3));
+ }), o('EXPORT Class', function() {
+ return new ExportNamedDeclaration($2);
+ }), o('EXPORT Identifier = Expression', function() {
+ return new ExportNamedDeclaration(new Assign($2, $4, null, {
+ moduleDeclaration: 'export'
+ }));
+ }), o('EXPORT Identifier = TERMINATOR Expression', function() {
+ return new ExportNamedDeclaration(new Assign($2, $5, null, {
+ moduleDeclaration: 'export'
+ }));
+ }), o('EXPORT Identifier = INDENT Expression OUTDENT', function() {
+ return new ExportNamedDeclaration(new Assign($2, $5, null, {
+ moduleDeclaration: 'export'
+ }));
+ }), o('EXPORT DEFAULT Expression', function() {
+ return new ExportDefaultDeclaration($3);
+ }), o('EXPORT EXPORT_ALL FROM String', function() {
+ return new ExportAllDeclaration(new Literal($2), $4);
+ }), o('EXPORT { ExportSpecifierList OptComma } FROM String', function() {
+ return new ExportNamedDeclaration(new ExportSpecifierList($3), $7);
+ })
+ ],
+ ExportSpecifierList: [
+ o('ExportSpecifier', function() {
+ return [$1];
+ }), o('ExportSpecifierList , ExportSpecifier', function() {
+ return $1.concat($3);
+ }), o('ExportSpecifierList OptComma TERMINATOR ExportSpecifier', function() {
+ return $1.concat($4);
+ }), o('INDENT ExportSpecifierList OptComma OUTDENT', function() {
+ return $2;
+ }), o('ExportSpecifierList OptComma INDENT ExportSpecifierList OptComma OUTDENT', function() {
+ return $1.concat($4);
+ })
+ ],
+ ExportSpecifier: [
+ o('Identifier', function() {
+ return new ExportSpecifier($1);
+ }), o('Identifier AS Identifier', function() {
+ return new ExportSpecifier($1, $3);
+ }), o('Identifier AS DEFAULT', function() {
+ return new ExportSpecifier($1, new Literal($3));
+ }), o('DEFAULT', function() {
+ return new ExportSpecifier(new Literal($1));
+ }), o('DEFAULT AS Identifier', function() {
+ return new ExportSpecifier(new Literal($1), $3);
+ })
+ ],
+ Invocation: [
+ o('Value OptFuncExist String', function() {
+ return new TaggedTemplateCall($1, $3, $2);
+ }), o('Value OptFuncExist Arguments', function() {
+ return new Call($1, $3, $2);
+ }), o('Invocation OptFuncExist Arguments', function() {
+ return new Call($1, $3, $2);
+ }), o('Super')
+ ],
+ Super: [
+ o('SUPER', function() {
+ return new SuperCall;
+ }), o('SUPER Arguments', function() {
+ return new SuperCall($2);
+ })
+ ],
+ OptFuncExist: [
+ o('', function() {
+ return false;
+ }), o('FUNC_EXIST', function() {
+ return true;
+ })
+ ],
+ Arguments: [
+ o('CALL_START CALL_END', function() {
+ return [];
+ }), o('CALL_START ArgList OptComma CALL_END', function() {
+ return $2;
+ })
+ ],
+ This: [
+ o('THIS', function() {
+ return new Value(new ThisLiteral);
+ }), o('@', function() {
+ return new Value(new ThisLiteral);
+ })
+ ],
+ ThisProperty: [
+ o('@ Property', function() {
+ return new Value(LOC(1)(new ThisLiteral), [LOC(2)(new Access($2))], 'this');
+ })
+ ],
+ Array: [
+ o('[ ]', function() {
+ return new Arr([]);
+ }), o('[ ArgList OptComma ]', function() {
+ return new Arr($2);
+ })
+ ],
+ RangeDots: [
+ o('..', function() {
+ return 'inclusive';
+ }), o('...', function() {
+ return 'exclusive';
+ })
+ ],
+ Range: [
+ o('[ Expression RangeDots Expression ]', function() {
+ return new Range($2, $4, $3);
+ })
+ ],
+ Slice: [
+ o('Expression RangeDots Expression', function() {
+ return new Range($1, $3, $2);
+ }), o('Expression RangeDots', function() {
+ return new Range($1, null, $2);
+ }), o('RangeDots Expression', function() {
+ return new Range(null, $2, $1);
+ }), o('RangeDots', function() {
+ return new Range(null, null, $1);
+ })
+ ],
+ ArgList: [
+ o('Arg', function() {
+ return [$1];
+ }), o('ArgList , Arg', function() {
+ return $1.concat($3);
+ }), o('ArgList OptComma TERMINATOR Arg', function() {
+ return $1.concat($4);
+ }), o('INDENT ArgList OptComma OUTDENT', function() {
+ return $2;
+ }), o('ArgList OptComma INDENT ArgList OptComma OUTDENT', function() {
+ return $1.concat($4);
+ })
+ ],
+ Arg: [
+ o('Expression'), o('Splat'), o('...', function() {
+ return new Expansion;
+ })
+ ],
+ SimpleArgs: [
+ o('Expression'), o('SimpleArgs , Expression', function() {
+ return [].concat($1, $3);
+ })
+ ],
+ Try: [
+ o('TRY Block', function() {
+ return new Try($2);
+ }), o('TRY Block Catch', function() {
+ return new Try($2, $3[0], $3[1]);
+ }), o('TRY Block FINALLY Block', function() {
+ return new Try($2, null, null, $4);
+ }), o('TRY Block Catch FINALLY Block', function() {
+ return new Try($2, $3[0], $3[1], $5);
+ })
+ ],
+ Catch: [
+ o('CATCH Identifier Block', function() {
+ return [$2, $3];
+ }), o('CATCH Object Block', function() {
+ return [LOC(2)(new Value($2)), $3];
+ }), o('CATCH Block', function() {
+ return [null, $2];
+ })
+ ],
+ Throw: [
+ o('THROW Expression', function() {
+ return new Throw($2);
+ })
+ ],
+ Parenthetical: [
+ o('( Body )', function() {
+ return new Parens($2);
+ }), o('( INDENT Body OUTDENT )', function() {
+ return new Parens($3);
+ })
+ ],
+ WhileSource: [
+ o('WHILE Expression', function() {
+ return new While($2);
+ }), o('WHILE Expression WHEN Expression', function() {
+ return new While($2, {
+ guard: $4
+ });
+ }), o('UNTIL Expression', function() {
+ return new While($2, {
+ invert: true
+ });
+ }), o('UNTIL Expression WHEN Expression', function() {
+ return new While($2, {
+ invert: true,
+ guard: $4
+ });
+ })
+ ],
+ While: [
+ o('WhileSource Block', function() {
+ return $1.addBody($2);
+ }), o('Statement WhileSource', function() {
+ return $2.addBody(LOC(1)(Block.wrap([$1])));
+ }), o('Expression WhileSource', function() {
+ return $2.addBody(LOC(1)(Block.wrap([$1])));
+ }), o('Loop', function() {
+ return $1;
+ })
+ ],
+ Loop: [
+ o('LOOP Block', function() {
+ return new While(LOC(1)(new BooleanLiteral('true'))).addBody($2);
+ }), o('LOOP Expression', function() {
+ return new While(LOC(1)(new BooleanLiteral('true'))).addBody(LOC(2)(Block.wrap([$2])));
+ })
+ ],
+ For: [
+ o('Statement ForBody', function() {
+ return new For($1, $2);
+ }), o('Expression ForBody', function() {
+ return new For($1, $2);
+ }), o('ForBody Block', function() {
+ return new For($2, $1);
+ })
+ ],
+ ForBody: [
+ o('FOR Range', function() {
+ return {
+ source: LOC(2)(new Value($2))
+ };
+ }), o('FOR Range BY Expression', function() {
+ return {
+ source: LOC(2)(new Value($2)),
+ step: $4
+ };
+ }), o('ForStart ForSource', function() {
+ $2.own = $1.own;
+ $2.ownTag = $1.ownTag;
+ $2.name = $1[0];
+ $2.index = $1[1];
+ return $2;
+ })
+ ],
+ ForStart: [
+ o('FOR ForVariables', function() {
+ return $2;
+ }), o('FOR OWN ForVariables', function() {
+ $3.own = true;
+ $3.ownTag = LOC(2)(new Literal($2));
+ return $3;
+ })
+ ],
+ ForValue: [
+ o('Identifier'), o('ThisProperty'), o('Array', function() {
+ return new Value($1);
+ }), o('Object', function() {
+ return new Value($1);
+ })
+ ],
+ ForVariables: [
+ o('ForValue', function() {
+ return [$1];
+ }), o('ForValue , ForValue', function() {
+ return [$1, $3];
+ })
+ ],
+ ForSource: [
+ o('FORIN Expression', function() {
+ return {
+ source: $2
+ };
+ }), o('FOROF Expression', function() {
+ return {
+ source: $2,
+ object: true
+ };
+ }), o('FORIN Expression WHEN Expression', function() {
+ return {
+ source: $2,
+ guard: $4
+ };
+ }), o('FOROF Expression WHEN Expression', function() {
+ return {
+ source: $2,
+ guard: $4,
+ object: true
+ };
+ }), o('FORIN Expression BY Expression', function() {
+ return {
+ source: $2,
+ step: $4
+ };
+ }), o('FORIN Expression WHEN Expression BY Expression', function() {
+ return {
+ source: $2,
+ guard: $4,
+ step: $6
+ };
+ }), o('FORIN Expression BY Expression WHEN Expression', function() {
+ return {
+ source: $2,
+ step: $4,
+ guard: $6
+ };
+ }), o('FORFROM Expression', function() {
+ return {
+ source: $2,
+ from: true
+ };
+ }), o('FORFROM Expression WHEN Expression', function() {
+ return {
+ source: $2,
+ guard: $4,
+ from: true
+ };
+ })
+ ],
+ Switch: [
+ o('SWITCH Expression INDENT Whens OUTDENT', function() {
+ return new Switch($2, $4);
+ }), o('SWITCH Expression INDENT Whens ELSE Block OUTDENT', function() {
+ return new Switch($2, $4, $6);
+ }), o('SWITCH INDENT Whens OUTDENT', function() {
+ return new Switch(null, $3);
+ }), o('SWITCH INDENT Whens ELSE Block OUTDENT', function() {
+ return new Switch(null, $3, $5);
+ })
+ ],
+ Whens: [
+ o('When'), o('Whens When', function() {
+ return $1.concat($2);
+ })
+ ],
+ When: [
+ o('LEADING_WHEN SimpleArgs Block', function() {
+ return [[$2, $3]];
+ }), o('LEADING_WHEN SimpleArgs Block TERMINATOR', function() {
+ return [[$2, $3]];
+ })
+ ],
+ IfBlock: [
+ o('IF Expression Block', function() {
+ return new If($2, $3, {
+ type: $1
+ });
+ }), o('IfBlock ELSE IF Expression Block', function() {
+ return $1.addElse(LOC(3, 5)(new If($4, $5, {
+ type: $3
+ })));
+ })
+ ],
+ If: [
+ o('IfBlock'), o('IfBlock ELSE Block', function() {
+ return $1.addElse($3);
+ }), o('Statement POST_IF Expression', function() {
+ return new If($3, LOC(1)(Block.wrap([$1])), {
+ type: $2,
+ statement: true
+ });
+ }), o('Expression POST_IF Expression', function() {
+ return new If($3, LOC(1)(Block.wrap([$1])), {
+ type: $2,
+ statement: true
+ });
+ })
+ ],
+ Operation: [
+ o('UNARY Expression', function() {
+ return new Op($1, $2);
+ }), o('UNARY_MATH Expression', function() {
+ return new Op($1, $2);
+ }), o('- Expression', (function() {
+ return new Op('-', $2);
+ }), {
+ prec: 'UNARY_MATH'
+ }), o('+ Expression', (function() {
+ return new Op('+', $2);
+ }), {
+ prec: 'UNARY_MATH'
+ }), o('-- SimpleAssignable', function() {
+ return new Op('--', $2);
+ }), o('++ SimpleAssignable', function() {
+ return new Op('++', $2);
+ }), o('SimpleAssignable --', function() {
+ return new Op('--', $1, null, true);
+ }), o('SimpleAssignable ++', function() {
+ return new Op('++', $1, null, true);
+ }), o('Expression ?', function() {
+ return new Existence($1);
+ }), o('Expression + Expression', function() {
+ return new Op('+', $1, $3);
+ }), o('Expression - Expression', function() {
+ return new Op('-', $1, $3);
+ }), o('Expression MATH Expression', function() {
+ return new Op($2, $1, $3);
+ }), o('Expression ** Expression', function() {
+ return new Op($2, $1, $3);
+ }), o('Expression SHIFT Expression', function() {
+ return new Op($2, $1, $3);
+ }), o('Expression COMPARE Expression', function() {
+ return new Op($2, $1, $3);
+ }), o('Expression & Expression', function() {
+ return new Op($2, $1, $3);
+ }), o('Expression ^ Expression', function() {
+ return new Op($2, $1, $3);
+ }), o('Expression | Expression', function() {
+ return new Op($2, $1, $3);
+ }), o('Expression && Expression', function() {
+ return new Op($2, $1, $3);
+ }), o('Expression || Expression', function() {
+ return new Op($2, $1, $3);
+ }), o('Expression BIN? Expression', function() {
+ return new Op($2, $1, $3);
+ }), o('Expression RELATION Expression', function() {
+ if ($2.charAt(0) === '!') {
+ return new Op($2.slice(1), $1, $3).invert();
+ } else {
+ return new Op($2, $1, $3);
+ }
+ }), o('SimpleAssignable COMPOUND_ASSIGN Expression', function() {
+ return new Assign($1, $3, $2);
+ }), o('SimpleAssignable COMPOUND_ASSIGN INDENT Expression OUTDENT', function() {
+ return new Assign($1, $4, $2);
+ }), o('SimpleAssignable COMPOUND_ASSIGN TERMINATOR Expression', function() {
+ return new Assign($1, $4, $2);
+ }), o('SimpleAssignable EXTENDS Expression', function() {
+ return new Extends($1, $3);
+ })
+ ]
+ };
+
+ operators = [['left', '.', '?.', '::', '?::'], ['left', 'CALL_START', 'CALL_END'], ['nonassoc', '++', '--'], ['left', '?'], ['right', 'UNARY'], ['right', '**'], ['right', 'UNARY_MATH'], ['left', 'MATH'], ['left', '+', '-'], ['left', 'SHIFT'], ['left', 'RELATION'], ['left', 'COMPARE'], ['left', '&'], ['left', '^'], ['left', '|'], ['left', '&&'], ['left', '||'], ['left', 'BIN?'], ['nonassoc', 'INDENT', 'OUTDENT'], ['right', 'YIELD'], ['right', '=', ':', 'COMPOUND_ASSIGN', 'RETURN', 'THROW', 'EXTENDS'], ['right', 'FORIN', 'FOROF', 'FORFROM', 'BY', 'WHEN'], ['right', 'IF', 'ELSE', 'FOR', 'WHILE', 'UNTIL', 'LOOP', 'SUPER', 'CLASS', 'IMPORT', 'EXPORT'], ['left', 'POST_IF']];
+
+ tokens = [];
+
+ for (name in grammar) {
+ alternatives = grammar[name];
+ grammar[name] = (function() {
+ var i, j, len, len1, ref, results;
+ results = [];
+ for (i = 0, len = alternatives.length; i < len; i++) {
+ alt = alternatives[i];
+ ref = alt[0].split(' ');
+ for (j = 0, len1 = ref.length; j < len1; j++) {
+ token = ref[j];
+ if (!grammar[token]) {
+ tokens.push(token);
+ }
+ }
+ if (name === 'Root') {
+ alt[1] = "return " + alt[1];
+ }
+ results.push(alt);
+ }
+ return results;
+ })();
+ }
+
+ exports.parser = new Parser({
+ tokens: tokens.join(' '),
+ bnf: grammar,
+ operators: operators.reverse(),
+ startSymbol: 'Root'
+ });
+
+}).call(this);
diff --git a/modeshape-sample/node_modules/coffee-script/lib/coffee-script/helpers.js b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/helpers.js
new file mode 100644
index 0000000..043a465
--- /dev/null
+++ b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/helpers.js
@@ -0,0 +1,249 @@
+// Generated by CoffeeScript 1.12.7
+(function() {
+ var buildLocationData, extend, flatten, ref, repeat, syntaxErrorToString;
+
+ exports.starts = function(string, literal, start) {
+ return literal === string.substr(start, literal.length);
+ };
+
+ exports.ends = function(string, literal, back) {
+ var len;
+ len = literal.length;
+ return literal === string.substr(string.length - len - (back || 0), len);
+ };
+
+ exports.repeat = repeat = function(str, n) {
+ var res;
+ res = '';
+ while (n > 0) {
+ if (n & 1) {
+ res += str;
+ }
+ n >>>= 1;
+ str += str;
+ }
+ return res;
+ };
+
+ exports.compact = function(array) {
+ var i, item, len1, results;
+ results = [];
+ for (i = 0, len1 = array.length; i < len1; i++) {
+ item = array[i];
+ if (item) {
+ results.push(item);
+ }
+ }
+ return results;
+ };
+
+ exports.count = function(string, substr) {
+ var num, pos;
+ num = pos = 0;
+ if (!substr.length) {
+ return 1 / 0;
+ }
+ while (pos = 1 + string.indexOf(substr, pos)) {
+ num++;
+ }
+ return num;
+ };
+
+ exports.merge = function(options, overrides) {
+ return extend(extend({}, options), overrides);
+ };
+
+ extend = exports.extend = function(object, properties) {
+ var key, val;
+ for (key in properties) {
+ val = properties[key];
+ object[key] = val;
+ }
+ return object;
+ };
+
+ exports.flatten = flatten = function(array) {
+ var element, flattened, i, len1;
+ flattened = [];
+ for (i = 0, len1 = array.length; i < len1; i++) {
+ element = array[i];
+ if ('[object Array]' === Object.prototype.toString.call(element)) {
+ flattened = flattened.concat(flatten(element));
+ } else {
+ flattened.push(element);
+ }
+ }
+ return flattened;
+ };
+
+ exports.del = function(obj, key) {
+ var val;
+ val = obj[key];
+ delete obj[key];
+ return val;
+ };
+
+ exports.some = (ref = Array.prototype.some) != null ? ref : function(fn) {
+ var e, i, len1, ref1;
+ ref1 = this;
+ for (i = 0, len1 = ref1.length; i < len1; i++) {
+ e = ref1[i];
+ if (fn(e)) {
+ return true;
+ }
+ }
+ return false;
+ };
+
+ exports.invertLiterate = function(code) {
+ var line, lines, maybe_code;
+ maybe_code = true;
+ lines = (function() {
+ var i, len1, ref1, results;
+ ref1 = code.split('\n');
+ results = [];
+ for (i = 0, len1 = ref1.length; i < len1; i++) {
+ line = ref1[i];
+ if (maybe_code && /^([ ]{4}|[ ]{0,3}\t)/.test(line)) {
+ results.push(line);
+ } else if (maybe_code = /^\s*$/.test(line)) {
+ results.push(line);
+ } else {
+ results.push('# ' + line);
+ }
+ }
+ return results;
+ })();
+ return lines.join('\n');
+ };
+
+ buildLocationData = function(first, last) {
+ if (!last) {
+ return first;
+ } else {
+ return {
+ first_line: first.first_line,
+ first_column: first.first_column,
+ last_line: last.last_line,
+ last_column: last.last_column
+ };
+ }
+ };
+
+ exports.addLocationDataFn = function(first, last) {
+ return function(obj) {
+ if (((typeof obj) === 'object') && (!!obj['updateLocationDataIfMissing'])) {
+ obj.updateLocationDataIfMissing(buildLocationData(first, last));
+ }
+ return obj;
+ };
+ };
+
+ exports.locationDataToString = function(obj) {
+ var locationData;
+ if (("2" in obj) && ("first_line" in obj[2])) {
+ locationData = obj[2];
+ } else if ("first_line" in obj) {
+ locationData = obj;
+ }
+ if (locationData) {
+ return ((locationData.first_line + 1) + ":" + (locationData.first_column + 1) + "-") + ((locationData.last_line + 1) + ":" + (locationData.last_column + 1));
+ } else {
+ return "No location data";
+ }
+ };
+
+ exports.baseFileName = function(file, stripExt, useWinPathSep) {
+ var parts, pathSep;
+ if (stripExt == null) {
+ stripExt = false;
+ }
+ if (useWinPathSep == null) {
+ useWinPathSep = false;
+ }
+ pathSep = useWinPathSep ? /\\|\// : /\//;
+ parts = file.split(pathSep);
+ file = parts[parts.length - 1];
+ if (!(stripExt && file.indexOf('.') >= 0)) {
+ return file;
+ }
+ parts = file.split('.');
+ parts.pop();
+ if (parts[parts.length - 1] === 'coffee' && parts.length > 1) {
+ parts.pop();
+ }
+ return parts.join('.');
+ };
+
+ exports.isCoffee = function(file) {
+ return /\.((lit)?coffee|coffee\.md)$/.test(file);
+ };
+
+ exports.isLiterate = function(file) {
+ return /\.(litcoffee|coffee\.md)$/.test(file);
+ };
+
+ exports.throwSyntaxError = function(message, location) {
+ var error;
+ error = new SyntaxError(message);
+ error.location = location;
+ error.toString = syntaxErrorToString;
+ error.stack = error.toString();
+ throw error;
+ };
+
+ exports.updateSyntaxError = function(error, code, filename) {
+ if (error.toString === syntaxErrorToString) {
+ error.code || (error.code = code);
+ error.filename || (error.filename = filename);
+ error.stack = error.toString();
+ }
+ return error;
+ };
+
+ syntaxErrorToString = function() {
+ var codeLine, colorize, colorsEnabled, end, filename, first_column, first_line, last_column, last_line, marker, ref1, ref2, ref3, ref4, start;
+ if (!(this.code && this.location)) {
+ return Error.prototype.toString.call(this);
+ }
+ ref1 = this.location, first_line = ref1.first_line, first_column = ref1.first_column, last_line = ref1.last_line, last_column = ref1.last_column;
+ if (last_line == null) {
+ last_line = first_line;
+ }
+ if (last_column == null) {
+ last_column = first_column;
+ }
+ filename = this.filename || '[stdin]';
+ codeLine = this.code.split('\n')[first_line];
+ start = first_column;
+ end = first_line === last_line ? last_column + 1 : codeLine.length;
+ marker = codeLine.slice(0, start).replace(/[^\s]/g, ' ') + repeat('^', end - start);
+ if (typeof process !== "undefined" && process !== null) {
+ colorsEnabled = ((ref2 = process.stdout) != null ? ref2.isTTY : void 0) && !((ref3 = process.env) != null ? ref3.NODE_DISABLE_COLORS : void 0);
+ }
+ if ((ref4 = this.colorful) != null ? ref4 : colorsEnabled) {
+ colorize = function(str) {
+ return "\x1B[1;31m" + str + "\x1B[0m";
+ };
+ codeLine = codeLine.slice(0, start) + colorize(codeLine.slice(start, end)) + codeLine.slice(end);
+ marker = colorize(marker);
+ }
+ return filename + ":" + (first_line + 1) + ":" + (first_column + 1) + ": error: " + this.message + "\n" + codeLine + "\n" + marker;
+ };
+
+ exports.nameWhitespaceCharacter = function(string) {
+ switch (string) {
+ case ' ':
+ return 'space';
+ case '\n':
+ return 'newline';
+ case '\r':
+ return 'carriage return';
+ case '\t':
+ return 'tab';
+ default:
+ return string;
+ }
+ };
+
+}).call(this);
diff --git a/modeshape-sample/node_modules/coffee-script/lib/coffee-script/index.js b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/index.js
new file mode 100644
index 0000000..c6813d5
--- /dev/null
+++ b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/index.js
@@ -0,0 +1,11 @@
+// Generated by CoffeeScript 1.12.7
+(function() {
+ var key, ref, val;
+
+ ref = require('./coffee-script');
+ for (key in ref) {
+ val = ref[key];
+ exports[key] = val;
+ }
+
+}).call(this);
diff --git a/modeshape-sample/node_modules/coffee-script/lib/coffee-script/lexer.js b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/lexer.js
new file mode 100644
index 0000000..1c93ea1
--- /dev/null
+++ b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/lexer.js
@@ -0,0 +1,1166 @@
+// Generated by CoffeeScript 1.12.7
+(function() {
+ var BOM, BOOL, CALLABLE, CODE, COFFEE_ALIASES, COFFEE_ALIAS_MAP, COFFEE_KEYWORDS, COMMENT, COMPARE, COMPOUND_ASSIGN, HERECOMMENT_ILLEGAL, HEREDOC_DOUBLE, HEREDOC_INDENT, HEREDOC_SINGLE, HEREGEX, HEREGEX_OMIT, HERE_JSTOKEN, IDENTIFIER, INDENTABLE_CLOSERS, INDEXABLE, INVERSES, JSTOKEN, JS_KEYWORDS, LEADING_BLANK_LINE, LINE_BREAK, LINE_CONTINUER, Lexer, MATH, MULTI_DENT, NOT_REGEX, NUMBER, OPERATOR, POSSIBLY_DIVISION, REGEX, REGEX_FLAGS, REGEX_ILLEGAL, REGEX_INVALID_ESCAPE, RELATION, RESERVED, Rewriter, SHIFT, SIMPLE_STRING_OMIT, STRICT_PROSCRIBED, STRING_DOUBLE, STRING_INVALID_ESCAPE, STRING_OMIT, STRING_SINGLE, STRING_START, TRAILING_BLANK_LINE, TRAILING_SPACES, UNARY, UNARY_MATH, UNFINISHED, UNICODE_CODE_POINT_ESCAPE, VALID_FLAGS, WHITESPACE, compact, count, invertLiterate, isForFrom, isUnassignable, key, locationDataToString, ref, ref1, repeat, starts, throwSyntaxError,
+ indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; },
+ slice = [].slice;
+
+ ref = require('./rewriter'), Rewriter = ref.Rewriter, INVERSES = ref.INVERSES;
+
+ ref1 = require('./helpers'), count = ref1.count, starts = ref1.starts, compact = ref1.compact, repeat = ref1.repeat, invertLiterate = ref1.invertLiterate, locationDataToString = ref1.locationDataToString, throwSyntaxError = ref1.throwSyntaxError;
+
+ exports.Lexer = Lexer = (function() {
+ function Lexer() {}
+
+ Lexer.prototype.tokenize = function(code, opts) {
+ var consumed, end, i, ref2;
+ if (opts == null) {
+ opts = {};
+ }
+ this.literate = opts.literate;
+ this.indent = 0;
+ this.baseIndent = 0;
+ this.indebt = 0;
+ this.outdebt = 0;
+ this.indents = [];
+ this.ends = [];
+ this.tokens = [];
+ this.seenFor = false;
+ this.seenImport = false;
+ this.seenExport = false;
+ this.importSpecifierList = false;
+ this.exportSpecifierList = false;
+ this.chunkLine = opts.line || 0;
+ this.chunkColumn = opts.column || 0;
+ code = this.clean(code);
+ i = 0;
+ while (this.chunk = code.slice(i)) {
+ consumed = this.identifierToken() || this.commentToken() || this.whitespaceToken() || this.lineToken() || this.stringToken() || this.numberToken() || this.regexToken() || this.jsToken() || this.literalToken();
+ ref2 = this.getLineAndColumnFromChunk(consumed), this.chunkLine = ref2[0], this.chunkColumn = ref2[1];
+ i += consumed;
+ if (opts.untilBalanced && this.ends.length === 0) {
+ return {
+ tokens: this.tokens,
+ index: i
+ };
+ }
+ }
+ this.closeIndentation();
+ if (end = this.ends.pop()) {
+ this.error("missing " + end.tag, end.origin[2]);
+ }
+ if (opts.rewrite === false) {
+ return this.tokens;
+ }
+ return (new Rewriter).rewrite(this.tokens);
+ };
+
+ Lexer.prototype.clean = function(code) {
+ if (code.charCodeAt(0) === BOM) {
+ code = code.slice(1);
+ }
+ code = code.replace(/\r/g, '').replace(TRAILING_SPACES, '');
+ if (WHITESPACE.test(code)) {
+ code = "\n" + code;
+ this.chunkLine--;
+ }
+ if (this.literate) {
+ code = invertLiterate(code);
+ }
+ return code;
+ };
+
+ Lexer.prototype.identifierToken = function() {
+ var alias, colon, colonOffset, id, idLength, input, match, poppedToken, prev, ref2, ref3, ref4, ref5, ref6, ref7, ref8, ref9, tag, tagToken;
+ if (!(match = IDENTIFIER.exec(this.chunk))) {
+ return 0;
+ }
+ input = match[0], id = match[1], colon = match[2];
+ idLength = id.length;
+ poppedToken = void 0;
+ if (id === 'own' && this.tag() === 'FOR') {
+ this.token('OWN', id);
+ return id.length;
+ }
+ if (id === 'from' && this.tag() === 'YIELD') {
+ this.token('FROM', id);
+ return id.length;
+ }
+ if (id === 'as' && this.seenImport) {
+ if (this.value() === '*') {
+ this.tokens[this.tokens.length - 1][0] = 'IMPORT_ALL';
+ } else if (ref2 = this.value(), indexOf.call(COFFEE_KEYWORDS, ref2) >= 0) {
+ this.tokens[this.tokens.length - 1][0] = 'IDENTIFIER';
+ }
+ if ((ref3 = this.tag()) === 'DEFAULT' || ref3 === 'IMPORT_ALL' || ref3 === 'IDENTIFIER') {
+ this.token('AS', id);
+ return id.length;
+ }
+ }
+ if (id === 'as' && this.seenExport && ((ref4 = this.tag()) === 'IDENTIFIER' || ref4 === 'DEFAULT')) {
+ this.token('AS', id);
+ return id.length;
+ }
+ if (id === 'default' && this.seenExport && ((ref5 = this.tag()) === 'EXPORT' || ref5 === 'AS')) {
+ this.token('DEFAULT', id);
+ return id.length;
+ }
+ ref6 = this.tokens, prev = ref6[ref6.length - 1];
+ tag = colon || (prev != null) && (((ref7 = prev[0]) === '.' || ref7 === '?.' || ref7 === '::' || ref7 === '?::') || !prev.spaced && prev[0] === '@') ? 'PROPERTY' : 'IDENTIFIER';
+ if (tag === 'IDENTIFIER' && (indexOf.call(JS_KEYWORDS, id) >= 0 || indexOf.call(COFFEE_KEYWORDS, id) >= 0) && !(this.exportSpecifierList && indexOf.call(COFFEE_KEYWORDS, id) >= 0)) {
+ tag = id.toUpperCase();
+ if (tag === 'WHEN' && (ref8 = this.tag(), indexOf.call(LINE_BREAK, ref8) >= 0)) {
+ tag = 'LEADING_WHEN';
+ } else if (tag === 'FOR') {
+ this.seenFor = true;
+ } else if (tag === 'UNLESS') {
+ tag = 'IF';
+ } else if (tag === 'IMPORT') {
+ this.seenImport = true;
+ } else if (tag === 'EXPORT') {
+ this.seenExport = true;
+ } else if (indexOf.call(UNARY, tag) >= 0) {
+ tag = 'UNARY';
+ } else if (indexOf.call(RELATION, tag) >= 0) {
+ if (tag !== 'INSTANCEOF' && this.seenFor) {
+ tag = 'FOR' + tag;
+ this.seenFor = false;
+ } else {
+ tag = 'RELATION';
+ if (this.value() === '!') {
+ poppedToken = this.tokens.pop();
+ id = '!' + id;
+ }
+ }
+ }
+ } else if (tag === 'IDENTIFIER' && this.seenFor && id === 'from' && isForFrom(prev)) {
+ tag = 'FORFROM';
+ this.seenFor = false;
+ }
+ if (tag === 'IDENTIFIER' && indexOf.call(RESERVED, id) >= 0) {
+ this.error("reserved word '" + id + "'", {
+ length: id.length
+ });
+ }
+ if (tag !== 'PROPERTY') {
+ if (indexOf.call(COFFEE_ALIASES, id) >= 0) {
+ alias = id;
+ id = COFFEE_ALIAS_MAP[id];
+ }
+ tag = (function() {
+ switch (id) {
+ case '!':
+ return 'UNARY';
+ case '==':
+ case '!=':
+ return 'COMPARE';
+ case 'true':
+ case 'false':
+ return 'BOOL';
+ case 'break':
+ case 'continue':
+ case 'debugger':
+ return 'STATEMENT';
+ case '&&':
+ case '||':
+ return id;
+ default:
+ return tag;
+ }
+ })();
+ }
+ tagToken = this.token(tag, id, 0, idLength);
+ if (alias) {
+ tagToken.origin = [tag, alias, tagToken[2]];
+ }
+ if (poppedToken) {
+ ref9 = [poppedToken[2].first_line, poppedToken[2].first_column], tagToken[2].first_line = ref9[0], tagToken[2].first_column = ref9[1];
+ }
+ if (colon) {
+ colonOffset = input.lastIndexOf(':');
+ this.token(':', ':', colonOffset, colon.length);
+ }
+ return input.length;
+ };
+
+ Lexer.prototype.numberToken = function() {
+ var base, lexedLength, match, number, numberValue, ref2, tag;
+ if (!(match = NUMBER.exec(this.chunk))) {
+ return 0;
+ }
+ number = match[0];
+ lexedLength = number.length;
+ switch (false) {
+ case !/^0[BOX]/.test(number):
+ this.error("radix prefix in '" + number + "' must be lowercase", {
+ offset: 1
+ });
+ break;
+ case !/^(?!0x).*E/.test(number):
+ this.error("exponential notation in '" + number + "' must be indicated with a lowercase 'e'", {
+ offset: number.indexOf('E')
+ });
+ break;
+ case !/^0\d*[89]/.test(number):
+ this.error("decimal literal '" + number + "' must not be prefixed with '0'", {
+ length: lexedLength
+ });
+ break;
+ case !/^0\d+/.test(number):
+ this.error("octal literal '" + number + "' must be prefixed with '0o'", {
+ length: lexedLength
+ });
+ }
+ base = (function() {
+ switch (number.charAt(1)) {
+ case 'b':
+ return 2;
+ case 'o':
+ return 8;
+ case 'x':
+ return 16;
+ default:
+ return null;
+ }
+ })();
+ numberValue = base != null ? parseInt(number.slice(2), base) : parseFloat(number);
+ if ((ref2 = number.charAt(1)) === 'b' || ref2 === 'o') {
+ number = "0x" + (numberValue.toString(16));
+ }
+ tag = numberValue === 2e308 ? 'INFINITY' : 'NUMBER';
+ this.token(tag, number, 0, lexedLength);
+ return lexedLength;
+ };
+
+ Lexer.prototype.stringToken = function() {
+ var $, attempt, delimiter, doc, end, heredoc, i, indent, indentRegex, match, quote, ref2, ref3, regex, token, tokens;
+ quote = (STRING_START.exec(this.chunk) || [])[0];
+ if (!quote) {
+ return 0;
+ }
+ if (this.tokens.length && this.value() === 'from' && (this.seenImport || this.seenExport)) {
+ this.tokens[this.tokens.length - 1][0] = 'FROM';
+ }
+ regex = (function() {
+ switch (quote) {
+ case "'":
+ return STRING_SINGLE;
+ case '"':
+ return STRING_DOUBLE;
+ case "'''":
+ return HEREDOC_SINGLE;
+ case '"""':
+ return HEREDOC_DOUBLE;
+ }
+ })();
+ heredoc = quote.length === 3;
+ ref2 = this.matchWithInterpolations(regex, quote), tokens = ref2.tokens, end = ref2.index;
+ $ = tokens.length - 1;
+ delimiter = quote.charAt(0);
+ if (heredoc) {
+ indent = null;
+ doc = ((function() {
+ var j, len, results;
+ results = [];
+ for (i = j = 0, len = tokens.length; j < len; i = ++j) {
+ token = tokens[i];
+ if (token[0] === 'NEOSTRING') {
+ results.push(token[1]);
+ }
+ }
+ return results;
+ })()).join('#{}');
+ while (match = HEREDOC_INDENT.exec(doc)) {
+ attempt = match[1];
+ if (indent === null || (0 < (ref3 = attempt.length) && ref3 < indent.length)) {
+ indent = attempt;
+ }
+ }
+ if (indent) {
+ indentRegex = RegExp("\\n" + indent, "g");
+ }
+ this.mergeInterpolationTokens(tokens, {
+ delimiter: delimiter
+ }, (function(_this) {
+ return function(value, i) {
+ value = _this.formatString(value, {
+ delimiter: quote
+ });
+ if (indentRegex) {
+ value = value.replace(indentRegex, '\n');
+ }
+ if (i === 0) {
+ value = value.replace(LEADING_BLANK_LINE, '');
+ }
+ if (i === $) {
+ value = value.replace(TRAILING_BLANK_LINE, '');
+ }
+ return value;
+ };
+ })(this));
+ } else {
+ this.mergeInterpolationTokens(tokens, {
+ delimiter: delimiter
+ }, (function(_this) {
+ return function(value, i) {
+ value = _this.formatString(value, {
+ delimiter: quote
+ });
+ value = value.replace(SIMPLE_STRING_OMIT, function(match, offset) {
+ if ((i === 0 && offset === 0) || (i === $ && offset + match.length === value.length)) {
+ return '';
+ } else {
+ return ' ';
+ }
+ });
+ return value;
+ };
+ })(this));
+ }
+ return end;
+ };
+
+ Lexer.prototype.commentToken = function() {
+ var comment, here, match;
+ if (!(match = this.chunk.match(COMMENT))) {
+ return 0;
+ }
+ comment = match[0], here = match[1];
+ if (here) {
+ if (match = HERECOMMENT_ILLEGAL.exec(comment)) {
+ this.error("block comments cannot contain " + match[0], {
+ offset: match.index,
+ length: match[0].length
+ });
+ }
+ if (here.indexOf('\n') >= 0) {
+ here = here.replace(RegExp("\\n" + (repeat(' ', this.indent)), "g"), '\n');
+ }
+ this.token('HERECOMMENT', here, 0, comment.length);
+ }
+ return comment.length;
+ };
+
+ Lexer.prototype.jsToken = function() {
+ var match, script;
+ if (!(this.chunk.charAt(0) === '`' && (match = HERE_JSTOKEN.exec(this.chunk) || JSTOKEN.exec(this.chunk)))) {
+ return 0;
+ }
+ script = match[1].replace(/\\+(`|$)/g, function(string) {
+ return string.slice(-Math.ceil(string.length / 2));
+ });
+ this.token('JS', script, 0, match[0].length);
+ return match[0].length;
+ };
+
+ Lexer.prototype.regexToken = function() {
+ var body, closed, end, flags, index, match, origin, prev, ref2, ref3, ref4, regex, tokens;
+ switch (false) {
+ case !(match = REGEX_ILLEGAL.exec(this.chunk)):
+ this.error("regular expressions cannot begin with " + match[2], {
+ offset: match.index + match[1].length
+ });
+ break;
+ case !(match = this.matchWithInterpolations(HEREGEX, '///')):
+ tokens = match.tokens, index = match.index;
+ break;
+ case !(match = REGEX.exec(this.chunk)):
+ regex = match[0], body = match[1], closed = match[2];
+ this.validateEscapes(body, {
+ isRegex: true,
+ offsetInChunk: 1
+ });
+ body = this.formatRegex(body, {
+ delimiter: '/'
+ });
+ index = regex.length;
+ ref2 = this.tokens, prev = ref2[ref2.length - 1];
+ if (prev) {
+ if (prev.spaced && (ref3 = prev[0], indexOf.call(CALLABLE, ref3) >= 0)) {
+ if (!closed || POSSIBLY_DIVISION.test(regex)) {
+ return 0;
+ }
+ } else if (ref4 = prev[0], indexOf.call(NOT_REGEX, ref4) >= 0) {
+ return 0;
+ }
+ }
+ if (!closed) {
+ this.error('missing / (unclosed regex)');
+ }
+ break;
+ default:
+ return 0;
+ }
+ flags = REGEX_FLAGS.exec(this.chunk.slice(index))[0];
+ end = index + flags.length;
+ origin = this.makeToken('REGEX', null, 0, end);
+ switch (false) {
+ case !!VALID_FLAGS.test(flags):
+ this.error("invalid regular expression flags " + flags, {
+ offset: index,
+ length: flags.length
+ });
+ break;
+ case !(regex || tokens.length === 1):
+ if (body == null) {
+ body = this.formatHeregex(tokens[0][1]);
+ }
+ this.token('REGEX', "" + (this.makeDelimitedLiteral(body, {
+ delimiter: '/'
+ })) + flags, 0, end, origin);
+ break;
+ default:
+ this.token('REGEX_START', '(', 0, 0, origin);
+ this.token('IDENTIFIER', 'RegExp', 0, 0);
+ this.token('CALL_START', '(', 0, 0);
+ this.mergeInterpolationTokens(tokens, {
+ delimiter: '"',
+ double: true
+ }, this.formatHeregex);
+ if (flags) {
+ this.token(',', ',', index - 1, 0);
+ this.token('STRING', '"' + flags + '"', index - 1, flags.length);
+ }
+ this.token(')', ')', end - 1, 0);
+ this.token('REGEX_END', ')', end - 1, 0);
+ }
+ return end;
+ };
+
+ Lexer.prototype.lineToken = function() {
+ var diff, indent, match, noNewlines, size;
+ if (!(match = MULTI_DENT.exec(this.chunk))) {
+ return 0;
+ }
+ indent = match[0];
+ this.seenFor = false;
+ if (!this.importSpecifierList) {
+ this.seenImport = false;
+ }
+ if (!this.exportSpecifierList) {
+ this.seenExport = false;
+ }
+ size = indent.length - 1 - indent.lastIndexOf('\n');
+ noNewlines = this.unfinished();
+ if (size - this.indebt === this.indent) {
+ if (noNewlines) {
+ this.suppressNewlines();
+ } else {
+ this.newlineToken(0);
+ }
+ return indent.length;
+ }
+ if (size > this.indent) {
+ if (noNewlines) {
+ this.indebt = size - this.indent;
+ this.suppressNewlines();
+ return indent.length;
+ }
+ if (!this.tokens.length) {
+ this.baseIndent = this.indent = size;
+ return indent.length;
+ }
+ diff = size - this.indent + this.outdebt;
+ this.token('INDENT', diff, indent.length - size, size);
+ this.indents.push(diff);
+ this.ends.push({
+ tag: 'OUTDENT'
+ });
+ this.outdebt = this.indebt = 0;
+ this.indent = size;
+ } else if (size < this.baseIndent) {
+ this.error('missing indentation', {
+ offset: indent.length
+ });
+ } else {
+ this.indebt = 0;
+ this.outdentToken(this.indent - size, noNewlines, indent.length);
+ }
+ return indent.length;
+ };
+
+ Lexer.prototype.outdentToken = function(moveOut, noNewlines, outdentLength) {
+ var decreasedIndent, dent, lastIndent, ref2;
+ decreasedIndent = this.indent - moveOut;
+ while (moveOut > 0) {
+ lastIndent = this.indents[this.indents.length - 1];
+ if (!lastIndent) {
+ moveOut = 0;
+ } else if (lastIndent === this.outdebt) {
+ moveOut -= this.outdebt;
+ this.outdebt = 0;
+ } else if (lastIndent < this.outdebt) {
+ this.outdebt -= lastIndent;
+ moveOut -= lastIndent;
+ } else {
+ dent = this.indents.pop() + this.outdebt;
+ if (outdentLength && (ref2 = this.chunk[outdentLength], indexOf.call(INDENTABLE_CLOSERS, ref2) >= 0)) {
+ decreasedIndent -= dent - moveOut;
+ moveOut = dent;
+ }
+ this.outdebt = 0;
+ this.pair('OUTDENT');
+ this.token('OUTDENT', moveOut, 0, outdentLength);
+ moveOut -= dent;
+ }
+ }
+ if (dent) {
+ this.outdebt -= moveOut;
+ }
+ while (this.value() === ';') {
+ this.tokens.pop();
+ }
+ if (!(this.tag() === 'TERMINATOR' || noNewlines)) {
+ this.token('TERMINATOR', '\n', outdentLength, 0);
+ }
+ this.indent = decreasedIndent;
+ return this;
+ };
+
+ Lexer.prototype.whitespaceToken = function() {
+ var match, nline, prev, ref2;
+ if (!((match = WHITESPACE.exec(this.chunk)) || (nline = this.chunk.charAt(0) === '\n'))) {
+ return 0;
+ }
+ ref2 = this.tokens, prev = ref2[ref2.length - 1];
+ if (prev) {
+ prev[match ? 'spaced' : 'newLine'] = true;
+ }
+ if (match) {
+ return match[0].length;
+ } else {
+ return 0;
+ }
+ };
+
+ Lexer.prototype.newlineToken = function(offset) {
+ while (this.value() === ';') {
+ this.tokens.pop();
+ }
+ if (this.tag() !== 'TERMINATOR') {
+ this.token('TERMINATOR', '\n', offset, 0);
+ }
+ return this;
+ };
+
+ Lexer.prototype.suppressNewlines = function() {
+ if (this.value() === '\\') {
+ this.tokens.pop();
+ }
+ return this;
+ };
+
+ Lexer.prototype.literalToken = function() {
+ var match, message, origin, prev, ref2, ref3, ref4, ref5, ref6, skipToken, tag, token, value;
+ if (match = OPERATOR.exec(this.chunk)) {
+ value = match[0];
+ if (CODE.test(value)) {
+ this.tagParameters();
+ }
+ } else {
+ value = this.chunk.charAt(0);
+ }
+ tag = value;
+ ref2 = this.tokens, prev = ref2[ref2.length - 1];
+ if (prev && indexOf.call(['='].concat(slice.call(COMPOUND_ASSIGN)), value) >= 0) {
+ skipToken = false;
+ if (value === '=' && ((ref3 = prev[1]) === '||' || ref3 === '&&') && !prev.spaced) {
+ prev[0] = 'COMPOUND_ASSIGN';
+ prev[1] += '=';
+ prev = this.tokens[this.tokens.length - 2];
+ skipToken = true;
+ }
+ if (prev && prev[0] !== 'PROPERTY') {
+ origin = (ref4 = prev.origin) != null ? ref4 : prev;
+ message = isUnassignable(prev[1], origin[1]);
+ if (message) {
+ this.error(message, origin[2]);
+ }
+ }
+ if (skipToken) {
+ return value.length;
+ }
+ }
+ if (value === '{' && this.seenImport) {
+ this.importSpecifierList = true;
+ } else if (this.importSpecifierList && value === '}') {
+ this.importSpecifierList = false;
+ } else if (value === '{' && (prev != null ? prev[0] : void 0) === 'EXPORT') {
+ this.exportSpecifierList = true;
+ } else if (this.exportSpecifierList && value === '}') {
+ this.exportSpecifierList = false;
+ }
+ if (value === ';') {
+ this.seenFor = this.seenImport = this.seenExport = false;
+ tag = 'TERMINATOR';
+ } else if (value === '*' && prev[0] === 'EXPORT') {
+ tag = 'EXPORT_ALL';
+ } else if (indexOf.call(MATH, value) >= 0) {
+ tag = 'MATH';
+ } else if (indexOf.call(COMPARE, value) >= 0) {
+ tag = 'COMPARE';
+ } else if (indexOf.call(COMPOUND_ASSIGN, value) >= 0) {
+ tag = 'COMPOUND_ASSIGN';
+ } else if (indexOf.call(UNARY, value) >= 0) {
+ tag = 'UNARY';
+ } else if (indexOf.call(UNARY_MATH, value) >= 0) {
+ tag = 'UNARY_MATH';
+ } else if (indexOf.call(SHIFT, value) >= 0) {
+ tag = 'SHIFT';
+ } else if (value === '?' && (prev != null ? prev.spaced : void 0)) {
+ tag = 'BIN?';
+ } else if (prev && !prev.spaced) {
+ if (value === '(' && (ref5 = prev[0], indexOf.call(CALLABLE, ref5) >= 0)) {
+ if (prev[0] === '?') {
+ prev[0] = 'FUNC_EXIST';
+ }
+ tag = 'CALL_START';
+ } else if (value === '[' && (ref6 = prev[0], indexOf.call(INDEXABLE, ref6) >= 0)) {
+ tag = 'INDEX_START';
+ switch (prev[0]) {
+ case '?':
+ prev[0] = 'INDEX_SOAK';
+ }
+ }
+ }
+ token = this.makeToken(tag, value);
+ switch (value) {
+ case '(':
+ case '{':
+ case '[':
+ this.ends.push({
+ tag: INVERSES[value],
+ origin: token
+ });
+ break;
+ case ')':
+ case '}':
+ case ']':
+ this.pair(value);
+ }
+ this.tokens.push(token);
+ return value.length;
+ };
+
+ Lexer.prototype.tagParameters = function() {
+ var i, stack, tok, tokens;
+ if (this.tag() !== ')') {
+ return this;
+ }
+ stack = [];
+ tokens = this.tokens;
+ i = tokens.length;
+ tokens[--i][0] = 'PARAM_END';
+ while (tok = tokens[--i]) {
+ switch (tok[0]) {
+ case ')':
+ stack.push(tok);
+ break;
+ case '(':
+ case 'CALL_START':
+ if (stack.length) {
+ stack.pop();
+ } else if (tok[0] === '(') {
+ tok[0] = 'PARAM_START';
+ return this;
+ } else {
+ return this;
+ }
+ }
+ }
+ return this;
+ };
+
+ Lexer.prototype.closeIndentation = function() {
+ return this.outdentToken(this.indent);
+ };
+
+ Lexer.prototype.matchWithInterpolations = function(regex, delimiter) {
+ var close, column, firstToken, index, lastToken, line, nested, offsetInChunk, open, ref2, ref3, ref4, str, strPart, tokens;
+ tokens = [];
+ offsetInChunk = delimiter.length;
+ if (this.chunk.slice(0, offsetInChunk) !== delimiter) {
+ return null;
+ }
+ str = this.chunk.slice(offsetInChunk);
+ while (true) {
+ strPart = regex.exec(str)[0];
+ this.validateEscapes(strPart, {
+ isRegex: delimiter.charAt(0) === '/',
+ offsetInChunk: offsetInChunk
+ });
+ tokens.push(this.makeToken('NEOSTRING', strPart, offsetInChunk));
+ str = str.slice(strPart.length);
+ offsetInChunk += strPart.length;
+ if (str.slice(0, 2) !== '#{') {
+ break;
+ }
+ ref2 = this.getLineAndColumnFromChunk(offsetInChunk + 1), line = ref2[0], column = ref2[1];
+ ref3 = new Lexer().tokenize(str.slice(1), {
+ line: line,
+ column: column,
+ untilBalanced: true
+ }), nested = ref3.tokens, index = ref3.index;
+ index += 1;
+ open = nested[0], close = nested[nested.length - 1];
+ open[0] = open[1] = '(';
+ close[0] = close[1] = ')';
+ close.origin = ['', 'end of interpolation', close[2]];
+ if (((ref4 = nested[1]) != null ? ref4[0] : void 0) === 'TERMINATOR') {
+ nested.splice(1, 1);
+ }
+ tokens.push(['TOKENS', nested]);
+ str = str.slice(index);
+ offsetInChunk += index;
+ }
+ if (str.slice(0, delimiter.length) !== delimiter) {
+ this.error("missing " + delimiter, {
+ length: delimiter.length
+ });
+ }
+ firstToken = tokens[0], lastToken = tokens[tokens.length - 1];
+ firstToken[2].first_column -= delimiter.length;
+ if (lastToken[1].substr(-1) === '\n') {
+ lastToken[2].last_line += 1;
+ lastToken[2].last_column = delimiter.length - 1;
+ } else {
+ lastToken[2].last_column += delimiter.length;
+ }
+ if (lastToken[1].length === 0) {
+ lastToken[2].last_column -= 1;
+ }
+ return {
+ tokens: tokens,
+ index: offsetInChunk + delimiter.length
+ };
+ };
+
+ Lexer.prototype.mergeInterpolationTokens = function(tokens, options, fn) {
+ var converted, firstEmptyStringIndex, firstIndex, i, j, lastToken, len, locationToken, lparen, plusToken, ref2, rparen, tag, token, tokensToPush, value;
+ if (tokens.length > 1) {
+ lparen = this.token('STRING_START', '(', 0, 0);
+ }
+ firstIndex = this.tokens.length;
+ for (i = j = 0, len = tokens.length; j < len; i = ++j) {
+ token = tokens[i];
+ tag = token[0], value = token[1];
+ switch (tag) {
+ case 'TOKENS':
+ if (value.length === 2) {
+ continue;
+ }
+ locationToken = value[0];
+ tokensToPush = value;
+ break;
+ case 'NEOSTRING':
+ converted = fn.call(this, token[1], i);
+ if (converted.length === 0) {
+ if (i === 0) {
+ firstEmptyStringIndex = this.tokens.length;
+ } else {
+ continue;
+ }
+ }
+ if (i === 2 && (firstEmptyStringIndex != null)) {
+ this.tokens.splice(firstEmptyStringIndex, 2);
+ }
+ token[0] = 'STRING';
+ token[1] = this.makeDelimitedLiteral(converted, options);
+ locationToken = token;
+ tokensToPush = [token];
+ }
+ if (this.tokens.length > firstIndex) {
+ plusToken = this.token('+', '+');
+ plusToken[2] = {
+ first_line: locationToken[2].first_line,
+ first_column: locationToken[2].first_column,
+ last_line: locationToken[2].first_line,
+ last_column: locationToken[2].first_column
+ };
+ }
+ (ref2 = this.tokens).push.apply(ref2, tokensToPush);
+ }
+ if (lparen) {
+ lastToken = tokens[tokens.length - 1];
+ lparen.origin = [
+ 'STRING', null, {
+ first_line: lparen[2].first_line,
+ first_column: lparen[2].first_column,
+ last_line: lastToken[2].last_line,
+ last_column: lastToken[2].last_column
+ }
+ ];
+ rparen = this.token('STRING_END', ')');
+ return rparen[2] = {
+ first_line: lastToken[2].last_line,
+ first_column: lastToken[2].last_column,
+ last_line: lastToken[2].last_line,
+ last_column: lastToken[2].last_column
+ };
+ }
+ };
+
+ Lexer.prototype.pair = function(tag) {
+ var lastIndent, prev, ref2, ref3, wanted;
+ ref2 = this.ends, prev = ref2[ref2.length - 1];
+ if (tag !== (wanted = prev != null ? prev.tag : void 0)) {
+ if ('OUTDENT' !== wanted) {
+ this.error("unmatched " + tag);
+ }
+ ref3 = this.indents, lastIndent = ref3[ref3.length - 1];
+ this.outdentToken(lastIndent, true);
+ return this.pair(tag);
+ }
+ return this.ends.pop();
+ };
+
+ Lexer.prototype.getLineAndColumnFromChunk = function(offset) {
+ var column, lastLine, lineCount, ref2, string;
+ if (offset === 0) {
+ return [this.chunkLine, this.chunkColumn];
+ }
+ if (offset >= this.chunk.length) {
+ string = this.chunk;
+ } else {
+ string = this.chunk.slice(0, +(offset - 1) + 1 || 9e9);
+ }
+ lineCount = count(string, '\n');
+ column = this.chunkColumn;
+ if (lineCount > 0) {
+ ref2 = string.split('\n'), lastLine = ref2[ref2.length - 1];
+ column = lastLine.length;
+ } else {
+ column += string.length;
+ }
+ return [this.chunkLine + lineCount, column];
+ };
+
+ Lexer.prototype.makeToken = function(tag, value, offsetInChunk, length) {
+ var lastCharacter, locationData, ref2, ref3, token;
+ if (offsetInChunk == null) {
+ offsetInChunk = 0;
+ }
+ if (length == null) {
+ length = value.length;
+ }
+ locationData = {};
+ ref2 = this.getLineAndColumnFromChunk(offsetInChunk), locationData.first_line = ref2[0], locationData.first_column = ref2[1];
+ lastCharacter = length > 0 ? length - 1 : 0;
+ ref3 = this.getLineAndColumnFromChunk(offsetInChunk + lastCharacter), locationData.last_line = ref3[0], locationData.last_column = ref3[1];
+ token = [tag, value, locationData];
+ return token;
+ };
+
+ Lexer.prototype.token = function(tag, value, offsetInChunk, length, origin) {
+ var token;
+ token = this.makeToken(tag, value, offsetInChunk, length);
+ if (origin) {
+ token.origin = origin;
+ }
+ this.tokens.push(token);
+ return token;
+ };
+
+ Lexer.prototype.tag = function() {
+ var ref2, token;
+ ref2 = this.tokens, token = ref2[ref2.length - 1];
+ return token != null ? token[0] : void 0;
+ };
+
+ Lexer.prototype.value = function() {
+ var ref2, token;
+ ref2 = this.tokens, token = ref2[ref2.length - 1];
+ return token != null ? token[1] : void 0;
+ };
+
+ Lexer.prototype.unfinished = function() {
+ var ref2;
+ return LINE_CONTINUER.test(this.chunk) || (ref2 = this.tag(), indexOf.call(UNFINISHED, ref2) >= 0);
+ };
+
+ Lexer.prototype.formatString = function(str, options) {
+ return this.replaceUnicodeCodePointEscapes(str.replace(STRING_OMIT, '$1'), options);
+ };
+
+ Lexer.prototype.formatHeregex = function(str) {
+ return this.formatRegex(str.replace(HEREGEX_OMIT, '$1$2'), {
+ delimiter: '///'
+ });
+ };
+
+ Lexer.prototype.formatRegex = function(str, options) {
+ return this.replaceUnicodeCodePointEscapes(str, options);
+ };
+
+ Lexer.prototype.unicodeCodePointToUnicodeEscapes = function(codePoint) {
+ var high, low, toUnicodeEscape;
+ toUnicodeEscape = function(val) {
+ var str;
+ str = val.toString(16);
+ return "\\u" + (repeat('0', 4 - str.length)) + str;
+ };
+ if (codePoint < 0x10000) {
+ return toUnicodeEscape(codePoint);
+ }
+ high = Math.floor((codePoint - 0x10000) / 0x400) + 0xD800;
+ low = (codePoint - 0x10000) % 0x400 + 0xDC00;
+ return "" + (toUnicodeEscape(high)) + (toUnicodeEscape(low));
+ };
+
+ Lexer.prototype.replaceUnicodeCodePointEscapes = function(str, options) {
+ return str.replace(UNICODE_CODE_POINT_ESCAPE, (function(_this) {
+ return function(match, escapedBackslash, codePointHex, offset) {
+ var codePointDecimal;
+ if (escapedBackslash) {
+ return escapedBackslash;
+ }
+ codePointDecimal = parseInt(codePointHex, 16);
+ if (codePointDecimal > 0x10ffff) {
+ _this.error("unicode code point escapes greater than \\u{10ffff} are not allowed", {
+ offset: offset + options.delimiter.length,
+ length: codePointHex.length + 4
+ });
+ }
+ return _this.unicodeCodePointToUnicodeEscapes(codePointDecimal);
+ };
+ })(this));
+ };
+
+ Lexer.prototype.validateEscapes = function(str, options) {
+ var before, hex, invalidEscape, invalidEscapeRegex, match, message, octal, ref2, unicode, unicodeCodePoint;
+ if (options == null) {
+ options = {};
+ }
+ invalidEscapeRegex = options.isRegex ? REGEX_INVALID_ESCAPE : STRING_INVALID_ESCAPE;
+ match = invalidEscapeRegex.exec(str);
+ if (!match) {
+ return;
+ }
+ match[0], before = match[1], octal = match[2], hex = match[3], unicodeCodePoint = match[4], unicode = match[5];
+ message = octal ? "octal escape sequences are not allowed" : "invalid escape sequence";
+ invalidEscape = "\\" + (octal || hex || unicodeCodePoint || unicode);
+ return this.error(message + " " + invalidEscape, {
+ offset: ((ref2 = options.offsetInChunk) != null ? ref2 : 0) + match.index + before.length,
+ length: invalidEscape.length
+ });
+ };
+
+ Lexer.prototype.makeDelimitedLiteral = function(body, options) {
+ var regex;
+ if (options == null) {
+ options = {};
+ }
+ if (body === '' && options.delimiter === '/') {
+ body = '(?:)';
+ }
+ regex = RegExp("(\\\\\\\\)|(\\\\0(?=[1-7]))|\\\\?(" + options.delimiter + ")|\\\\?(?:(\\n)|(\\r)|(\\u2028)|(\\u2029))|(\\\\.)", "g");
+ body = body.replace(regex, function(match, backslash, nul, delimiter, lf, cr, ls, ps, other) {
+ switch (false) {
+ case !backslash:
+ if (options.double) {
+ return backslash + backslash;
+ } else {
+ return backslash;
+ }
+ case !nul:
+ return '\\x00';
+ case !delimiter:
+ return "\\" + delimiter;
+ case !lf:
+ return '\\n';
+ case !cr:
+ return '\\r';
+ case !ls:
+ return '\\u2028';
+ case !ps:
+ return '\\u2029';
+ case !other:
+ if (options.double) {
+ return "\\" + other;
+ } else {
+ return other;
+ }
+ }
+ });
+ return "" + options.delimiter + body + options.delimiter;
+ };
+
+ Lexer.prototype.error = function(message, options) {
+ var first_column, first_line, location, ref2, ref3, ref4;
+ if (options == null) {
+ options = {};
+ }
+ location = 'first_line' in options ? options : ((ref3 = this.getLineAndColumnFromChunk((ref2 = options.offset) != null ? ref2 : 0), first_line = ref3[0], first_column = ref3[1], ref3), {
+ first_line: first_line,
+ first_column: first_column,
+ last_column: first_column + ((ref4 = options.length) != null ? ref4 : 1) - 1
+ });
+ return throwSyntaxError(message, location);
+ };
+
+ return Lexer;
+
+ })();
+
+ isUnassignable = function(name, displayName) {
+ if (displayName == null) {
+ displayName = name;
+ }
+ switch (false) {
+ case indexOf.call(slice.call(JS_KEYWORDS).concat(slice.call(COFFEE_KEYWORDS)), name) < 0:
+ return "keyword '" + displayName + "' can't be assigned";
+ case indexOf.call(STRICT_PROSCRIBED, name) < 0:
+ return "'" + displayName + "' can't be assigned";
+ case indexOf.call(RESERVED, name) < 0:
+ return "reserved word '" + displayName + "' can't be assigned";
+ default:
+ return false;
+ }
+ };
+
+ exports.isUnassignable = isUnassignable;
+
+ isForFrom = function(prev) {
+ var ref2;
+ if (prev[0] === 'IDENTIFIER') {
+ if (prev[1] === 'from') {
+ prev[1][0] = 'IDENTIFIER';
+ true;
+ }
+ return true;
+ } else if (prev[0] === 'FOR') {
+ return false;
+ } else if ((ref2 = prev[1]) === '{' || ref2 === '[' || ref2 === ',' || ref2 === ':') {
+ return false;
+ } else {
+ return true;
+ }
+ };
+
+ JS_KEYWORDS = ['true', 'false', 'null', 'this', 'new', 'delete', 'typeof', 'in', 'instanceof', 'return', 'throw', 'break', 'continue', 'debugger', 'yield', 'if', 'else', 'switch', 'for', 'while', 'do', 'try', 'catch', 'finally', 'class', 'extends', 'super', 'import', 'export', 'default'];
+
+ COFFEE_KEYWORDS = ['undefined', 'Infinity', 'NaN', 'then', 'unless', 'until', 'loop', 'of', 'by', 'when'];
+
+ COFFEE_ALIAS_MAP = {
+ and: '&&',
+ or: '||',
+ is: '==',
+ isnt: '!=',
+ not: '!',
+ yes: 'true',
+ no: 'false',
+ on: 'true',
+ off: 'false'
+ };
+
+ COFFEE_ALIASES = (function() {
+ var results;
+ results = [];
+ for (key in COFFEE_ALIAS_MAP) {
+ results.push(key);
+ }
+ return results;
+ })();
+
+ COFFEE_KEYWORDS = COFFEE_KEYWORDS.concat(COFFEE_ALIASES);
+
+ RESERVED = ['case', 'function', 'var', 'void', 'with', 'const', 'let', 'enum', 'native', 'implements', 'interface', 'package', 'private', 'protected', 'public', 'static'];
+
+ STRICT_PROSCRIBED = ['arguments', 'eval'];
+
+ exports.JS_FORBIDDEN = JS_KEYWORDS.concat(RESERVED).concat(STRICT_PROSCRIBED);
+
+ BOM = 65279;
+
+ IDENTIFIER = /^(?!\d)((?:(?!\s)[$\w\x7f-\uffff])+)([^\n\S]*:(?!:))?/;
+
+ NUMBER = /^0b[01]+|^0o[0-7]+|^0x[\da-f]+|^\d*\.?\d+(?:e[+-]?\d+)?/i;
+
+ OPERATOR = /^(?:[-=]>|[-+*\/%<>&|^!?=]=|>>>=?|([-+:])\1|([&|<>*\/%])\2=?|\?(\.|::)|\.{2,3})/;
+
+ WHITESPACE = /^[^\n\S]+/;
+
+ COMMENT = /^###([^#][\s\S]*?)(?:###[^\n\S]*|###$)|^(?:\s*#(?!##[^#]).*)+/;
+
+ CODE = /^[-=]>/;
+
+ MULTI_DENT = /^(?:\n[^\n\S]*)+/;
+
+ JSTOKEN = /^`(?!``)((?:[^`\\]|\\[\s\S])*)`/;
+
+ HERE_JSTOKEN = /^```((?:[^`\\]|\\[\s\S]|`(?!``))*)```/;
+
+ STRING_START = /^(?:'''|"""|'|")/;
+
+ STRING_SINGLE = /^(?:[^\\']|\\[\s\S])*/;
+
+ STRING_DOUBLE = /^(?:[^\\"#]|\\[\s\S]|\#(?!\{))*/;
+
+ HEREDOC_SINGLE = /^(?:[^\\']|\\[\s\S]|'(?!''))*/;
+
+ HEREDOC_DOUBLE = /^(?:[^\\"#]|\\[\s\S]|"(?!"")|\#(?!\{))*/;
+
+ STRING_OMIT = /((?:\\\\)+)|\\[^\S\n]*\n\s*/g;
+
+ SIMPLE_STRING_OMIT = /\s*\n\s*/g;
+
+ HEREDOC_INDENT = /\n+([^\n\S]*)(?=\S)/g;
+
+ REGEX = /^\/(?!\/)((?:[^[\/\n\\]|\\[^\n]|\[(?:\\[^\n]|[^\]\n\\])*\])*)(\/)?/;
+
+ REGEX_FLAGS = /^\w*/;
+
+ VALID_FLAGS = /^(?!.*(.).*\1)[imguy]*$/;
+
+ HEREGEX = /^(?:[^\\\/#]|\\[\s\S]|\/(?!\/\/)|\#(?!\{))*/;
+
+ HEREGEX_OMIT = /((?:\\\\)+)|\\(\s)|\s+(?:#.*)?/g;
+
+ REGEX_ILLEGAL = /^(\/|\/{3}\s*)(\*)/;
+
+ POSSIBLY_DIVISION = /^\/=?\s/;
+
+ HERECOMMENT_ILLEGAL = /\*\//;
+
+ LINE_CONTINUER = /^\s*(?:,|\??\.(?![.\d])|::)/;
+
+ STRING_INVALID_ESCAPE = /((?:^|[^\\])(?:\\\\)*)\\(?:(0[0-7]|[1-7])|(x(?![\da-fA-F]{2}).{0,2})|(u\{(?![\da-fA-F]{1,}\})[^}]*\}?)|(u(?!\{|[\da-fA-F]{4}).{0,4}))/;
+
+ REGEX_INVALID_ESCAPE = /((?:^|[^\\])(?:\\\\)*)\\(?:(0[0-7])|(x(?![\da-fA-F]{2}).{0,2})|(u\{(?![\da-fA-F]{1,}\})[^}]*\}?)|(u(?!\{|[\da-fA-F]{4}).{0,4}))/;
+
+ UNICODE_CODE_POINT_ESCAPE = /(\\\\)|\\u\{([\da-fA-F]+)\}/g;
+
+ LEADING_BLANK_LINE = /^[^\n\S]*\n/;
+
+ TRAILING_BLANK_LINE = /\n[^\n\S]*$/;
+
+ TRAILING_SPACES = /\s+$/;
+
+ COMPOUND_ASSIGN = ['-=', '+=', '/=', '*=', '%=', '||=', '&&=', '?=', '<<=', '>>=', '>>>=', '&=', '^=', '|=', '**=', '//=', '%%='];
+
+ UNARY = ['NEW', 'TYPEOF', 'DELETE', 'DO'];
+
+ UNARY_MATH = ['!', '~'];
+
+ SHIFT = ['<<', '>>', '>>>'];
+
+ COMPARE = ['==', '!=', '<', '>', '<=', '>='];
+
+ MATH = ['*', '/', '%', '//', '%%'];
+
+ RELATION = ['IN', 'OF', 'INSTANCEOF'];
+
+ BOOL = ['TRUE', 'FALSE'];
+
+ CALLABLE = ['IDENTIFIER', 'PROPERTY', ')', ']', '?', '@', 'THIS', 'SUPER'];
+
+ INDEXABLE = CALLABLE.concat(['NUMBER', 'INFINITY', 'NAN', 'STRING', 'STRING_END', 'REGEX', 'REGEX_END', 'BOOL', 'NULL', 'UNDEFINED', '}', '::']);
+
+ NOT_REGEX = INDEXABLE.concat(['++', '--']);
+
+ LINE_BREAK = ['INDENT', 'OUTDENT', 'TERMINATOR'];
+
+ INDENTABLE_CLOSERS = [')', '}', ']'];
+
+ UNFINISHED = ['\\', '.', '?.', '?::', 'UNARY', 'MATH', 'UNARY_MATH', '+', '-', '**', 'SHIFT', 'RELATION', 'COMPARE', '&', '^', '|', '&&', '||', 'BIN?', 'THROW', 'EXTENDS', 'DEFAULT'];
+
+}).call(this);
diff --git a/modeshape-sample/node_modules/coffee-script/lib/coffee-script/nodes.js b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/nodes.js
new file mode 100644
index 0000000..f4d6479
--- /dev/null
+++ b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/nodes.js
@@ -0,0 +1,3899 @@
+// Generated by CoffeeScript 1.12.7
+(function() {
+ var Access, Arr, Assign, Base, Block, BooleanLiteral, Call, Class, Code, CodeFragment, Comment, Existence, Expansion, ExportAllDeclaration, ExportDeclaration, ExportDefaultDeclaration, ExportNamedDeclaration, ExportSpecifier, ExportSpecifierList, Extends, For, IdentifierLiteral, If, ImportClause, ImportDeclaration, ImportDefaultSpecifier, ImportNamespaceSpecifier, ImportSpecifier, ImportSpecifierList, In, Index, InfinityLiteral, JS_FORBIDDEN, LEVEL_ACCESS, LEVEL_COND, LEVEL_LIST, LEVEL_OP, LEVEL_PAREN, LEVEL_TOP, Literal, ModuleDeclaration, ModuleSpecifier, ModuleSpecifierList, NEGATE, NO, NaNLiteral, NullLiteral, NumberLiteral, Obj, Op, Param, Parens, PassthroughLiteral, PropertyName, Range, RegexLiteral, RegexWithInterpolations, Return, SIMPLENUM, Scope, Slice, Splat, StatementLiteral, StringLiteral, StringWithInterpolations, SuperCall, Switch, TAB, THIS, TaggedTemplateCall, ThisLiteral, Throw, Try, UTILITIES, UndefinedLiteral, Value, While, YES, YieldReturn, addLocationDataFn, compact, del, ends, extend, flatten, fragmentsToText, isComplexOrAssignable, isLiteralArguments, isLiteralThis, isUnassignable, locationDataToString, merge, multident, ref1, ref2, some, starts, throwSyntaxError, unfoldSoak, utility,
+ extend1 = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+ hasProp = {}.hasOwnProperty,
+ indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; },
+ slice = [].slice;
+
+ Error.stackTraceLimit = 2e308;
+
+ Scope = require('./scope').Scope;
+
+ ref1 = require('./lexer'), isUnassignable = ref1.isUnassignable, JS_FORBIDDEN = ref1.JS_FORBIDDEN;
+
+ ref2 = require('./helpers'), compact = ref2.compact, flatten = ref2.flatten, extend = ref2.extend, merge = ref2.merge, del = ref2.del, starts = ref2.starts, ends = ref2.ends, some = ref2.some, addLocationDataFn = ref2.addLocationDataFn, locationDataToString = ref2.locationDataToString, throwSyntaxError = ref2.throwSyntaxError;
+
+ exports.extend = extend;
+
+ exports.addLocationDataFn = addLocationDataFn;
+
+ YES = function() {
+ return true;
+ };
+
+ NO = function() {
+ return false;
+ };
+
+ THIS = function() {
+ return this;
+ };
+
+ NEGATE = function() {
+ this.negated = !this.negated;
+ return this;
+ };
+
+ exports.CodeFragment = CodeFragment = (function() {
+ function CodeFragment(parent, code) {
+ var ref3;
+ this.code = "" + code;
+ this.locationData = parent != null ? parent.locationData : void 0;
+ this.type = (parent != null ? (ref3 = parent.constructor) != null ? ref3.name : void 0 : void 0) || 'unknown';
+ }
+
+ CodeFragment.prototype.toString = function() {
+ return "" + this.code + (this.locationData ? ": " + locationDataToString(this.locationData) : '');
+ };
+
+ return CodeFragment;
+
+ })();
+
+ fragmentsToText = function(fragments) {
+ var fragment;
+ return ((function() {
+ var j, len1, results;
+ results = [];
+ for (j = 0, len1 = fragments.length; j < len1; j++) {
+ fragment = fragments[j];
+ results.push(fragment.code);
+ }
+ return results;
+ })()).join('');
+ };
+
+ exports.Base = Base = (function() {
+ function Base() {}
+
+ Base.prototype.compile = function(o, lvl) {
+ return fragmentsToText(this.compileToFragments(o, lvl));
+ };
+
+ Base.prototype.compileToFragments = function(o, lvl) {
+ var node;
+ o = extend({}, o);
+ if (lvl) {
+ o.level = lvl;
+ }
+ node = this.unfoldSoak(o) || this;
+ node.tab = o.indent;
+ if (o.level === LEVEL_TOP || !node.isStatement(o)) {
+ return node.compileNode(o);
+ } else {
+ return node.compileClosure(o);
+ }
+ };
+
+ Base.prototype.compileClosure = function(o) {
+ var args, argumentsNode, func, jumpNode, meth, parts, ref3;
+ if (jumpNode = this.jumps()) {
+ jumpNode.error('cannot use a pure statement in an expression');
+ }
+ o.sharedScope = true;
+ func = new Code([], Block.wrap([this]));
+ args = [];
+ if ((argumentsNode = this.contains(isLiteralArguments)) || this.contains(isLiteralThis)) {
+ args = [new ThisLiteral];
+ if (argumentsNode) {
+ meth = 'apply';
+ args.push(new IdentifierLiteral('arguments'));
+ } else {
+ meth = 'call';
+ }
+ func = new Value(func, [new Access(new PropertyName(meth))]);
+ }
+ parts = (new Call(func, args)).compileNode(o);
+ if (func.isGenerator || ((ref3 = func.base) != null ? ref3.isGenerator : void 0)) {
+ parts.unshift(this.makeCode("(yield* "));
+ parts.push(this.makeCode(")"));
+ }
+ return parts;
+ };
+
+ Base.prototype.cache = function(o, level, isComplex) {
+ var complex, ref, sub;
+ complex = isComplex != null ? isComplex(this) : this.isComplex();
+ if (complex) {
+ ref = new IdentifierLiteral(o.scope.freeVariable('ref'));
+ sub = new Assign(ref, this);
+ if (level) {
+ return [sub.compileToFragments(o, level), [this.makeCode(ref.value)]];
+ } else {
+ return [sub, ref];
+ }
+ } else {
+ ref = level ? this.compileToFragments(o, level) : this;
+ return [ref, ref];
+ }
+ };
+
+ Base.prototype.cacheToCodeFragments = function(cacheValues) {
+ return [fragmentsToText(cacheValues[0]), fragmentsToText(cacheValues[1])];
+ };
+
+ Base.prototype.makeReturn = function(res) {
+ var me;
+ me = this.unwrapAll();
+ if (res) {
+ return new Call(new Literal(res + ".push"), [me]);
+ } else {
+ return new Return(me);
+ }
+ };
+
+ Base.prototype.contains = function(pred) {
+ var node;
+ node = void 0;
+ this.traverseChildren(false, function(n) {
+ if (pred(n)) {
+ node = n;
+ return false;
+ }
+ });
+ return node;
+ };
+
+ Base.prototype.lastNonComment = function(list) {
+ var i;
+ i = list.length;
+ while (i--) {
+ if (!(list[i] instanceof Comment)) {
+ return list[i];
+ }
+ }
+ return null;
+ };
+
+ Base.prototype.toString = function(idt, name) {
+ var tree;
+ if (idt == null) {
+ idt = '';
+ }
+ if (name == null) {
+ name = this.constructor.name;
+ }
+ tree = '\n' + idt + name;
+ if (this.soak) {
+ tree += '?';
+ }
+ this.eachChild(function(node) {
+ return tree += node.toString(idt + TAB);
+ });
+ return tree;
+ };
+
+ Base.prototype.eachChild = function(func) {
+ var attr, child, j, k, len1, len2, ref3, ref4;
+ if (!this.children) {
+ return this;
+ }
+ ref3 = this.children;
+ for (j = 0, len1 = ref3.length; j < len1; j++) {
+ attr = ref3[j];
+ if (this[attr]) {
+ ref4 = flatten([this[attr]]);
+ for (k = 0, len2 = ref4.length; k < len2; k++) {
+ child = ref4[k];
+ if (func(child) === false) {
+ return this;
+ }
+ }
+ }
+ }
+ return this;
+ };
+
+ Base.prototype.traverseChildren = function(crossScope, func) {
+ return this.eachChild(function(child) {
+ var recur;
+ recur = func(child);
+ if (recur !== false) {
+ return child.traverseChildren(crossScope, func);
+ }
+ });
+ };
+
+ Base.prototype.invert = function() {
+ return new Op('!', this);
+ };
+
+ Base.prototype.unwrapAll = function() {
+ var node;
+ node = this;
+ while (node !== (node = node.unwrap())) {
+ continue;
+ }
+ return node;
+ };
+
+ Base.prototype.children = [];
+
+ Base.prototype.isStatement = NO;
+
+ Base.prototype.jumps = NO;
+
+ Base.prototype.isComplex = YES;
+
+ Base.prototype.isChainable = NO;
+
+ Base.prototype.isAssignable = NO;
+
+ Base.prototype.isNumber = NO;
+
+ Base.prototype.unwrap = THIS;
+
+ Base.prototype.unfoldSoak = NO;
+
+ Base.prototype.assigns = NO;
+
+ Base.prototype.updateLocationDataIfMissing = function(locationData) {
+ if (this.locationData) {
+ return this;
+ }
+ this.locationData = locationData;
+ return this.eachChild(function(child) {
+ return child.updateLocationDataIfMissing(locationData);
+ });
+ };
+
+ Base.prototype.error = function(message) {
+ return throwSyntaxError(message, this.locationData);
+ };
+
+ Base.prototype.makeCode = function(code) {
+ return new CodeFragment(this, code);
+ };
+
+ Base.prototype.wrapInBraces = function(fragments) {
+ return [].concat(this.makeCode('('), fragments, this.makeCode(')'));
+ };
+
+ Base.prototype.joinFragmentArrays = function(fragmentsList, joinStr) {
+ var answer, fragments, i, j, len1;
+ answer = [];
+ for (i = j = 0, len1 = fragmentsList.length; j < len1; i = ++j) {
+ fragments = fragmentsList[i];
+ if (i) {
+ answer.push(this.makeCode(joinStr));
+ }
+ answer = answer.concat(fragments);
+ }
+ return answer;
+ };
+
+ return Base;
+
+ })();
+
+ exports.Block = Block = (function(superClass1) {
+ extend1(Block, superClass1);
+
+ function Block(nodes) {
+ this.expressions = compact(flatten(nodes || []));
+ }
+
+ Block.prototype.children = ['expressions'];
+
+ Block.prototype.push = function(node) {
+ this.expressions.push(node);
+ return this;
+ };
+
+ Block.prototype.pop = function() {
+ return this.expressions.pop();
+ };
+
+ Block.prototype.unshift = function(node) {
+ this.expressions.unshift(node);
+ return this;
+ };
+
+ Block.prototype.unwrap = function() {
+ if (this.expressions.length === 1) {
+ return this.expressions[0];
+ } else {
+ return this;
+ }
+ };
+
+ Block.prototype.isEmpty = function() {
+ return !this.expressions.length;
+ };
+
+ Block.prototype.isStatement = function(o) {
+ var exp, j, len1, ref3;
+ ref3 = this.expressions;
+ for (j = 0, len1 = ref3.length; j < len1; j++) {
+ exp = ref3[j];
+ if (exp.isStatement(o)) {
+ return true;
+ }
+ }
+ return false;
+ };
+
+ Block.prototype.jumps = function(o) {
+ var exp, j, jumpNode, len1, ref3;
+ ref3 = this.expressions;
+ for (j = 0, len1 = ref3.length; j < len1; j++) {
+ exp = ref3[j];
+ if (jumpNode = exp.jumps(o)) {
+ return jumpNode;
+ }
+ }
+ };
+
+ Block.prototype.makeReturn = function(res) {
+ var expr, len;
+ len = this.expressions.length;
+ while (len--) {
+ expr = this.expressions[len];
+ if (!(expr instanceof Comment)) {
+ this.expressions[len] = expr.makeReturn(res);
+ if (expr instanceof Return && !expr.expression) {
+ this.expressions.splice(len, 1);
+ }
+ break;
+ }
+ }
+ return this;
+ };
+
+ Block.prototype.compileToFragments = function(o, level) {
+ if (o == null) {
+ o = {};
+ }
+ if (o.scope) {
+ return Block.__super__.compileToFragments.call(this, o, level);
+ } else {
+ return this.compileRoot(o);
+ }
+ };
+
+ Block.prototype.compileNode = function(o) {
+ var answer, compiledNodes, fragments, index, j, len1, node, ref3, top;
+ this.tab = o.indent;
+ top = o.level === LEVEL_TOP;
+ compiledNodes = [];
+ ref3 = this.expressions;
+ for (index = j = 0, len1 = ref3.length; j < len1; index = ++j) {
+ node = ref3[index];
+ node = node.unwrapAll();
+ node = node.unfoldSoak(o) || node;
+ if (node instanceof Block) {
+ compiledNodes.push(node.compileNode(o));
+ } else if (top) {
+ node.front = true;
+ fragments = node.compileToFragments(o);
+ if (!node.isStatement(o)) {
+ fragments.unshift(this.makeCode("" + this.tab));
+ fragments.push(this.makeCode(";"));
+ }
+ compiledNodes.push(fragments);
+ } else {
+ compiledNodes.push(node.compileToFragments(o, LEVEL_LIST));
+ }
+ }
+ if (top) {
+ if (this.spaced) {
+ return [].concat(this.joinFragmentArrays(compiledNodes, '\n\n'), this.makeCode("\n"));
+ } else {
+ return this.joinFragmentArrays(compiledNodes, '\n');
+ }
+ }
+ if (compiledNodes.length) {
+ answer = this.joinFragmentArrays(compiledNodes, ', ');
+ } else {
+ answer = [this.makeCode("void 0")];
+ }
+ if (compiledNodes.length > 1 && o.level >= LEVEL_LIST) {
+ return this.wrapInBraces(answer);
+ } else {
+ return answer;
+ }
+ };
+
+ Block.prototype.compileRoot = function(o) {
+ var exp, fragments, i, j, len1, name, prelude, preludeExps, ref3, ref4, rest;
+ o.indent = o.bare ? '' : TAB;
+ o.level = LEVEL_TOP;
+ this.spaced = true;
+ o.scope = new Scope(null, this, null, (ref3 = o.referencedVars) != null ? ref3 : []);
+ ref4 = o.locals || [];
+ for (j = 0, len1 = ref4.length; j < len1; j++) {
+ name = ref4[j];
+ o.scope.parameter(name);
+ }
+ prelude = [];
+ if (!o.bare) {
+ preludeExps = (function() {
+ var k, len2, ref5, results;
+ ref5 = this.expressions;
+ results = [];
+ for (i = k = 0, len2 = ref5.length; k < len2; i = ++k) {
+ exp = ref5[i];
+ if (!(exp.unwrap() instanceof Comment)) {
+ break;
+ }
+ results.push(exp);
+ }
+ return results;
+ }).call(this);
+ rest = this.expressions.slice(preludeExps.length);
+ this.expressions = preludeExps;
+ if (preludeExps.length) {
+ prelude = this.compileNode(merge(o, {
+ indent: ''
+ }));
+ prelude.push(this.makeCode("\n"));
+ }
+ this.expressions = rest;
+ }
+ fragments = this.compileWithDeclarations(o);
+ if (o.bare) {
+ return fragments;
+ }
+ return [].concat(prelude, this.makeCode("(function() {\n"), fragments, this.makeCode("\n}).call(this);\n"));
+ };
+
+ Block.prototype.compileWithDeclarations = function(o) {
+ var assigns, declars, exp, fragments, i, j, len1, post, ref3, ref4, ref5, rest, scope, spaced;
+ fragments = [];
+ post = [];
+ ref3 = this.expressions;
+ for (i = j = 0, len1 = ref3.length; j < len1; i = ++j) {
+ exp = ref3[i];
+ exp = exp.unwrap();
+ if (!(exp instanceof Comment || exp instanceof Literal)) {
+ break;
+ }
+ }
+ o = merge(o, {
+ level: LEVEL_TOP
+ });
+ if (i) {
+ rest = this.expressions.splice(i, 9e9);
+ ref4 = [this.spaced, false], spaced = ref4[0], this.spaced = ref4[1];
+ ref5 = [this.compileNode(o), spaced], fragments = ref5[0], this.spaced = ref5[1];
+ this.expressions = rest;
+ }
+ post = this.compileNode(o);
+ scope = o.scope;
+ if (scope.expressions === this) {
+ declars = o.scope.hasDeclarations();
+ assigns = scope.hasAssignments;
+ if (declars || assigns) {
+ if (i) {
+ fragments.push(this.makeCode('\n'));
+ }
+ fragments.push(this.makeCode(this.tab + "var "));
+ if (declars) {
+ fragments.push(this.makeCode(scope.declaredVariables().join(', ')));
+ }
+ if (assigns) {
+ if (declars) {
+ fragments.push(this.makeCode(",\n" + (this.tab + TAB)));
+ }
+ fragments.push(this.makeCode(scope.assignedVariables().join(",\n" + (this.tab + TAB))));
+ }
+ fragments.push(this.makeCode(";\n" + (this.spaced ? '\n' : '')));
+ } else if (fragments.length && post.length) {
+ fragments.push(this.makeCode("\n"));
+ }
+ }
+ return fragments.concat(post);
+ };
+
+ Block.wrap = function(nodes) {
+ if (nodes.length === 1 && nodes[0] instanceof Block) {
+ return nodes[0];
+ }
+ return new Block(nodes);
+ };
+
+ return Block;
+
+ })(Base);
+
+ exports.Literal = Literal = (function(superClass1) {
+ extend1(Literal, superClass1);
+
+ function Literal(value1) {
+ this.value = value1;
+ }
+
+ Literal.prototype.isComplex = NO;
+
+ Literal.prototype.assigns = function(name) {
+ return name === this.value;
+ };
+
+ Literal.prototype.compileNode = function(o) {
+ return [this.makeCode(this.value)];
+ };
+
+ Literal.prototype.toString = function() {
+ return " " + (this.isStatement() ? Literal.__super__.toString.apply(this, arguments) : this.constructor.name) + ": " + this.value;
+ };
+
+ return Literal;
+
+ })(Base);
+
+ exports.NumberLiteral = NumberLiteral = (function(superClass1) {
+ extend1(NumberLiteral, superClass1);
+
+ function NumberLiteral() {
+ return NumberLiteral.__super__.constructor.apply(this, arguments);
+ }
+
+ return NumberLiteral;
+
+ })(Literal);
+
+ exports.InfinityLiteral = InfinityLiteral = (function(superClass1) {
+ extend1(InfinityLiteral, superClass1);
+
+ function InfinityLiteral() {
+ return InfinityLiteral.__super__.constructor.apply(this, arguments);
+ }
+
+ InfinityLiteral.prototype.compileNode = function() {
+ return [this.makeCode('2e308')];
+ };
+
+ return InfinityLiteral;
+
+ })(NumberLiteral);
+
+ exports.NaNLiteral = NaNLiteral = (function(superClass1) {
+ extend1(NaNLiteral, superClass1);
+
+ function NaNLiteral() {
+ NaNLiteral.__super__.constructor.call(this, 'NaN');
+ }
+
+ NaNLiteral.prototype.compileNode = function(o) {
+ var code;
+ code = [this.makeCode('0/0')];
+ if (o.level >= LEVEL_OP) {
+ return this.wrapInBraces(code);
+ } else {
+ return code;
+ }
+ };
+
+ return NaNLiteral;
+
+ })(NumberLiteral);
+
+ exports.StringLiteral = StringLiteral = (function(superClass1) {
+ extend1(StringLiteral, superClass1);
+
+ function StringLiteral() {
+ return StringLiteral.__super__.constructor.apply(this, arguments);
+ }
+
+ return StringLiteral;
+
+ })(Literal);
+
+ exports.RegexLiteral = RegexLiteral = (function(superClass1) {
+ extend1(RegexLiteral, superClass1);
+
+ function RegexLiteral() {
+ return RegexLiteral.__super__.constructor.apply(this, arguments);
+ }
+
+ return RegexLiteral;
+
+ })(Literal);
+
+ exports.PassthroughLiteral = PassthroughLiteral = (function(superClass1) {
+ extend1(PassthroughLiteral, superClass1);
+
+ function PassthroughLiteral() {
+ return PassthroughLiteral.__super__.constructor.apply(this, arguments);
+ }
+
+ return PassthroughLiteral;
+
+ })(Literal);
+
+ exports.IdentifierLiteral = IdentifierLiteral = (function(superClass1) {
+ extend1(IdentifierLiteral, superClass1);
+
+ function IdentifierLiteral() {
+ return IdentifierLiteral.__super__.constructor.apply(this, arguments);
+ }
+
+ IdentifierLiteral.prototype.isAssignable = YES;
+
+ return IdentifierLiteral;
+
+ })(Literal);
+
+ exports.PropertyName = PropertyName = (function(superClass1) {
+ extend1(PropertyName, superClass1);
+
+ function PropertyName() {
+ return PropertyName.__super__.constructor.apply(this, arguments);
+ }
+
+ PropertyName.prototype.isAssignable = YES;
+
+ return PropertyName;
+
+ })(Literal);
+
+ exports.StatementLiteral = StatementLiteral = (function(superClass1) {
+ extend1(StatementLiteral, superClass1);
+
+ function StatementLiteral() {
+ return StatementLiteral.__super__.constructor.apply(this, arguments);
+ }
+
+ StatementLiteral.prototype.isStatement = YES;
+
+ StatementLiteral.prototype.makeReturn = THIS;
+
+ StatementLiteral.prototype.jumps = function(o) {
+ if (this.value === 'break' && !((o != null ? o.loop : void 0) || (o != null ? o.block : void 0))) {
+ return this;
+ }
+ if (this.value === 'continue' && !(o != null ? o.loop : void 0)) {
+ return this;
+ }
+ };
+
+ StatementLiteral.prototype.compileNode = function(o) {
+ return [this.makeCode("" + this.tab + this.value + ";")];
+ };
+
+ return StatementLiteral;
+
+ })(Literal);
+
+ exports.ThisLiteral = ThisLiteral = (function(superClass1) {
+ extend1(ThisLiteral, superClass1);
+
+ function ThisLiteral() {
+ ThisLiteral.__super__.constructor.call(this, 'this');
+ }
+
+ ThisLiteral.prototype.compileNode = function(o) {
+ var code, ref3;
+ code = ((ref3 = o.scope.method) != null ? ref3.bound : void 0) ? o.scope.method.context : this.value;
+ return [this.makeCode(code)];
+ };
+
+ return ThisLiteral;
+
+ })(Literal);
+
+ exports.UndefinedLiteral = UndefinedLiteral = (function(superClass1) {
+ extend1(UndefinedLiteral, superClass1);
+
+ function UndefinedLiteral() {
+ UndefinedLiteral.__super__.constructor.call(this, 'undefined');
+ }
+
+ UndefinedLiteral.prototype.compileNode = function(o) {
+ return [this.makeCode(o.level >= LEVEL_ACCESS ? '(void 0)' : 'void 0')];
+ };
+
+ return UndefinedLiteral;
+
+ })(Literal);
+
+ exports.NullLiteral = NullLiteral = (function(superClass1) {
+ extend1(NullLiteral, superClass1);
+
+ function NullLiteral() {
+ NullLiteral.__super__.constructor.call(this, 'null');
+ }
+
+ return NullLiteral;
+
+ })(Literal);
+
+ exports.BooleanLiteral = BooleanLiteral = (function(superClass1) {
+ extend1(BooleanLiteral, superClass1);
+
+ function BooleanLiteral() {
+ return BooleanLiteral.__super__.constructor.apply(this, arguments);
+ }
+
+ return BooleanLiteral;
+
+ })(Literal);
+
+ exports.Return = Return = (function(superClass1) {
+ extend1(Return, superClass1);
+
+ function Return(expression) {
+ this.expression = expression;
+ }
+
+ Return.prototype.children = ['expression'];
+
+ Return.prototype.isStatement = YES;
+
+ Return.prototype.makeReturn = THIS;
+
+ Return.prototype.jumps = THIS;
+
+ Return.prototype.compileToFragments = function(o, level) {
+ var expr, ref3;
+ expr = (ref3 = this.expression) != null ? ref3.makeReturn() : void 0;
+ if (expr && !(expr instanceof Return)) {
+ return expr.compileToFragments(o, level);
+ } else {
+ return Return.__super__.compileToFragments.call(this, o, level);
+ }
+ };
+
+ Return.prototype.compileNode = function(o) {
+ var answer;
+ answer = [];
+ answer.push(this.makeCode(this.tab + ("return" + (this.expression ? " " : ""))));
+ if (this.expression) {
+ answer = answer.concat(this.expression.compileToFragments(o, LEVEL_PAREN));
+ }
+ answer.push(this.makeCode(";"));
+ return answer;
+ };
+
+ return Return;
+
+ })(Base);
+
+ exports.YieldReturn = YieldReturn = (function(superClass1) {
+ extend1(YieldReturn, superClass1);
+
+ function YieldReturn() {
+ return YieldReturn.__super__.constructor.apply(this, arguments);
+ }
+
+ YieldReturn.prototype.compileNode = function(o) {
+ if (o.scope.parent == null) {
+ this.error('yield can only occur inside functions');
+ }
+ return YieldReturn.__super__.compileNode.apply(this, arguments);
+ };
+
+ return YieldReturn;
+
+ })(Return);
+
+ exports.Value = Value = (function(superClass1) {
+ extend1(Value, superClass1);
+
+ function Value(base, props, tag) {
+ if (!props && base instanceof Value) {
+ return base;
+ }
+ this.base = base;
+ this.properties = props || [];
+ if (tag) {
+ this[tag] = true;
+ }
+ return this;
+ }
+
+ Value.prototype.children = ['base', 'properties'];
+
+ Value.prototype.add = function(props) {
+ this.properties = this.properties.concat(props);
+ return this;
+ };
+
+ Value.prototype.hasProperties = function() {
+ return !!this.properties.length;
+ };
+
+ Value.prototype.bareLiteral = function(type) {
+ return !this.properties.length && this.base instanceof type;
+ };
+
+ Value.prototype.isArray = function() {
+ return this.bareLiteral(Arr);
+ };
+
+ Value.prototype.isRange = function() {
+ return this.bareLiteral(Range);
+ };
+
+ Value.prototype.isComplex = function() {
+ return this.hasProperties() || this.base.isComplex();
+ };
+
+ Value.prototype.isAssignable = function() {
+ return this.hasProperties() || this.base.isAssignable();
+ };
+
+ Value.prototype.isNumber = function() {
+ return this.bareLiteral(NumberLiteral);
+ };
+
+ Value.prototype.isString = function() {
+ return this.bareLiteral(StringLiteral);
+ };
+
+ Value.prototype.isRegex = function() {
+ return this.bareLiteral(RegexLiteral);
+ };
+
+ Value.prototype.isUndefined = function() {
+ return this.bareLiteral(UndefinedLiteral);
+ };
+
+ Value.prototype.isNull = function() {
+ return this.bareLiteral(NullLiteral);
+ };
+
+ Value.prototype.isBoolean = function() {
+ return this.bareLiteral(BooleanLiteral);
+ };
+
+ Value.prototype.isAtomic = function() {
+ var j, len1, node, ref3;
+ ref3 = this.properties.concat(this.base);
+ for (j = 0, len1 = ref3.length; j < len1; j++) {
+ node = ref3[j];
+ if (node.soak || node instanceof Call) {
+ return false;
+ }
+ }
+ return true;
+ };
+
+ Value.prototype.isNotCallable = function() {
+ return this.isNumber() || this.isString() || this.isRegex() || this.isArray() || this.isRange() || this.isSplice() || this.isObject() || this.isUndefined() || this.isNull() || this.isBoolean();
+ };
+
+ Value.prototype.isStatement = function(o) {
+ return !this.properties.length && this.base.isStatement(o);
+ };
+
+ Value.prototype.assigns = function(name) {
+ return !this.properties.length && this.base.assigns(name);
+ };
+
+ Value.prototype.jumps = function(o) {
+ return !this.properties.length && this.base.jumps(o);
+ };
+
+ Value.prototype.isObject = function(onlyGenerated) {
+ if (this.properties.length) {
+ return false;
+ }
+ return (this.base instanceof Obj) && (!onlyGenerated || this.base.generated);
+ };
+
+ Value.prototype.isSplice = function() {
+ var lastProp, ref3;
+ ref3 = this.properties, lastProp = ref3[ref3.length - 1];
+ return lastProp instanceof Slice;
+ };
+
+ Value.prototype.looksStatic = function(className) {
+ var ref3;
+ return this.base.value === className && this.properties.length === 1 && ((ref3 = this.properties[0].name) != null ? ref3.value : void 0) !== 'prototype';
+ };
+
+ Value.prototype.unwrap = function() {
+ if (this.properties.length) {
+ return this;
+ } else {
+ return this.base;
+ }
+ };
+
+ Value.prototype.cacheReference = function(o) {
+ var base, bref, name, nref, ref3;
+ ref3 = this.properties, name = ref3[ref3.length - 1];
+ if (this.properties.length < 2 && !this.base.isComplex() && !(name != null ? name.isComplex() : void 0)) {
+ return [this, this];
+ }
+ base = new Value(this.base, this.properties.slice(0, -1));
+ if (base.isComplex()) {
+ bref = new IdentifierLiteral(o.scope.freeVariable('base'));
+ base = new Value(new Parens(new Assign(bref, base)));
+ }
+ if (!name) {
+ return [base, bref];
+ }
+ if (name.isComplex()) {
+ nref = new IdentifierLiteral(o.scope.freeVariable('name'));
+ name = new Index(new Assign(nref, name.index));
+ nref = new Index(nref);
+ }
+ return [base.add(name), new Value(bref || base.base, [nref || name])];
+ };
+
+ Value.prototype.compileNode = function(o) {
+ var fragments, j, len1, prop, props;
+ this.base.front = this.front;
+ props = this.properties;
+ fragments = this.base.compileToFragments(o, (props.length ? LEVEL_ACCESS : null));
+ if (props.length && SIMPLENUM.test(fragmentsToText(fragments))) {
+ fragments.push(this.makeCode('.'));
+ }
+ for (j = 0, len1 = props.length; j < len1; j++) {
+ prop = props[j];
+ fragments.push.apply(fragments, prop.compileToFragments(o));
+ }
+ return fragments;
+ };
+
+ Value.prototype.unfoldSoak = function(o) {
+ return this.unfoldedSoak != null ? this.unfoldedSoak : this.unfoldedSoak = (function(_this) {
+ return function() {
+ var fst, i, ifn, j, len1, prop, ref, ref3, ref4, snd;
+ if (ifn = _this.base.unfoldSoak(o)) {
+ (ref3 = ifn.body.properties).push.apply(ref3, _this.properties);
+ return ifn;
+ }
+ ref4 = _this.properties;
+ for (i = j = 0, len1 = ref4.length; j < len1; i = ++j) {
+ prop = ref4[i];
+ if (!prop.soak) {
+ continue;
+ }
+ prop.soak = false;
+ fst = new Value(_this.base, _this.properties.slice(0, i));
+ snd = new Value(_this.base, _this.properties.slice(i));
+ if (fst.isComplex()) {
+ ref = new IdentifierLiteral(o.scope.freeVariable('ref'));
+ fst = new Parens(new Assign(ref, fst));
+ snd.base = ref;
+ }
+ return new If(new Existence(fst), snd, {
+ soak: true
+ });
+ }
+ return false;
+ };
+ })(this)();
+ };
+
+ return Value;
+
+ })(Base);
+
+ exports.Comment = Comment = (function(superClass1) {
+ extend1(Comment, superClass1);
+
+ function Comment(comment1) {
+ this.comment = comment1;
+ }
+
+ Comment.prototype.isStatement = YES;
+
+ Comment.prototype.makeReturn = THIS;
+
+ Comment.prototype.compileNode = function(o, level) {
+ var code, comment;
+ comment = this.comment.replace(/^(\s*)#(?=\s)/gm, "$1 *");
+ code = "/*" + (multident(comment, this.tab)) + (indexOf.call(comment, '\n') >= 0 ? "\n" + this.tab : '') + " */";
+ if ((level || o.level) === LEVEL_TOP) {
+ code = o.indent + code;
+ }
+ return [this.makeCode("\n"), this.makeCode(code)];
+ };
+
+ return Comment;
+
+ })(Base);
+
+ exports.Call = Call = (function(superClass1) {
+ extend1(Call, superClass1);
+
+ function Call(variable1, args1, soak1) {
+ this.variable = variable1;
+ this.args = args1 != null ? args1 : [];
+ this.soak = soak1;
+ this.isNew = false;
+ if (this.variable instanceof Value && this.variable.isNotCallable()) {
+ this.variable.error("literal is not a function");
+ }
+ }
+
+ Call.prototype.children = ['variable', 'args'];
+
+ Call.prototype.updateLocationDataIfMissing = function(locationData) {
+ var base, ref3;
+ if (this.locationData && this.needsUpdatedStartLocation) {
+ this.locationData.first_line = locationData.first_line;
+ this.locationData.first_column = locationData.first_column;
+ base = ((ref3 = this.variable) != null ? ref3.base : void 0) || this.variable;
+ if (base.needsUpdatedStartLocation) {
+ this.variable.locationData.first_line = locationData.first_line;
+ this.variable.locationData.first_column = locationData.first_column;
+ base.updateLocationDataIfMissing(locationData);
+ }
+ delete this.needsUpdatedStartLocation;
+ }
+ return Call.__super__.updateLocationDataIfMissing.apply(this, arguments);
+ };
+
+ Call.prototype.newInstance = function() {
+ var base, ref3;
+ base = ((ref3 = this.variable) != null ? ref3.base : void 0) || this.variable;
+ if (base instanceof Call && !base.isNew) {
+ base.newInstance();
+ } else {
+ this.isNew = true;
+ }
+ this.needsUpdatedStartLocation = true;
+ return this;
+ };
+
+ Call.prototype.unfoldSoak = function(o) {
+ var call, ifn, j, left, len1, list, ref3, ref4, rite;
+ if (this.soak) {
+ if (this instanceof SuperCall) {
+ left = new Literal(this.superReference(o));
+ rite = new Value(left);
+ } else {
+ if (ifn = unfoldSoak(o, this, 'variable')) {
+ return ifn;
+ }
+ ref3 = new Value(this.variable).cacheReference(o), left = ref3[0], rite = ref3[1];
+ }
+ rite = new Call(rite, this.args);
+ rite.isNew = this.isNew;
+ left = new Literal("typeof " + (left.compile(o)) + " === \"function\"");
+ return new If(left, new Value(rite), {
+ soak: true
+ });
+ }
+ call = this;
+ list = [];
+ while (true) {
+ if (call.variable instanceof Call) {
+ list.push(call);
+ call = call.variable;
+ continue;
+ }
+ if (!(call.variable instanceof Value)) {
+ break;
+ }
+ list.push(call);
+ if (!((call = call.variable.base) instanceof Call)) {
+ break;
+ }
+ }
+ ref4 = list.reverse();
+ for (j = 0, len1 = ref4.length; j < len1; j++) {
+ call = ref4[j];
+ if (ifn) {
+ if (call.variable instanceof Call) {
+ call.variable = ifn;
+ } else {
+ call.variable.base = ifn;
+ }
+ }
+ ifn = unfoldSoak(o, call, 'variable');
+ }
+ return ifn;
+ };
+
+ Call.prototype.compileNode = function(o) {
+ var arg, argIndex, compiledArgs, compiledArray, fragments, j, len1, preface, ref3, ref4;
+ if ((ref3 = this.variable) != null) {
+ ref3.front = this.front;
+ }
+ compiledArray = Splat.compileSplattedArray(o, this.args, true);
+ if (compiledArray.length) {
+ return this.compileSplat(o, compiledArray);
+ }
+ compiledArgs = [];
+ ref4 = this.args;
+ for (argIndex = j = 0, len1 = ref4.length; j < len1; argIndex = ++j) {
+ arg = ref4[argIndex];
+ if (argIndex) {
+ compiledArgs.push(this.makeCode(", "));
+ }
+ compiledArgs.push.apply(compiledArgs, arg.compileToFragments(o, LEVEL_LIST));
+ }
+ fragments = [];
+ if (this instanceof SuperCall) {
+ preface = this.superReference(o) + (".call(" + (this.superThis(o)));
+ if (compiledArgs.length) {
+ preface += ", ";
+ }
+ fragments.push(this.makeCode(preface));
+ } else {
+ if (this.isNew) {
+ fragments.push(this.makeCode('new '));
+ }
+ fragments.push.apply(fragments, this.variable.compileToFragments(o, LEVEL_ACCESS));
+ fragments.push(this.makeCode("("));
+ }
+ fragments.push.apply(fragments, compiledArgs);
+ fragments.push(this.makeCode(")"));
+ return fragments;
+ };
+
+ Call.prototype.compileSplat = function(o, splatArgs) {
+ var answer, base, fun, idt, name, ref;
+ if (this instanceof SuperCall) {
+ return [].concat(this.makeCode((this.superReference(o)) + ".apply(" + (this.superThis(o)) + ", "), splatArgs, this.makeCode(")"));
+ }
+ if (this.isNew) {
+ idt = this.tab + TAB;
+ return [].concat(this.makeCode("(function(func, args, ctor) {\n" + idt + "ctor.prototype = func.prototype;\n" + idt + "var child = new ctor, result = func.apply(child, args);\n" + idt + "return Object(result) === result ? result : child;\n" + this.tab + "})("), this.variable.compileToFragments(o, LEVEL_LIST), this.makeCode(", "), splatArgs, this.makeCode(", function(){})"));
+ }
+ answer = [];
+ base = new Value(this.variable);
+ if ((name = base.properties.pop()) && base.isComplex()) {
+ ref = o.scope.freeVariable('ref');
+ answer = answer.concat(this.makeCode("(" + ref + " = "), base.compileToFragments(o, LEVEL_LIST), this.makeCode(")"), name.compileToFragments(o));
+ } else {
+ fun = base.compileToFragments(o, LEVEL_ACCESS);
+ if (SIMPLENUM.test(fragmentsToText(fun))) {
+ fun = this.wrapInBraces(fun);
+ }
+ if (name) {
+ ref = fragmentsToText(fun);
+ fun.push.apply(fun, name.compileToFragments(o));
+ } else {
+ ref = 'null';
+ }
+ answer = answer.concat(fun);
+ }
+ return answer = answer.concat(this.makeCode(".apply(" + ref + ", "), splatArgs, this.makeCode(")"));
+ };
+
+ return Call;
+
+ })(Base);
+
+ exports.SuperCall = SuperCall = (function(superClass1) {
+ extend1(SuperCall, superClass1);
+
+ function SuperCall(args) {
+ SuperCall.__super__.constructor.call(this, null, args != null ? args : [new Splat(new IdentifierLiteral('arguments'))]);
+ this.isBare = args != null;
+ }
+
+ SuperCall.prototype.superReference = function(o) {
+ var accesses, base, bref, klass, method, name, nref, variable;
+ method = o.scope.namedMethod();
+ if (method != null ? method.klass : void 0) {
+ klass = method.klass, name = method.name, variable = method.variable;
+ if (klass.isComplex()) {
+ bref = new IdentifierLiteral(o.scope.parent.freeVariable('base'));
+ base = new Value(new Parens(new Assign(bref, klass)));
+ variable.base = base;
+ variable.properties.splice(0, klass.properties.length);
+ }
+ if (name.isComplex() || (name instanceof Index && name.index.isAssignable())) {
+ nref = new IdentifierLiteral(o.scope.parent.freeVariable('name'));
+ name = new Index(new Assign(nref, name.index));
+ variable.properties.pop();
+ variable.properties.push(name);
+ }
+ accesses = [new Access(new PropertyName('__super__'))];
+ if (method["static"]) {
+ accesses.push(new Access(new PropertyName('constructor')));
+ }
+ accesses.push(nref != null ? new Index(nref) : name);
+ return (new Value(bref != null ? bref : klass, accesses)).compile(o);
+ } else if (method != null ? method.ctor : void 0) {
+ return method.name + ".__super__.constructor";
+ } else {
+ return this.error('cannot call super outside of an instance method.');
+ }
+ };
+
+ SuperCall.prototype.superThis = function(o) {
+ var method;
+ method = o.scope.method;
+ return (method && !method.klass && method.context) || "this";
+ };
+
+ return SuperCall;
+
+ })(Call);
+
+ exports.RegexWithInterpolations = RegexWithInterpolations = (function(superClass1) {
+ extend1(RegexWithInterpolations, superClass1);
+
+ function RegexWithInterpolations(args) {
+ if (args == null) {
+ args = [];
+ }
+ RegexWithInterpolations.__super__.constructor.call(this, new Value(new IdentifierLiteral('RegExp')), args, false);
+ }
+
+ return RegexWithInterpolations;
+
+ })(Call);
+
+ exports.TaggedTemplateCall = TaggedTemplateCall = (function(superClass1) {
+ extend1(TaggedTemplateCall, superClass1);
+
+ function TaggedTemplateCall(variable, arg, soak) {
+ if (arg instanceof StringLiteral) {
+ arg = new StringWithInterpolations(Block.wrap([new Value(arg)]));
+ }
+ TaggedTemplateCall.__super__.constructor.call(this, variable, [arg], soak);
+ }
+
+ TaggedTemplateCall.prototype.compileNode = function(o) {
+ o.inTaggedTemplateCall = true;
+ return this.variable.compileToFragments(o, LEVEL_ACCESS).concat(this.args[0].compileToFragments(o, LEVEL_LIST));
+ };
+
+ return TaggedTemplateCall;
+
+ })(Call);
+
+ exports.Extends = Extends = (function(superClass1) {
+ extend1(Extends, superClass1);
+
+ function Extends(child1, parent1) {
+ this.child = child1;
+ this.parent = parent1;
+ }
+
+ Extends.prototype.children = ['child', 'parent'];
+
+ Extends.prototype.compileToFragments = function(o) {
+ return new Call(new Value(new Literal(utility('extend', o))), [this.child, this.parent]).compileToFragments(o);
+ };
+
+ return Extends;
+
+ })(Base);
+
+ exports.Access = Access = (function(superClass1) {
+ extend1(Access, superClass1);
+
+ function Access(name1, tag) {
+ this.name = name1;
+ this.soak = tag === 'soak';
+ }
+
+ Access.prototype.children = ['name'];
+
+ Access.prototype.compileToFragments = function(o) {
+ var name, node, ref3;
+ name = this.name.compileToFragments(o);
+ node = this.name.unwrap();
+ if (node instanceof PropertyName) {
+ if (ref3 = node.value, indexOf.call(JS_FORBIDDEN, ref3) >= 0) {
+ return [this.makeCode('["')].concat(slice.call(name), [this.makeCode('"]')]);
+ } else {
+ return [this.makeCode('.')].concat(slice.call(name));
+ }
+ } else {
+ return [this.makeCode('[')].concat(slice.call(name), [this.makeCode(']')]);
+ }
+ };
+
+ Access.prototype.isComplex = NO;
+
+ return Access;
+
+ })(Base);
+
+ exports.Index = Index = (function(superClass1) {
+ extend1(Index, superClass1);
+
+ function Index(index1) {
+ this.index = index1;
+ }
+
+ Index.prototype.children = ['index'];
+
+ Index.prototype.compileToFragments = function(o) {
+ return [].concat(this.makeCode("["), this.index.compileToFragments(o, LEVEL_PAREN), this.makeCode("]"));
+ };
+
+ Index.prototype.isComplex = function() {
+ return this.index.isComplex();
+ };
+
+ return Index;
+
+ })(Base);
+
+ exports.Range = Range = (function(superClass1) {
+ extend1(Range, superClass1);
+
+ Range.prototype.children = ['from', 'to'];
+
+ function Range(from1, to1, tag) {
+ this.from = from1;
+ this.to = to1;
+ this.exclusive = tag === 'exclusive';
+ this.equals = this.exclusive ? '' : '=';
+ }
+
+ Range.prototype.compileVariables = function(o) {
+ var isComplex, ref3, ref4, ref5, step;
+ o = merge(o, {
+ top: true
+ });
+ isComplex = del(o, 'isComplex');
+ ref3 = this.cacheToCodeFragments(this.from.cache(o, LEVEL_LIST, isComplex)), this.fromC = ref3[0], this.fromVar = ref3[1];
+ ref4 = this.cacheToCodeFragments(this.to.cache(o, LEVEL_LIST, isComplex)), this.toC = ref4[0], this.toVar = ref4[1];
+ if (step = del(o, 'step')) {
+ ref5 = this.cacheToCodeFragments(step.cache(o, LEVEL_LIST, isComplex)), this.step = ref5[0], this.stepVar = ref5[1];
+ }
+ this.fromNum = this.from.isNumber() ? Number(this.fromVar) : null;
+ this.toNum = this.to.isNumber() ? Number(this.toVar) : null;
+ return this.stepNum = (step != null ? step.isNumber() : void 0) ? Number(this.stepVar) : null;
+ };
+
+ Range.prototype.compileNode = function(o) {
+ var cond, condPart, from, gt, idx, idxName, known, lt, namedIndex, ref3, ref4, stepPart, to, varPart;
+ if (!this.fromVar) {
+ this.compileVariables(o);
+ }
+ if (!o.index) {
+ return this.compileArray(o);
+ }
+ known = (this.fromNum != null) && (this.toNum != null);
+ idx = del(o, 'index');
+ idxName = del(o, 'name');
+ namedIndex = idxName && idxName !== idx;
+ varPart = idx + " = " + this.fromC;
+ if (this.toC !== this.toVar) {
+ varPart += ", " + this.toC;
+ }
+ if (this.step !== this.stepVar) {
+ varPart += ", " + this.step;
+ }
+ ref3 = [idx + " <" + this.equals, idx + " >" + this.equals], lt = ref3[0], gt = ref3[1];
+ condPart = this.stepNum != null ? this.stepNum > 0 ? lt + " " + this.toVar : gt + " " + this.toVar : known ? ((ref4 = [this.fromNum, this.toNum], from = ref4[0], to = ref4[1], ref4), from <= to ? lt + " " + to : gt + " " + to) : (cond = this.stepVar ? this.stepVar + " > 0" : this.fromVar + " <= " + this.toVar, cond + " ? " + lt + " " + this.toVar + " : " + gt + " " + this.toVar);
+ stepPart = this.stepVar ? idx + " += " + this.stepVar : known ? namedIndex ? from <= to ? "++" + idx : "--" + idx : from <= to ? idx + "++" : idx + "--" : namedIndex ? cond + " ? ++" + idx + " : --" + idx : cond + " ? " + idx + "++ : " + idx + "--";
+ if (namedIndex) {
+ varPart = idxName + " = " + varPart;
+ }
+ if (namedIndex) {
+ stepPart = idxName + " = " + stepPart;
+ }
+ return [this.makeCode(varPart + "; " + condPart + "; " + stepPart)];
+ };
+
+ Range.prototype.compileArray = function(o) {
+ var args, body, cond, hasArgs, i, idt, j, known, post, pre, range, ref3, ref4, result, results, vars;
+ known = (this.fromNum != null) && (this.toNum != null);
+ if (known && Math.abs(this.fromNum - this.toNum) <= 20) {
+ range = (function() {
+ results = [];
+ for (var j = ref3 = this.fromNum, ref4 = this.toNum; ref3 <= ref4 ? j <= ref4 : j >= ref4; ref3 <= ref4 ? j++ : j--){ results.push(j); }
+ return results;
+ }).apply(this);
+ if (this.exclusive) {
+ range.pop();
+ }
+ return [this.makeCode("[" + (range.join(', ')) + "]")];
+ }
+ idt = this.tab + TAB;
+ i = o.scope.freeVariable('i', {
+ single: true
+ });
+ result = o.scope.freeVariable('results');
+ pre = "\n" + idt + result + " = [];";
+ if (known) {
+ o.index = i;
+ body = fragmentsToText(this.compileNode(o));
+ } else {
+ vars = (i + " = " + this.fromC) + (this.toC !== this.toVar ? ", " + this.toC : '');
+ cond = this.fromVar + " <= " + this.toVar;
+ body = "var " + vars + "; " + cond + " ? " + i + " <" + this.equals + " " + this.toVar + " : " + i + " >" + this.equals + " " + this.toVar + "; " + cond + " ? " + i + "++ : " + i + "--";
+ }
+ post = "{ " + result + ".push(" + i + "); }\n" + idt + "return " + result + ";\n" + o.indent;
+ hasArgs = function(node) {
+ return node != null ? node.contains(isLiteralArguments) : void 0;
+ };
+ if (hasArgs(this.from) || hasArgs(this.to)) {
+ args = ', arguments';
+ }
+ return [this.makeCode("(function() {" + pre + "\n" + idt + "for (" + body + ")" + post + "}).apply(this" + (args != null ? args : '') + ")")];
+ };
+
+ return Range;
+
+ })(Base);
+
+ exports.Slice = Slice = (function(superClass1) {
+ extend1(Slice, superClass1);
+
+ Slice.prototype.children = ['range'];
+
+ function Slice(range1) {
+ this.range = range1;
+ Slice.__super__.constructor.call(this);
+ }
+
+ Slice.prototype.compileNode = function(o) {
+ var compiled, compiledText, from, fromCompiled, ref3, to, toStr;
+ ref3 = this.range, to = ref3.to, from = ref3.from;
+ fromCompiled = from && from.compileToFragments(o, LEVEL_PAREN) || [this.makeCode('0')];
+ if (to) {
+ compiled = to.compileToFragments(o, LEVEL_PAREN);
+ compiledText = fragmentsToText(compiled);
+ if (!(!this.range.exclusive && +compiledText === -1)) {
+ toStr = ', ' + (this.range.exclusive ? compiledText : to.isNumber() ? "" + (+compiledText + 1) : (compiled = to.compileToFragments(o, LEVEL_ACCESS), "+" + (fragmentsToText(compiled)) + " + 1 || 9e9"));
+ }
+ }
+ return [this.makeCode(".slice(" + (fragmentsToText(fromCompiled)) + (toStr || '') + ")")];
+ };
+
+ return Slice;
+
+ })(Base);
+
+ exports.Obj = Obj = (function(superClass1) {
+ extend1(Obj, superClass1);
+
+ function Obj(props, generated) {
+ this.generated = generated != null ? generated : false;
+ this.objects = this.properties = props || [];
+ }
+
+ Obj.prototype.children = ['properties'];
+
+ Obj.prototype.compileNode = function(o) {
+ var answer, dynamicIndex, hasDynamic, i, idt, indent, j, join, k, key, l, lastNoncom, len1, len2, len3, node, oref, prop, props, ref3, value;
+ props = this.properties;
+ if (this.generated) {
+ for (j = 0, len1 = props.length; j < len1; j++) {
+ node = props[j];
+ if (node instanceof Value) {
+ node.error('cannot have an implicit value in an implicit object');
+ }
+ }
+ }
+ for (dynamicIndex = k = 0, len2 = props.length; k < len2; dynamicIndex = ++k) {
+ prop = props[dynamicIndex];
+ if ((prop.variable || prop).base instanceof Parens) {
+ break;
+ }
+ }
+ hasDynamic = dynamicIndex < props.length;
+ idt = o.indent += TAB;
+ lastNoncom = this.lastNonComment(this.properties);
+ answer = [];
+ if (hasDynamic) {
+ oref = o.scope.freeVariable('obj');
+ answer.push(this.makeCode("(\n" + idt + oref + " = "));
+ }
+ answer.push(this.makeCode("{" + (props.length === 0 || dynamicIndex === 0 ? '}' : '\n')));
+ for (i = l = 0, len3 = props.length; l < len3; i = ++l) {
+ prop = props[i];
+ if (i === dynamicIndex) {
+ if (i !== 0) {
+ answer.push(this.makeCode("\n" + idt + "}"));
+ }
+ answer.push(this.makeCode(',\n'));
+ }
+ join = i === props.length - 1 || i === dynamicIndex - 1 ? '' : prop === lastNoncom || prop instanceof Comment ? '\n' : ',\n';
+ indent = prop instanceof Comment ? '' : idt;
+ if (hasDynamic && i < dynamicIndex) {
+ indent += TAB;
+ }
+ if (prop instanceof Assign) {
+ if (prop.context !== 'object') {
+ prop.operatorToken.error("unexpected " + prop.operatorToken.value);
+ }
+ if (prop.variable instanceof Value && prop.variable.hasProperties()) {
+ prop.variable.error('invalid object key');
+ }
+ }
+ if (prop instanceof Value && prop["this"]) {
+ prop = new Assign(prop.properties[0].name, prop, 'object');
+ }
+ if (!(prop instanceof Comment)) {
+ if (i < dynamicIndex) {
+ if (!(prop instanceof Assign)) {
+ prop = new Assign(prop, prop, 'object');
+ }
+ } else {
+ if (prop instanceof Assign) {
+ key = prop.variable;
+ value = prop.value;
+ } else {
+ ref3 = prop.base.cache(o), key = ref3[0], value = ref3[1];
+ if (key instanceof IdentifierLiteral) {
+ key = new PropertyName(key.value);
+ }
+ }
+ prop = new Assign(new Value(new IdentifierLiteral(oref), [new Access(key)]), value);
+ }
+ }
+ if (indent) {
+ answer.push(this.makeCode(indent));
+ }
+ answer.push.apply(answer, prop.compileToFragments(o, LEVEL_TOP));
+ if (join) {
+ answer.push(this.makeCode(join));
+ }
+ }
+ if (hasDynamic) {
+ answer.push(this.makeCode(",\n" + idt + oref + "\n" + this.tab + ")"));
+ } else {
+ if (props.length !== 0) {
+ answer.push(this.makeCode("\n" + this.tab + "}"));
+ }
+ }
+ if (this.front && !hasDynamic) {
+ return this.wrapInBraces(answer);
+ } else {
+ return answer;
+ }
+ };
+
+ Obj.prototype.assigns = function(name) {
+ var j, len1, prop, ref3;
+ ref3 = this.properties;
+ for (j = 0, len1 = ref3.length; j < len1; j++) {
+ prop = ref3[j];
+ if (prop.assigns(name)) {
+ return true;
+ }
+ }
+ return false;
+ };
+
+ return Obj;
+
+ })(Base);
+
+ exports.Arr = Arr = (function(superClass1) {
+ extend1(Arr, superClass1);
+
+ function Arr(objs) {
+ this.objects = objs || [];
+ }
+
+ Arr.prototype.children = ['objects'];
+
+ Arr.prototype.compileNode = function(o) {
+ var answer, compiledObjs, fragments, index, j, len1, obj;
+ if (!this.objects.length) {
+ return [this.makeCode('[]')];
+ }
+ o.indent += TAB;
+ answer = Splat.compileSplattedArray(o, this.objects);
+ if (answer.length) {
+ return answer;
+ }
+ answer = [];
+ compiledObjs = (function() {
+ var j, len1, ref3, results;
+ ref3 = this.objects;
+ results = [];
+ for (j = 0, len1 = ref3.length; j < len1; j++) {
+ obj = ref3[j];
+ results.push(obj.compileToFragments(o, LEVEL_LIST));
+ }
+ return results;
+ }).call(this);
+ for (index = j = 0, len1 = compiledObjs.length; j < len1; index = ++j) {
+ fragments = compiledObjs[index];
+ if (index) {
+ answer.push(this.makeCode(", "));
+ }
+ answer.push.apply(answer, fragments);
+ }
+ if (fragmentsToText(answer).indexOf('\n') >= 0) {
+ answer.unshift(this.makeCode("[\n" + o.indent));
+ answer.push(this.makeCode("\n" + this.tab + "]"));
+ } else {
+ answer.unshift(this.makeCode("["));
+ answer.push(this.makeCode("]"));
+ }
+ return answer;
+ };
+
+ Arr.prototype.assigns = function(name) {
+ var j, len1, obj, ref3;
+ ref3 = this.objects;
+ for (j = 0, len1 = ref3.length; j < len1; j++) {
+ obj = ref3[j];
+ if (obj.assigns(name)) {
+ return true;
+ }
+ }
+ return false;
+ };
+
+ return Arr;
+
+ })(Base);
+
+ exports.Class = Class = (function(superClass1) {
+ extend1(Class, superClass1);
+
+ function Class(variable1, parent1, body1) {
+ this.variable = variable1;
+ this.parent = parent1;
+ this.body = body1 != null ? body1 : new Block;
+ this.boundFuncs = [];
+ this.body.classBody = true;
+ }
+
+ Class.prototype.children = ['variable', 'parent', 'body'];
+
+ Class.prototype.defaultClassVariableName = '_Class';
+
+ Class.prototype.determineName = function() {
+ var message, name, node, ref3, tail;
+ if (!this.variable) {
+ return this.defaultClassVariableName;
+ }
+ ref3 = this.variable.properties, tail = ref3[ref3.length - 1];
+ node = tail ? tail instanceof Access && tail.name : this.variable.base;
+ if (!(node instanceof IdentifierLiteral || node instanceof PropertyName)) {
+ return this.defaultClassVariableName;
+ }
+ name = node.value;
+ if (!tail) {
+ message = isUnassignable(name);
+ if (message) {
+ this.variable.error(message);
+ }
+ }
+ if (indexOf.call(JS_FORBIDDEN, name) >= 0) {
+ return "_" + name;
+ } else {
+ return name;
+ }
+ };
+
+ Class.prototype.setContext = function(name) {
+ return this.body.traverseChildren(false, function(node) {
+ if (node.classBody) {
+ return false;
+ }
+ if (node instanceof ThisLiteral) {
+ return node.value = name;
+ } else if (node instanceof Code) {
+ if (node.bound) {
+ return node.context = name;
+ }
+ }
+ });
+ };
+
+ Class.prototype.addBoundFunctions = function(o) {
+ var bvar, j, len1, lhs, ref3;
+ ref3 = this.boundFuncs;
+ for (j = 0, len1 = ref3.length; j < len1; j++) {
+ bvar = ref3[j];
+ lhs = (new Value(new ThisLiteral, [new Access(bvar)])).compile(o);
+ this.ctor.body.unshift(new Literal(lhs + " = " + (utility('bind', o)) + "(" + lhs + ", this)"));
+ }
+ };
+
+ Class.prototype.addProperties = function(node, name, o) {
+ var acc, assign, base, exprs, func, props;
+ props = node.base.properties.slice(0);
+ exprs = (function() {
+ var results;
+ results = [];
+ while (assign = props.shift()) {
+ if (assign instanceof Assign) {
+ base = assign.variable.base;
+ delete assign.context;
+ func = assign.value;
+ if (base.value === 'constructor') {
+ if (this.ctor) {
+ assign.error('cannot define more than one constructor in a class');
+ }
+ if (func.bound) {
+ assign.error('cannot define a constructor as a bound function');
+ }
+ if (func instanceof Code) {
+ assign = this.ctor = func;
+ } else {
+ this.externalCtor = o.classScope.freeVariable('ctor');
+ assign = new Assign(new IdentifierLiteral(this.externalCtor), func);
+ }
+ } else {
+ if (assign.variable["this"]) {
+ func["static"] = true;
+ } else {
+ acc = base.isComplex() ? new Index(base) : new Access(base);
+ assign.variable = new Value(new IdentifierLiteral(name), [new Access(new PropertyName('prototype')), acc]);
+ if (func instanceof Code && func.bound) {
+ this.boundFuncs.push(base);
+ func.bound = false;
+ }
+ }
+ }
+ }
+ results.push(assign);
+ }
+ return results;
+ }).call(this);
+ return compact(exprs);
+ };
+
+ Class.prototype.walkBody = function(name, o) {
+ return this.traverseChildren(false, (function(_this) {
+ return function(child) {
+ var cont, exps, i, j, len1, node, ref3;
+ cont = true;
+ if (child instanceof Class) {
+ return false;
+ }
+ if (child instanceof Block) {
+ ref3 = exps = child.expressions;
+ for (i = j = 0, len1 = ref3.length; j < len1; i = ++j) {
+ node = ref3[i];
+ if (node instanceof Assign && node.variable.looksStatic(name)) {
+ node.value["static"] = true;
+ } else if (node instanceof Value && node.isObject(true)) {
+ cont = false;
+ exps[i] = _this.addProperties(node, name, o);
+ }
+ }
+ child.expressions = exps = flatten(exps);
+ }
+ return cont && !(child instanceof Class);
+ };
+ })(this));
+ };
+
+ Class.prototype.hoistDirectivePrologue = function() {
+ var expressions, index, node;
+ index = 0;
+ expressions = this.body.expressions;
+ while ((node = expressions[index]) && node instanceof Comment || node instanceof Value && node.isString()) {
+ ++index;
+ }
+ return this.directives = expressions.splice(0, index);
+ };
+
+ Class.prototype.ensureConstructor = function(name) {
+ if (!this.ctor) {
+ this.ctor = new Code;
+ if (this.externalCtor) {
+ this.ctor.body.push(new Literal(this.externalCtor + ".apply(this, arguments)"));
+ } else if (this.parent) {
+ this.ctor.body.push(new Literal(name + ".__super__.constructor.apply(this, arguments)"));
+ }
+ this.ctor.body.makeReturn();
+ this.body.expressions.unshift(this.ctor);
+ }
+ this.ctor.ctor = this.ctor.name = name;
+ this.ctor.klass = null;
+ return this.ctor.noReturn = true;
+ };
+
+ Class.prototype.compileNode = function(o) {
+ var args, argumentsNode, func, jumpNode, klass, lname, name, ref3, superClass;
+ if (jumpNode = this.body.jumps()) {
+ jumpNode.error('Class bodies cannot contain pure statements');
+ }
+ if (argumentsNode = this.body.contains(isLiteralArguments)) {
+ argumentsNode.error("Class bodies shouldn't reference arguments");
+ }
+ name = this.determineName();
+ lname = new IdentifierLiteral(name);
+ func = new Code([], Block.wrap([this.body]));
+ args = [];
+ o.classScope = func.makeScope(o.scope);
+ this.hoistDirectivePrologue();
+ this.setContext(name);
+ this.walkBody(name, o);
+ this.ensureConstructor(name);
+ this.addBoundFunctions(o);
+ this.body.spaced = true;
+ this.body.expressions.push(lname);
+ if (this.parent) {
+ superClass = new IdentifierLiteral(o.classScope.freeVariable('superClass', {
+ reserve: false
+ }));
+ this.body.expressions.unshift(new Extends(lname, superClass));
+ func.params.push(new Param(superClass));
+ args.push(this.parent);
+ }
+ (ref3 = this.body.expressions).unshift.apply(ref3, this.directives);
+ klass = new Parens(new Call(func, args));
+ if (this.variable) {
+ klass = new Assign(this.variable, klass, null, {
+ moduleDeclaration: this.moduleDeclaration
+ });
+ }
+ return klass.compileToFragments(o);
+ };
+
+ return Class;
+
+ })(Base);
+
+ exports.ModuleDeclaration = ModuleDeclaration = (function(superClass1) {
+ extend1(ModuleDeclaration, superClass1);
+
+ function ModuleDeclaration(clause, source1) {
+ this.clause = clause;
+ this.source = source1;
+ this.checkSource();
+ }
+
+ ModuleDeclaration.prototype.children = ['clause', 'source'];
+
+ ModuleDeclaration.prototype.isStatement = YES;
+
+ ModuleDeclaration.prototype.jumps = THIS;
+
+ ModuleDeclaration.prototype.makeReturn = THIS;
+
+ ModuleDeclaration.prototype.checkSource = function() {
+ if ((this.source != null) && this.source instanceof StringWithInterpolations) {
+ return this.source.error('the name of the module to be imported from must be an uninterpolated string');
+ }
+ };
+
+ ModuleDeclaration.prototype.checkScope = function(o, moduleDeclarationType) {
+ if (o.indent.length !== 0) {
+ return this.error(moduleDeclarationType + " statements must be at top-level scope");
+ }
+ };
+
+ return ModuleDeclaration;
+
+ })(Base);
+
+ exports.ImportDeclaration = ImportDeclaration = (function(superClass1) {
+ extend1(ImportDeclaration, superClass1);
+
+ function ImportDeclaration() {
+ return ImportDeclaration.__super__.constructor.apply(this, arguments);
+ }
+
+ ImportDeclaration.prototype.compileNode = function(o) {
+ var code, ref3;
+ this.checkScope(o, 'import');
+ o.importedSymbols = [];
+ code = [];
+ code.push(this.makeCode(this.tab + "import "));
+ if (this.clause != null) {
+ code.push.apply(code, this.clause.compileNode(o));
+ }
+ if (((ref3 = this.source) != null ? ref3.value : void 0) != null) {
+ if (this.clause !== null) {
+ code.push(this.makeCode(' from '));
+ }
+ code.push(this.makeCode(this.source.value));
+ }
+ code.push(this.makeCode(';'));
+ return code;
+ };
+
+ return ImportDeclaration;
+
+ })(ModuleDeclaration);
+
+ exports.ImportClause = ImportClause = (function(superClass1) {
+ extend1(ImportClause, superClass1);
+
+ function ImportClause(defaultBinding, namedImports) {
+ this.defaultBinding = defaultBinding;
+ this.namedImports = namedImports;
+ }
+
+ ImportClause.prototype.children = ['defaultBinding', 'namedImports'];
+
+ ImportClause.prototype.compileNode = function(o) {
+ var code;
+ code = [];
+ if (this.defaultBinding != null) {
+ code.push.apply(code, this.defaultBinding.compileNode(o));
+ if (this.namedImports != null) {
+ code.push(this.makeCode(', '));
+ }
+ }
+ if (this.namedImports != null) {
+ code.push.apply(code, this.namedImports.compileNode(o));
+ }
+ return code;
+ };
+
+ return ImportClause;
+
+ })(Base);
+
+ exports.ExportDeclaration = ExportDeclaration = (function(superClass1) {
+ extend1(ExportDeclaration, superClass1);
+
+ function ExportDeclaration() {
+ return ExportDeclaration.__super__.constructor.apply(this, arguments);
+ }
+
+ ExportDeclaration.prototype.compileNode = function(o) {
+ var code, ref3;
+ this.checkScope(o, 'export');
+ code = [];
+ code.push(this.makeCode(this.tab + "export "));
+ if (this instanceof ExportDefaultDeclaration) {
+ code.push(this.makeCode('default '));
+ }
+ if (!(this instanceof ExportDefaultDeclaration) && (this.clause instanceof Assign || this.clause instanceof Class)) {
+ if (this.clause instanceof Class && !this.clause.variable) {
+ this.clause.error('anonymous classes cannot be exported');
+ }
+ code.push(this.makeCode('var '));
+ this.clause.moduleDeclaration = 'export';
+ }
+ if ((this.clause.body != null) && this.clause.body instanceof Block) {
+ code = code.concat(this.clause.compileToFragments(o, LEVEL_TOP));
+ } else {
+ code = code.concat(this.clause.compileNode(o));
+ }
+ if (((ref3 = this.source) != null ? ref3.value : void 0) != null) {
+ code.push(this.makeCode(" from " + this.source.value));
+ }
+ code.push(this.makeCode(';'));
+ return code;
+ };
+
+ return ExportDeclaration;
+
+ })(ModuleDeclaration);
+
+ exports.ExportNamedDeclaration = ExportNamedDeclaration = (function(superClass1) {
+ extend1(ExportNamedDeclaration, superClass1);
+
+ function ExportNamedDeclaration() {
+ return ExportNamedDeclaration.__super__.constructor.apply(this, arguments);
+ }
+
+ return ExportNamedDeclaration;
+
+ })(ExportDeclaration);
+
+ exports.ExportDefaultDeclaration = ExportDefaultDeclaration = (function(superClass1) {
+ extend1(ExportDefaultDeclaration, superClass1);
+
+ function ExportDefaultDeclaration() {
+ return ExportDefaultDeclaration.__super__.constructor.apply(this, arguments);
+ }
+
+ return ExportDefaultDeclaration;
+
+ })(ExportDeclaration);
+
+ exports.ExportAllDeclaration = ExportAllDeclaration = (function(superClass1) {
+ extend1(ExportAllDeclaration, superClass1);
+
+ function ExportAllDeclaration() {
+ return ExportAllDeclaration.__super__.constructor.apply(this, arguments);
+ }
+
+ return ExportAllDeclaration;
+
+ })(ExportDeclaration);
+
+ exports.ModuleSpecifierList = ModuleSpecifierList = (function(superClass1) {
+ extend1(ModuleSpecifierList, superClass1);
+
+ function ModuleSpecifierList(specifiers) {
+ this.specifiers = specifiers;
+ }
+
+ ModuleSpecifierList.prototype.children = ['specifiers'];
+
+ ModuleSpecifierList.prototype.compileNode = function(o) {
+ var code, compiledList, fragments, index, j, len1, specifier;
+ code = [];
+ o.indent += TAB;
+ compiledList = (function() {
+ var j, len1, ref3, results;
+ ref3 = this.specifiers;
+ results = [];
+ for (j = 0, len1 = ref3.length; j < len1; j++) {
+ specifier = ref3[j];
+ results.push(specifier.compileToFragments(o, LEVEL_LIST));
+ }
+ return results;
+ }).call(this);
+ if (this.specifiers.length !== 0) {
+ code.push(this.makeCode("{\n" + o.indent));
+ for (index = j = 0, len1 = compiledList.length; j < len1; index = ++j) {
+ fragments = compiledList[index];
+ if (index) {
+ code.push(this.makeCode(",\n" + o.indent));
+ }
+ code.push.apply(code, fragments);
+ }
+ code.push(this.makeCode("\n}"));
+ } else {
+ code.push(this.makeCode('{}'));
+ }
+ return code;
+ };
+
+ return ModuleSpecifierList;
+
+ })(Base);
+
+ exports.ImportSpecifierList = ImportSpecifierList = (function(superClass1) {
+ extend1(ImportSpecifierList, superClass1);
+
+ function ImportSpecifierList() {
+ return ImportSpecifierList.__super__.constructor.apply(this, arguments);
+ }
+
+ return ImportSpecifierList;
+
+ })(ModuleSpecifierList);
+
+ exports.ExportSpecifierList = ExportSpecifierList = (function(superClass1) {
+ extend1(ExportSpecifierList, superClass1);
+
+ function ExportSpecifierList() {
+ return ExportSpecifierList.__super__.constructor.apply(this, arguments);
+ }
+
+ return ExportSpecifierList;
+
+ })(ModuleSpecifierList);
+
+ exports.ModuleSpecifier = ModuleSpecifier = (function(superClass1) {
+ extend1(ModuleSpecifier, superClass1);
+
+ function ModuleSpecifier(original, alias, moduleDeclarationType1) {
+ this.original = original;
+ this.alias = alias;
+ this.moduleDeclarationType = moduleDeclarationType1;
+ this.identifier = this.alias != null ? this.alias.value : this.original.value;
+ }
+
+ ModuleSpecifier.prototype.children = ['original', 'alias'];
+
+ ModuleSpecifier.prototype.compileNode = function(o) {
+ var code;
+ o.scope.find(this.identifier, this.moduleDeclarationType);
+ code = [];
+ code.push(this.makeCode(this.original.value));
+ if (this.alias != null) {
+ code.push(this.makeCode(" as " + this.alias.value));
+ }
+ return code;
+ };
+
+ return ModuleSpecifier;
+
+ })(Base);
+
+ exports.ImportSpecifier = ImportSpecifier = (function(superClass1) {
+ extend1(ImportSpecifier, superClass1);
+
+ function ImportSpecifier(imported, local) {
+ ImportSpecifier.__super__.constructor.call(this, imported, local, 'import');
+ }
+
+ ImportSpecifier.prototype.compileNode = function(o) {
+ var ref3;
+ if ((ref3 = this.identifier, indexOf.call(o.importedSymbols, ref3) >= 0) || o.scope.check(this.identifier)) {
+ this.error("'" + this.identifier + "' has already been declared");
+ } else {
+ o.importedSymbols.push(this.identifier);
+ }
+ return ImportSpecifier.__super__.compileNode.call(this, o);
+ };
+
+ return ImportSpecifier;
+
+ })(ModuleSpecifier);
+
+ exports.ImportDefaultSpecifier = ImportDefaultSpecifier = (function(superClass1) {
+ extend1(ImportDefaultSpecifier, superClass1);
+
+ function ImportDefaultSpecifier() {
+ return ImportDefaultSpecifier.__super__.constructor.apply(this, arguments);
+ }
+
+ return ImportDefaultSpecifier;
+
+ })(ImportSpecifier);
+
+ exports.ImportNamespaceSpecifier = ImportNamespaceSpecifier = (function(superClass1) {
+ extend1(ImportNamespaceSpecifier, superClass1);
+
+ function ImportNamespaceSpecifier() {
+ return ImportNamespaceSpecifier.__super__.constructor.apply(this, arguments);
+ }
+
+ return ImportNamespaceSpecifier;
+
+ })(ImportSpecifier);
+
+ exports.ExportSpecifier = ExportSpecifier = (function(superClass1) {
+ extend1(ExportSpecifier, superClass1);
+
+ function ExportSpecifier(local, exported) {
+ ExportSpecifier.__super__.constructor.call(this, local, exported, 'export');
+ }
+
+ return ExportSpecifier;
+
+ })(ModuleSpecifier);
+
+ exports.Assign = Assign = (function(superClass1) {
+ extend1(Assign, superClass1);
+
+ function Assign(variable1, value1, context, options) {
+ this.variable = variable1;
+ this.value = value1;
+ this.context = context;
+ if (options == null) {
+ options = {};
+ }
+ this.param = options.param, this.subpattern = options.subpattern, this.operatorToken = options.operatorToken, this.moduleDeclaration = options.moduleDeclaration;
+ }
+
+ Assign.prototype.children = ['variable', 'value'];
+
+ Assign.prototype.isStatement = function(o) {
+ return (o != null ? o.level : void 0) === LEVEL_TOP && (this.context != null) && (this.moduleDeclaration || indexOf.call(this.context, "?") >= 0);
+ };
+
+ Assign.prototype.checkAssignability = function(o, varBase) {
+ if (Object.prototype.hasOwnProperty.call(o.scope.positions, varBase.value) && o.scope.variables[o.scope.positions[varBase.value]].type === 'import') {
+ return varBase.error("'" + varBase.value + "' is read-only");
+ }
+ };
+
+ Assign.prototype.assigns = function(name) {
+ return this[this.context === 'object' ? 'value' : 'variable'].assigns(name);
+ };
+
+ Assign.prototype.unfoldSoak = function(o) {
+ return unfoldSoak(o, this, 'variable');
+ };
+
+ Assign.prototype.compileNode = function(o) {
+ var answer, compiledName, isValue, j, name, properties, prototype, ref3, ref4, ref5, ref6, ref7, ref8, val, varBase;
+ if (isValue = this.variable instanceof Value) {
+ if (this.variable.isArray() || this.variable.isObject()) {
+ return this.compilePatternMatch(o);
+ }
+ if (this.variable.isSplice()) {
+ return this.compileSplice(o);
+ }
+ if ((ref3 = this.context) === '||=' || ref3 === '&&=' || ref3 === '?=') {
+ return this.compileConditional(o);
+ }
+ if ((ref4 = this.context) === '**=' || ref4 === '//=' || ref4 === '%%=') {
+ return this.compileSpecialMath(o);
+ }
+ }
+ if (this.value instanceof Code) {
+ if (this.value["static"]) {
+ this.value.klass = this.variable.base;
+ this.value.name = this.variable.properties[0];
+ this.value.variable = this.variable;
+ } else if (((ref5 = this.variable.properties) != null ? ref5.length : void 0) >= 2) {
+ ref6 = this.variable.properties, properties = 3 <= ref6.length ? slice.call(ref6, 0, j = ref6.length - 2) : (j = 0, []), prototype = ref6[j++], name = ref6[j++];
+ if (((ref7 = prototype.name) != null ? ref7.value : void 0) === 'prototype') {
+ this.value.klass = new Value(this.variable.base, properties);
+ this.value.name = name;
+ this.value.variable = this.variable;
+ }
+ }
+ }
+ if (!this.context) {
+ varBase = this.variable.unwrapAll();
+ if (!varBase.isAssignable()) {
+ this.variable.error("'" + (this.variable.compile(o)) + "' can't be assigned");
+ }
+ if (!(typeof varBase.hasProperties === "function" ? varBase.hasProperties() : void 0)) {
+ if (this.moduleDeclaration) {
+ this.checkAssignability(o, varBase);
+ o.scope.add(varBase.value, this.moduleDeclaration);
+ } else if (this.param) {
+ o.scope.add(varBase.value, 'var');
+ } else {
+ this.checkAssignability(o, varBase);
+ o.scope.find(varBase.value);
+ }
+ }
+ }
+ val = this.value.compileToFragments(o, LEVEL_LIST);
+ if (isValue && this.variable.base instanceof Obj) {
+ this.variable.front = true;
+ }
+ compiledName = this.variable.compileToFragments(o, LEVEL_LIST);
+ if (this.context === 'object') {
+ if (ref8 = fragmentsToText(compiledName), indexOf.call(JS_FORBIDDEN, ref8) >= 0) {
+ compiledName.unshift(this.makeCode('"'));
+ compiledName.push(this.makeCode('"'));
+ }
+ return compiledName.concat(this.makeCode(": "), val);
+ }
+ answer = compiledName.concat(this.makeCode(" " + (this.context || '=') + " "), val);
+ if (o.level <= LEVEL_LIST) {
+ return answer;
+ } else {
+ return this.wrapInBraces(answer);
+ }
+ };
+
+ Assign.prototype.compilePatternMatch = function(o) {
+ var acc, assigns, code, defaultValue, expandedIdx, fragments, i, idx, isObject, ivar, j, len1, message, name, obj, objects, olen, ref, ref3, ref4, ref5, ref6, rest, top, val, value, vvar, vvarText;
+ top = o.level === LEVEL_TOP;
+ value = this.value;
+ objects = this.variable.base.objects;
+ if (!(olen = objects.length)) {
+ code = value.compileToFragments(o);
+ if (o.level >= LEVEL_OP) {
+ return this.wrapInBraces(code);
+ } else {
+ return code;
+ }
+ }
+ obj = objects[0];
+ if (olen === 1 && obj instanceof Expansion) {
+ obj.error('Destructuring assignment has no target');
+ }
+ isObject = this.variable.isObject();
+ if (top && olen === 1 && !(obj instanceof Splat)) {
+ defaultValue = null;
+ if (obj instanceof Assign && obj.context === 'object') {
+ ref3 = obj, (ref4 = ref3.variable, idx = ref4.base), obj = ref3.value;
+ if (obj instanceof Assign) {
+ defaultValue = obj.value;
+ obj = obj.variable;
+ }
+ } else {
+ if (obj instanceof Assign) {
+ defaultValue = obj.value;
+ obj = obj.variable;
+ }
+ idx = isObject ? obj["this"] ? obj.properties[0].name : new PropertyName(obj.unwrap().value) : new NumberLiteral(0);
+ }
+ acc = idx.unwrap() instanceof PropertyName;
+ value = new Value(value);
+ value.properties.push(new (acc ? Access : Index)(idx));
+ message = isUnassignable(obj.unwrap().value);
+ if (message) {
+ obj.error(message);
+ }
+ if (defaultValue) {
+ value = new Op('?', value, defaultValue);
+ }
+ return new Assign(obj, value, null, {
+ param: this.param
+ }).compileToFragments(o, LEVEL_TOP);
+ }
+ vvar = value.compileToFragments(o, LEVEL_LIST);
+ vvarText = fragmentsToText(vvar);
+ assigns = [];
+ expandedIdx = false;
+ if (!(value.unwrap() instanceof IdentifierLiteral) || this.variable.assigns(vvarText)) {
+ assigns.push([this.makeCode((ref = o.scope.freeVariable('ref')) + " = ")].concat(slice.call(vvar)));
+ vvar = [this.makeCode(ref)];
+ vvarText = ref;
+ }
+ for (i = j = 0, len1 = objects.length; j < len1; i = ++j) {
+ obj = objects[i];
+ idx = i;
+ if (!expandedIdx && obj instanceof Splat) {
+ name = obj.name.unwrap().value;
+ obj = obj.unwrap();
+ val = olen + " <= " + vvarText + ".length ? " + (utility('slice', o)) + ".call(" + vvarText + ", " + i;
+ if (rest = olen - i - 1) {
+ ivar = o.scope.freeVariable('i', {
+ single: true
+ });
+ val += ", " + ivar + " = " + vvarText + ".length - " + rest + ") : (" + ivar + " = " + i + ", [])";
+ } else {
+ val += ") : []";
+ }
+ val = new Literal(val);
+ expandedIdx = ivar + "++";
+ } else if (!expandedIdx && obj instanceof Expansion) {
+ if (rest = olen - i - 1) {
+ if (rest === 1) {
+ expandedIdx = vvarText + ".length - 1";
+ } else {
+ ivar = o.scope.freeVariable('i', {
+ single: true
+ });
+ val = new Literal(ivar + " = " + vvarText + ".length - " + rest);
+ expandedIdx = ivar + "++";
+ assigns.push(val.compileToFragments(o, LEVEL_LIST));
+ }
+ }
+ continue;
+ } else {
+ if (obj instanceof Splat || obj instanceof Expansion) {
+ obj.error("multiple splats/expansions are disallowed in an assignment");
+ }
+ defaultValue = null;
+ if (obj instanceof Assign && obj.context === 'object') {
+ ref5 = obj, (ref6 = ref5.variable, idx = ref6.base), obj = ref5.value;
+ if (obj instanceof Assign) {
+ defaultValue = obj.value;
+ obj = obj.variable;
+ }
+ } else {
+ if (obj instanceof Assign) {
+ defaultValue = obj.value;
+ obj = obj.variable;
+ }
+ idx = isObject ? obj["this"] ? obj.properties[0].name : new PropertyName(obj.unwrap().value) : new Literal(expandedIdx || idx);
+ }
+ name = obj.unwrap().value;
+ acc = idx.unwrap() instanceof PropertyName;
+ val = new Value(new Literal(vvarText), [new (acc ? Access : Index)(idx)]);
+ if (defaultValue) {
+ val = new Op('?', val, defaultValue);
+ }
+ }
+ if (name != null) {
+ message = isUnassignable(name);
+ if (message) {
+ obj.error(message);
+ }
+ }
+ assigns.push(new Assign(obj, val, null, {
+ param: this.param,
+ subpattern: true
+ }).compileToFragments(o, LEVEL_LIST));
+ }
+ if (!(top || this.subpattern)) {
+ assigns.push(vvar);
+ }
+ fragments = this.joinFragmentArrays(assigns, ', ');
+ if (o.level < LEVEL_LIST) {
+ return fragments;
+ } else {
+ return this.wrapInBraces(fragments);
+ }
+ };
+
+ Assign.prototype.compileConditional = function(o) {
+ var fragments, left, ref3, right;
+ ref3 = this.variable.cacheReference(o), left = ref3[0], right = ref3[1];
+ if (!left.properties.length && left.base instanceof Literal && !(left.base instanceof ThisLiteral) && !o.scope.check(left.base.value)) {
+ this.variable.error("the variable \"" + left.base.value + "\" can't be assigned with " + this.context + " because it has not been declared before");
+ }
+ if (indexOf.call(this.context, "?") >= 0) {
+ o.isExistentialEquals = true;
+ return new If(new Existence(left), right, {
+ type: 'if'
+ }).addElse(new Assign(right, this.value, '=')).compileToFragments(o);
+ } else {
+ fragments = new Op(this.context.slice(0, -1), left, new Assign(right, this.value, '=')).compileToFragments(o);
+ if (o.level <= LEVEL_LIST) {
+ return fragments;
+ } else {
+ return this.wrapInBraces(fragments);
+ }
+ }
+ };
+
+ Assign.prototype.compileSpecialMath = function(o) {
+ var left, ref3, right;
+ ref3 = this.variable.cacheReference(o), left = ref3[0], right = ref3[1];
+ return new Assign(left, new Op(this.context.slice(0, -1), right, this.value)).compileToFragments(o);
+ };
+
+ Assign.prototype.compileSplice = function(o) {
+ var answer, exclusive, from, fromDecl, fromRef, name, ref3, ref4, ref5, to, valDef, valRef;
+ ref3 = this.variable.properties.pop().range, from = ref3.from, to = ref3.to, exclusive = ref3.exclusive;
+ name = this.variable.compile(o);
+ if (from) {
+ ref4 = this.cacheToCodeFragments(from.cache(o, LEVEL_OP)), fromDecl = ref4[0], fromRef = ref4[1];
+ } else {
+ fromDecl = fromRef = '0';
+ }
+ if (to) {
+ if ((from != null ? from.isNumber() : void 0) && to.isNumber()) {
+ to = to.compile(o) - fromRef;
+ if (!exclusive) {
+ to += 1;
+ }
+ } else {
+ to = to.compile(o, LEVEL_ACCESS) + ' - ' + fromRef;
+ if (!exclusive) {
+ to += ' + 1';
+ }
+ }
+ } else {
+ to = "9e9";
+ }
+ ref5 = this.value.cache(o, LEVEL_LIST), valDef = ref5[0], valRef = ref5[1];
+ answer = [].concat(this.makeCode("[].splice.apply(" + name + ", [" + fromDecl + ", " + to + "].concat("), valDef, this.makeCode(")), "), valRef);
+ if (o.level > LEVEL_TOP) {
+ return this.wrapInBraces(answer);
+ } else {
+ return answer;
+ }
+ };
+
+ return Assign;
+
+ })(Base);
+
+ exports.Code = Code = (function(superClass1) {
+ extend1(Code, superClass1);
+
+ function Code(params, body, tag) {
+ this.params = params || [];
+ this.body = body || new Block;
+ this.bound = tag === 'boundfunc';
+ this.isGenerator = !!this.body.contains(function(node) {
+ return (node instanceof Op && node.isYield()) || node instanceof YieldReturn;
+ });
+ }
+
+ Code.prototype.children = ['params', 'body'];
+
+ Code.prototype.isStatement = function() {
+ return !!this.ctor;
+ };
+
+ Code.prototype.jumps = NO;
+
+ Code.prototype.makeScope = function(parentScope) {
+ return new Scope(parentScope, this.body, this);
+ };
+
+ Code.prototype.compileNode = function(o) {
+ var answer, boundfunc, code, exprs, i, j, k, l, len1, len2, len3, len4, len5, len6, lit, m, p, param, params, q, r, ref, ref3, ref4, ref5, ref6, ref7, ref8, splats, uniqs, val, wasEmpty, wrapper;
+ if (this.bound && ((ref3 = o.scope.method) != null ? ref3.bound : void 0)) {
+ this.context = o.scope.method.context;
+ }
+ if (this.bound && !this.context) {
+ this.context = '_this';
+ wrapper = new Code([new Param(new IdentifierLiteral(this.context))], new Block([this]));
+ boundfunc = new Call(wrapper, [new ThisLiteral]);
+ boundfunc.updateLocationDataIfMissing(this.locationData);
+ return boundfunc.compileNode(o);
+ }
+ o.scope = del(o, 'classScope') || this.makeScope(o.scope);
+ o.scope.shared = del(o, 'sharedScope');
+ o.indent += TAB;
+ delete o.bare;
+ delete o.isExistentialEquals;
+ params = [];
+ exprs = [];
+ ref4 = this.params;
+ for (j = 0, len1 = ref4.length; j < len1; j++) {
+ param = ref4[j];
+ if (!(param instanceof Expansion)) {
+ o.scope.parameter(param.asReference(o));
+ }
+ }
+ ref5 = this.params;
+ for (k = 0, len2 = ref5.length; k < len2; k++) {
+ param = ref5[k];
+ if (!(param.splat || param instanceof Expansion)) {
+ continue;
+ }
+ ref6 = this.params;
+ for (l = 0, len3 = ref6.length; l < len3; l++) {
+ p = ref6[l];
+ if (!(p instanceof Expansion) && p.name.value) {
+ o.scope.add(p.name.value, 'var', true);
+ }
+ }
+ splats = new Assign(new Value(new Arr((function() {
+ var len4, m, ref7, results;
+ ref7 = this.params;
+ results = [];
+ for (m = 0, len4 = ref7.length; m < len4; m++) {
+ p = ref7[m];
+ results.push(p.asReference(o));
+ }
+ return results;
+ }).call(this))), new Value(new IdentifierLiteral('arguments')));
+ break;
+ }
+ ref7 = this.params;
+ for (m = 0, len4 = ref7.length; m < len4; m++) {
+ param = ref7[m];
+ if (param.isComplex()) {
+ val = ref = param.asReference(o);
+ if (param.value) {
+ val = new Op('?', ref, param.value);
+ }
+ exprs.push(new Assign(new Value(param.name), val, '=', {
+ param: true
+ }));
+ } else {
+ ref = param;
+ if (param.value) {
+ lit = new Literal(ref.name.value + ' == null');
+ val = new Assign(new Value(param.name), param.value, '=');
+ exprs.push(new If(lit, val));
+ }
+ }
+ if (!splats) {
+ params.push(ref);
+ }
+ }
+ wasEmpty = this.body.isEmpty();
+ if (splats) {
+ exprs.unshift(splats);
+ }
+ if (exprs.length) {
+ (ref8 = this.body.expressions).unshift.apply(ref8, exprs);
+ }
+ for (i = q = 0, len5 = params.length; q < len5; i = ++q) {
+ p = params[i];
+ params[i] = p.compileToFragments(o);
+ o.scope.parameter(fragmentsToText(params[i]));
+ }
+ uniqs = [];
+ this.eachParamName(function(name, node) {
+ if (indexOf.call(uniqs, name) >= 0) {
+ node.error("multiple parameters named " + name);
+ }
+ return uniqs.push(name);
+ });
+ if (!(wasEmpty || this.noReturn)) {
+ this.body.makeReturn();
+ }
+ code = 'function';
+ if (this.isGenerator) {
+ code += '*';
+ }
+ if (this.ctor) {
+ code += ' ' + this.name;
+ }
+ code += '(';
+ answer = [this.makeCode(code)];
+ for (i = r = 0, len6 = params.length; r < len6; i = ++r) {
+ p = params[i];
+ if (i) {
+ answer.push(this.makeCode(", "));
+ }
+ answer.push.apply(answer, p);
+ }
+ answer.push(this.makeCode(') {'));
+ if (!this.body.isEmpty()) {
+ answer = answer.concat(this.makeCode("\n"), this.body.compileWithDeclarations(o), this.makeCode("\n" + this.tab));
+ }
+ answer.push(this.makeCode('}'));
+ if (this.ctor) {
+ return [this.makeCode(this.tab)].concat(slice.call(answer));
+ }
+ if (this.front || (o.level >= LEVEL_ACCESS)) {
+ return this.wrapInBraces(answer);
+ } else {
+ return answer;
+ }
+ };
+
+ Code.prototype.eachParamName = function(iterator) {
+ var j, len1, param, ref3, results;
+ ref3 = this.params;
+ results = [];
+ for (j = 0, len1 = ref3.length; j < len1; j++) {
+ param = ref3[j];
+ results.push(param.eachName(iterator));
+ }
+ return results;
+ };
+
+ Code.prototype.traverseChildren = function(crossScope, func) {
+ if (crossScope) {
+ return Code.__super__.traverseChildren.call(this, crossScope, func);
+ }
+ };
+
+ return Code;
+
+ })(Base);
+
+ exports.Param = Param = (function(superClass1) {
+ extend1(Param, superClass1);
+
+ function Param(name1, value1, splat) {
+ var message, token;
+ this.name = name1;
+ this.value = value1;
+ this.splat = splat;
+ message = isUnassignable(this.name.unwrapAll().value);
+ if (message) {
+ this.name.error(message);
+ }
+ if (this.name instanceof Obj && this.name.generated) {
+ token = this.name.objects[0].operatorToken;
+ token.error("unexpected " + token.value);
+ }
+ }
+
+ Param.prototype.children = ['name', 'value'];
+
+ Param.prototype.compileToFragments = function(o) {
+ return this.name.compileToFragments(o, LEVEL_LIST);
+ };
+
+ Param.prototype.asReference = function(o) {
+ var name, node;
+ if (this.reference) {
+ return this.reference;
+ }
+ node = this.name;
+ if (node["this"]) {
+ name = node.properties[0].name.value;
+ if (indexOf.call(JS_FORBIDDEN, name) >= 0) {
+ name = "_" + name;
+ }
+ node = new IdentifierLiteral(o.scope.freeVariable(name));
+ } else if (node.isComplex()) {
+ node = new IdentifierLiteral(o.scope.freeVariable('arg'));
+ }
+ node = new Value(node);
+ if (this.splat) {
+ node = new Splat(node);
+ }
+ node.updateLocationDataIfMissing(this.locationData);
+ return this.reference = node;
+ };
+
+ Param.prototype.isComplex = function() {
+ return this.name.isComplex();
+ };
+
+ Param.prototype.eachName = function(iterator, name) {
+ var atParam, j, len1, node, obj, ref3, ref4;
+ if (name == null) {
+ name = this.name;
+ }
+ atParam = function(obj) {
+ return iterator("@" + obj.properties[0].name.value, obj);
+ };
+ if (name instanceof Literal) {
+ return iterator(name.value, name);
+ }
+ if (name instanceof Value) {
+ return atParam(name);
+ }
+ ref4 = (ref3 = name.objects) != null ? ref3 : [];
+ for (j = 0, len1 = ref4.length; j < len1; j++) {
+ obj = ref4[j];
+ if (obj instanceof Assign && (obj.context == null)) {
+ obj = obj.variable;
+ }
+ if (obj instanceof Assign) {
+ if (obj.value instanceof Assign) {
+ obj = obj.value;
+ }
+ this.eachName(iterator, obj.value.unwrap());
+ } else if (obj instanceof Splat) {
+ node = obj.name.unwrap();
+ iterator(node.value, node);
+ } else if (obj instanceof Value) {
+ if (obj.isArray() || obj.isObject()) {
+ this.eachName(iterator, obj.base);
+ } else if (obj["this"]) {
+ atParam(obj);
+ } else {
+ iterator(obj.base.value, obj.base);
+ }
+ } else if (!(obj instanceof Expansion)) {
+ obj.error("illegal parameter " + (obj.compile()));
+ }
+ }
+ };
+
+ return Param;
+
+ })(Base);
+
+ exports.Splat = Splat = (function(superClass1) {
+ extend1(Splat, superClass1);
+
+ Splat.prototype.children = ['name'];
+
+ Splat.prototype.isAssignable = YES;
+
+ function Splat(name) {
+ this.name = name.compile ? name : new Literal(name);
+ }
+
+ Splat.prototype.assigns = function(name) {
+ return this.name.assigns(name);
+ };
+
+ Splat.prototype.compileToFragments = function(o) {
+ return this.name.compileToFragments(o);
+ };
+
+ Splat.prototype.unwrap = function() {
+ return this.name;
+ };
+
+ Splat.compileSplattedArray = function(o, list, apply) {
+ var args, base, compiledNode, concatPart, fragments, i, index, j, last, len1, node;
+ index = -1;
+ while ((node = list[++index]) && !(node instanceof Splat)) {
+ continue;
+ }
+ if (index >= list.length) {
+ return [];
+ }
+ if (list.length === 1) {
+ node = list[0];
+ fragments = node.compileToFragments(o, LEVEL_LIST);
+ if (apply) {
+ return fragments;
+ }
+ return [].concat(node.makeCode((utility('slice', o)) + ".call("), fragments, node.makeCode(")"));
+ }
+ args = list.slice(index);
+ for (i = j = 0, len1 = args.length; j < len1; i = ++j) {
+ node = args[i];
+ compiledNode = node.compileToFragments(o, LEVEL_LIST);
+ args[i] = node instanceof Splat ? [].concat(node.makeCode((utility('slice', o)) + ".call("), compiledNode, node.makeCode(")")) : [].concat(node.makeCode("["), compiledNode, node.makeCode("]"));
+ }
+ if (index === 0) {
+ node = list[0];
+ concatPart = node.joinFragmentArrays(args.slice(1), ', ');
+ return args[0].concat(node.makeCode(".concat("), concatPart, node.makeCode(")"));
+ }
+ base = (function() {
+ var k, len2, ref3, results;
+ ref3 = list.slice(0, index);
+ results = [];
+ for (k = 0, len2 = ref3.length; k < len2; k++) {
+ node = ref3[k];
+ results.push(node.compileToFragments(o, LEVEL_LIST));
+ }
+ return results;
+ })();
+ base = list[0].joinFragmentArrays(base, ', ');
+ concatPart = list[index].joinFragmentArrays(args, ', ');
+ last = list[list.length - 1];
+ return [].concat(list[0].makeCode("["), base, list[index].makeCode("].concat("), concatPart, last.makeCode(")"));
+ };
+
+ return Splat;
+
+ })(Base);
+
+ exports.Expansion = Expansion = (function(superClass1) {
+ extend1(Expansion, superClass1);
+
+ function Expansion() {
+ return Expansion.__super__.constructor.apply(this, arguments);
+ }
+
+ Expansion.prototype.isComplex = NO;
+
+ Expansion.prototype.compileNode = function(o) {
+ return this.error('Expansion must be used inside a destructuring assignment or parameter list');
+ };
+
+ Expansion.prototype.asReference = function(o) {
+ return this;
+ };
+
+ Expansion.prototype.eachName = function(iterator) {};
+
+ return Expansion;
+
+ })(Base);
+
+ exports.While = While = (function(superClass1) {
+ extend1(While, superClass1);
+
+ function While(condition, options) {
+ this.condition = (options != null ? options.invert : void 0) ? condition.invert() : condition;
+ this.guard = options != null ? options.guard : void 0;
+ }
+
+ While.prototype.children = ['condition', 'guard', 'body'];
+
+ While.prototype.isStatement = YES;
+
+ While.prototype.makeReturn = function(res) {
+ if (res) {
+ return While.__super__.makeReturn.apply(this, arguments);
+ } else {
+ this.returns = !this.jumps({
+ loop: true
+ });
+ return this;
+ }
+ };
+
+ While.prototype.addBody = function(body1) {
+ this.body = body1;
+ return this;
+ };
+
+ While.prototype.jumps = function() {
+ var expressions, j, jumpNode, len1, node;
+ expressions = this.body.expressions;
+ if (!expressions.length) {
+ return false;
+ }
+ for (j = 0, len1 = expressions.length; j < len1; j++) {
+ node = expressions[j];
+ if (jumpNode = node.jumps({
+ loop: true
+ })) {
+ return jumpNode;
+ }
+ }
+ return false;
+ };
+
+ While.prototype.compileNode = function(o) {
+ var answer, body, rvar, set;
+ o.indent += TAB;
+ set = '';
+ body = this.body;
+ if (body.isEmpty()) {
+ body = this.makeCode('');
+ } else {
+ if (this.returns) {
+ body.makeReturn(rvar = o.scope.freeVariable('results'));
+ set = "" + this.tab + rvar + " = [];\n";
+ }
+ if (this.guard) {
+ if (body.expressions.length > 1) {
+ body.expressions.unshift(new If((new Parens(this.guard)).invert(), new StatementLiteral("continue")));
+ } else {
+ if (this.guard) {
+ body = Block.wrap([new If(this.guard, body)]);
+ }
+ }
+ }
+ body = [].concat(this.makeCode("\n"), body.compileToFragments(o, LEVEL_TOP), this.makeCode("\n" + this.tab));
+ }
+ answer = [].concat(this.makeCode(set + this.tab + "while ("), this.condition.compileToFragments(o, LEVEL_PAREN), this.makeCode(") {"), body, this.makeCode("}"));
+ if (this.returns) {
+ answer.push(this.makeCode("\n" + this.tab + "return " + rvar + ";"));
+ }
+ return answer;
+ };
+
+ return While;
+
+ })(Base);
+
+ exports.Op = Op = (function(superClass1) {
+ var CONVERSIONS, INVERSIONS;
+
+ extend1(Op, superClass1);
+
+ function Op(op, first, second, flip) {
+ if (op === 'in') {
+ return new In(first, second);
+ }
+ if (op === 'do') {
+ return this.generateDo(first);
+ }
+ if (op === 'new') {
+ if (first instanceof Call && !first["do"] && !first.isNew) {
+ return first.newInstance();
+ }
+ if (first instanceof Code && first.bound || first["do"]) {
+ first = new Parens(first);
+ }
+ }
+ this.operator = CONVERSIONS[op] || op;
+ this.first = first;
+ this.second = second;
+ this.flip = !!flip;
+ return this;
+ }
+
+ CONVERSIONS = {
+ '==': '===',
+ '!=': '!==',
+ 'of': 'in',
+ 'yieldfrom': 'yield*'
+ };
+
+ INVERSIONS = {
+ '!==': '===',
+ '===': '!=='
+ };
+
+ Op.prototype.children = ['first', 'second'];
+
+ Op.prototype.isNumber = function() {
+ var ref3;
+ return this.isUnary() && ((ref3 = this.operator) === '+' || ref3 === '-') && this.first instanceof Value && this.first.isNumber();
+ };
+
+ Op.prototype.isYield = function() {
+ var ref3;
+ return (ref3 = this.operator) === 'yield' || ref3 === 'yield*';
+ };
+
+ Op.prototype.isUnary = function() {
+ return !this.second;
+ };
+
+ Op.prototype.isComplex = function() {
+ return !this.isNumber();
+ };
+
+ Op.prototype.isChainable = function() {
+ var ref3;
+ return (ref3 = this.operator) === '<' || ref3 === '>' || ref3 === '>=' || ref3 === '<=' || ref3 === '===' || ref3 === '!==';
+ };
+
+ Op.prototype.invert = function() {
+ var allInvertable, curr, fst, op, ref3;
+ if (this.isChainable() && this.first.isChainable()) {
+ allInvertable = true;
+ curr = this;
+ while (curr && curr.operator) {
+ allInvertable && (allInvertable = curr.operator in INVERSIONS);
+ curr = curr.first;
+ }
+ if (!allInvertable) {
+ return new Parens(this).invert();
+ }
+ curr = this;
+ while (curr && curr.operator) {
+ curr.invert = !curr.invert;
+ curr.operator = INVERSIONS[curr.operator];
+ curr = curr.first;
+ }
+ return this;
+ } else if (op = INVERSIONS[this.operator]) {
+ this.operator = op;
+ if (this.first.unwrap() instanceof Op) {
+ this.first.invert();
+ }
+ return this;
+ } else if (this.second) {
+ return new Parens(this).invert();
+ } else if (this.operator === '!' && (fst = this.first.unwrap()) instanceof Op && ((ref3 = fst.operator) === '!' || ref3 === 'in' || ref3 === 'instanceof')) {
+ return fst;
+ } else {
+ return new Op('!', this);
+ }
+ };
+
+ Op.prototype.unfoldSoak = function(o) {
+ var ref3;
+ return ((ref3 = this.operator) === '++' || ref3 === '--' || ref3 === 'delete') && unfoldSoak(o, this, 'first');
+ };
+
+ Op.prototype.generateDo = function(exp) {
+ var call, func, j, len1, param, passedParams, ref, ref3;
+ passedParams = [];
+ func = exp instanceof Assign && (ref = exp.value.unwrap()) instanceof Code ? ref : exp;
+ ref3 = func.params || [];
+ for (j = 0, len1 = ref3.length; j < len1; j++) {
+ param = ref3[j];
+ if (param.value) {
+ passedParams.push(param.value);
+ delete param.value;
+ } else {
+ passedParams.push(param);
+ }
+ }
+ call = new Call(exp, passedParams);
+ call["do"] = true;
+ return call;
+ };
+
+ Op.prototype.compileNode = function(o) {
+ var answer, isChain, lhs, message, ref3, rhs;
+ isChain = this.isChainable() && this.first.isChainable();
+ if (!isChain) {
+ this.first.front = this.front;
+ }
+ if (this.operator === 'delete' && o.scope.check(this.first.unwrapAll().value)) {
+ this.error('delete operand may not be argument or var');
+ }
+ if ((ref3 = this.operator) === '--' || ref3 === '++') {
+ message = isUnassignable(this.first.unwrapAll().value);
+ if (message) {
+ this.first.error(message);
+ }
+ }
+ if (this.isYield()) {
+ return this.compileYield(o);
+ }
+ if (this.isUnary()) {
+ return this.compileUnary(o);
+ }
+ if (isChain) {
+ return this.compileChain(o);
+ }
+ switch (this.operator) {
+ case '?':
+ return this.compileExistence(o);
+ case '**':
+ return this.compilePower(o);
+ case '//':
+ return this.compileFloorDivision(o);
+ case '%%':
+ return this.compileModulo(o);
+ default:
+ lhs = this.first.compileToFragments(o, LEVEL_OP);
+ rhs = this.second.compileToFragments(o, LEVEL_OP);
+ answer = [].concat(lhs, this.makeCode(" " + this.operator + " "), rhs);
+ if (o.level <= LEVEL_OP) {
+ return answer;
+ } else {
+ return this.wrapInBraces(answer);
+ }
+ }
+ };
+
+ Op.prototype.compileChain = function(o) {
+ var fragments, fst, ref3, shared;
+ ref3 = this.first.second.cache(o), this.first.second = ref3[0], shared = ref3[1];
+ fst = this.first.compileToFragments(o, LEVEL_OP);
+ fragments = fst.concat(this.makeCode(" " + (this.invert ? '&&' : '||') + " "), shared.compileToFragments(o), this.makeCode(" " + this.operator + " "), this.second.compileToFragments(o, LEVEL_OP));
+ return this.wrapInBraces(fragments);
+ };
+
+ Op.prototype.compileExistence = function(o) {
+ var fst, ref;
+ if (this.first.isComplex()) {
+ ref = new IdentifierLiteral(o.scope.freeVariable('ref'));
+ fst = new Parens(new Assign(ref, this.first));
+ } else {
+ fst = this.first;
+ ref = fst;
+ }
+ return new If(new Existence(fst), ref, {
+ type: 'if'
+ }).addElse(this.second).compileToFragments(o);
+ };
+
+ Op.prototype.compileUnary = function(o) {
+ var op, parts, plusMinus;
+ parts = [];
+ op = this.operator;
+ parts.push([this.makeCode(op)]);
+ if (op === '!' && this.first instanceof Existence) {
+ this.first.negated = !this.first.negated;
+ return this.first.compileToFragments(o);
+ }
+ if (o.level >= LEVEL_ACCESS) {
+ return (new Parens(this)).compileToFragments(o);
+ }
+ plusMinus = op === '+' || op === '-';
+ if ((op === 'new' || op === 'typeof' || op === 'delete') || plusMinus && this.first instanceof Op && this.first.operator === op) {
+ parts.push([this.makeCode(' ')]);
+ }
+ if ((plusMinus && this.first instanceof Op) || (op === 'new' && this.first.isStatement(o))) {
+ this.first = new Parens(this.first);
+ }
+ parts.push(this.first.compileToFragments(o, LEVEL_OP));
+ if (this.flip) {
+ parts.reverse();
+ }
+ return this.joinFragmentArrays(parts, '');
+ };
+
+ Op.prototype.compileYield = function(o) {
+ var op, parts, ref3;
+ parts = [];
+ op = this.operator;
+ if (o.scope.parent == null) {
+ this.error('yield can only occur inside functions');
+ }
+ if (indexOf.call(Object.keys(this.first), 'expression') >= 0 && !(this.first instanceof Throw)) {
+ if (this.first.expression != null) {
+ parts.push(this.first.expression.compileToFragments(o, LEVEL_OP));
+ }
+ } else {
+ if (o.level >= LEVEL_PAREN) {
+ parts.push([this.makeCode("(")]);
+ }
+ parts.push([this.makeCode(op)]);
+ if (((ref3 = this.first.base) != null ? ref3.value : void 0) !== '') {
+ parts.push([this.makeCode(" ")]);
+ }
+ parts.push(this.first.compileToFragments(o, LEVEL_OP));
+ if (o.level >= LEVEL_PAREN) {
+ parts.push([this.makeCode(")")]);
+ }
+ }
+ return this.joinFragmentArrays(parts, '');
+ };
+
+ Op.prototype.compilePower = function(o) {
+ var pow;
+ pow = new Value(new IdentifierLiteral('Math'), [new Access(new PropertyName('pow'))]);
+ return new Call(pow, [this.first, this.second]).compileToFragments(o);
+ };
+
+ Op.prototype.compileFloorDivision = function(o) {
+ var div, floor, second;
+ floor = new Value(new IdentifierLiteral('Math'), [new Access(new PropertyName('floor'))]);
+ second = this.second.isComplex() ? new Parens(this.second) : this.second;
+ div = new Op('/', this.first, second);
+ return new Call(floor, [div]).compileToFragments(o);
+ };
+
+ Op.prototype.compileModulo = function(o) {
+ var mod;
+ mod = new Value(new Literal(utility('modulo', o)));
+ return new Call(mod, [this.first, this.second]).compileToFragments(o);
+ };
+
+ Op.prototype.toString = function(idt) {
+ return Op.__super__.toString.call(this, idt, this.constructor.name + ' ' + this.operator);
+ };
+
+ return Op;
+
+ })(Base);
+
+ exports.In = In = (function(superClass1) {
+ extend1(In, superClass1);
+
+ function In(object, array) {
+ this.object = object;
+ this.array = array;
+ }
+
+ In.prototype.children = ['object', 'array'];
+
+ In.prototype.invert = NEGATE;
+
+ In.prototype.compileNode = function(o) {
+ var hasSplat, j, len1, obj, ref3;
+ if (this.array instanceof Value && this.array.isArray() && this.array.base.objects.length) {
+ ref3 = this.array.base.objects;
+ for (j = 0, len1 = ref3.length; j < len1; j++) {
+ obj = ref3[j];
+ if (!(obj instanceof Splat)) {
+ continue;
+ }
+ hasSplat = true;
+ break;
+ }
+ if (!hasSplat) {
+ return this.compileOrTest(o);
+ }
+ }
+ return this.compileLoopTest(o);
+ };
+
+ In.prototype.compileOrTest = function(o) {
+ var cmp, cnj, i, item, j, len1, ref, ref3, ref4, ref5, sub, tests;
+ ref3 = this.object.cache(o, LEVEL_OP), sub = ref3[0], ref = ref3[1];
+ ref4 = this.negated ? [' !== ', ' && '] : [' === ', ' || '], cmp = ref4[0], cnj = ref4[1];
+ tests = [];
+ ref5 = this.array.base.objects;
+ for (i = j = 0, len1 = ref5.length; j < len1; i = ++j) {
+ item = ref5[i];
+ if (i) {
+ tests.push(this.makeCode(cnj));
+ }
+ tests = tests.concat((i ? ref : sub), this.makeCode(cmp), item.compileToFragments(o, LEVEL_ACCESS));
+ }
+ if (o.level < LEVEL_OP) {
+ return tests;
+ } else {
+ return this.wrapInBraces(tests);
+ }
+ };
+
+ In.prototype.compileLoopTest = function(o) {
+ var fragments, ref, ref3, sub;
+ ref3 = this.object.cache(o, LEVEL_LIST), sub = ref3[0], ref = ref3[1];
+ fragments = [].concat(this.makeCode(utility('indexOf', o) + ".call("), this.array.compileToFragments(o, LEVEL_LIST), this.makeCode(", "), ref, this.makeCode(") " + (this.negated ? '< 0' : '>= 0')));
+ if (fragmentsToText(sub) === fragmentsToText(ref)) {
+ return fragments;
+ }
+ fragments = sub.concat(this.makeCode(', '), fragments);
+ if (o.level < LEVEL_LIST) {
+ return fragments;
+ } else {
+ return this.wrapInBraces(fragments);
+ }
+ };
+
+ In.prototype.toString = function(idt) {
+ return In.__super__.toString.call(this, idt, this.constructor.name + (this.negated ? '!' : ''));
+ };
+
+ return In;
+
+ })(Base);
+
+ exports.Try = Try = (function(superClass1) {
+ extend1(Try, superClass1);
+
+ function Try(attempt, errorVariable, recovery, ensure) {
+ this.attempt = attempt;
+ this.errorVariable = errorVariable;
+ this.recovery = recovery;
+ this.ensure = ensure;
+ }
+
+ Try.prototype.children = ['attempt', 'recovery', 'ensure'];
+
+ Try.prototype.isStatement = YES;
+
+ Try.prototype.jumps = function(o) {
+ var ref3;
+ return this.attempt.jumps(o) || ((ref3 = this.recovery) != null ? ref3.jumps(o) : void 0);
+ };
+
+ Try.prototype.makeReturn = function(res) {
+ if (this.attempt) {
+ this.attempt = this.attempt.makeReturn(res);
+ }
+ if (this.recovery) {
+ this.recovery = this.recovery.makeReturn(res);
+ }
+ return this;
+ };
+
+ Try.prototype.compileNode = function(o) {
+ var catchPart, ensurePart, generatedErrorVariableName, message, placeholder, tryPart;
+ o.indent += TAB;
+ tryPart = this.attempt.compileToFragments(o, LEVEL_TOP);
+ catchPart = this.recovery ? (generatedErrorVariableName = o.scope.freeVariable('error', {
+ reserve: false
+ }), placeholder = new IdentifierLiteral(generatedErrorVariableName), this.errorVariable ? (message = isUnassignable(this.errorVariable.unwrapAll().value), message ? this.errorVariable.error(message) : void 0, this.recovery.unshift(new Assign(this.errorVariable, placeholder))) : void 0, [].concat(this.makeCode(" catch ("), placeholder.compileToFragments(o), this.makeCode(") {\n"), this.recovery.compileToFragments(o, LEVEL_TOP), this.makeCode("\n" + this.tab + "}"))) : !(this.ensure || this.recovery) ? (generatedErrorVariableName = o.scope.freeVariable('error', {
+ reserve: false
+ }), [this.makeCode(" catch (" + generatedErrorVariableName + ") {}")]) : [];
+ ensurePart = this.ensure ? [].concat(this.makeCode(" finally {\n"), this.ensure.compileToFragments(o, LEVEL_TOP), this.makeCode("\n" + this.tab + "}")) : [];
+ return [].concat(this.makeCode(this.tab + "try {\n"), tryPart, this.makeCode("\n" + this.tab + "}"), catchPart, ensurePart);
+ };
+
+ return Try;
+
+ })(Base);
+
+ exports.Throw = Throw = (function(superClass1) {
+ extend1(Throw, superClass1);
+
+ function Throw(expression) {
+ this.expression = expression;
+ }
+
+ Throw.prototype.children = ['expression'];
+
+ Throw.prototype.isStatement = YES;
+
+ Throw.prototype.jumps = NO;
+
+ Throw.prototype.makeReturn = THIS;
+
+ Throw.prototype.compileNode = function(o) {
+ return [].concat(this.makeCode(this.tab + "throw "), this.expression.compileToFragments(o), this.makeCode(";"));
+ };
+
+ return Throw;
+
+ })(Base);
+
+ exports.Existence = Existence = (function(superClass1) {
+ extend1(Existence, superClass1);
+
+ function Existence(expression) {
+ this.expression = expression;
+ }
+
+ Existence.prototype.children = ['expression'];
+
+ Existence.prototype.invert = NEGATE;
+
+ Existence.prototype.compileNode = function(o) {
+ var cmp, cnj, code, ref3;
+ this.expression.front = this.front;
+ code = this.expression.compile(o, LEVEL_OP);
+ if (this.expression.unwrap() instanceof IdentifierLiteral && !o.scope.check(code)) {
+ ref3 = this.negated ? ['===', '||'] : ['!==', '&&'], cmp = ref3[0], cnj = ref3[1];
+ code = "typeof " + code + " " + cmp + " \"undefined\" " + cnj + " " + code + " " + cmp + " null";
+ } else {
+ code = code + " " + (this.negated ? '==' : '!=') + " null";
+ }
+ return [this.makeCode(o.level <= LEVEL_COND ? code : "(" + code + ")")];
+ };
+
+ return Existence;
+
+ })(Base);
+
+ exports.Parens = Parens = (function(superClass1) {
+ extend1(Parens, superClass1);
+
+ function Parens(body1) {
+ this.body = body1;
+ }
+
+ Parens.prototype.children = ['body'];
+
+ Parens.prototype.unwrap = function() {
+ return this.body;
+ };
+
+ Parens.prototype.isComplex = function() {
+ return this.body.isComplex();
+ };
+
+ Parens.prototype.compileNode = function(o) {
+ var bare, expr, fragments;
+ expr = this.body.unwrap();
+ if (expr instanceof Value && expr.isAtomic()) {
+ expr.front = this.front;
+ return expr.compileToFragments(o);
+ }
+ fragments = expr.compileToFragments(o, LEVEL_PAREN);
+ bare = o.level < LEVEL_OP && (expr instanceof Op || expr instanceof Call || (expr instanceof For && expr.returns)) && (o.level < LEVEL_COND || fragments.length <= 3);
+ if (bare) {
+ return fragments;
+ } else {
+ return this.wrapInBraces(fragments);
+ }
+ };
+
+ return Parens;
+
+ })(Base);
+
+ exports.StringWithInterpolations = StringWithInterpolations = (function(superClass1) {
+ extend1(StringWithInterpolations, superClass1);
+
+ function StringWithInterpolations() {
+ return StringWithInterpolations.__super__.constructor.apply(this, arguments);
+ }
+
+ StringWithInterpolations.prototype.compileNode = function(o) {
+ var element, elements, expr, fragments, j, len1, value;
+ if (!o.inTaggedTemplateCall) {
+ return StringWithInterpolations.__super__.compileNode.apply(this, arguments);
+ }
+ expr = this.body.unwrap();
+ elements = [];
+ expr.traverseChildren(false, function(node) {
+ if (node instanceof StringLiteral) {
+ elements.push(node);
+ return true;
+ } else if (node instanceof Parens) {
+ elements.push(node);
+ return false;
+ }
+ return true;
+ });
+ fragments = [];
+ fragments.push(this.makeCode('`'));
+ for (j = 0, len1 = elements.length; j < len1; j++) {
+ element = elements[j];
+ if (element instanceof StringLiteral) {
+ value = element.value.slice(1, -1);
+ value = value.replace(/(\\*)(`|\$\{)/g, function(match, backslashes, toBeEscaped) {
+ if (backslashes.length % 2 === 0) {
+ return backslashes + "\\" + toBeEscaped;
+ } else {
+ return match;
+ }
+ });
+ fragments.push(this.makeCode(value));
+ } else {
+ fragments.push(this.makeCode('${'));
+ fragments.push.apply(fragments, element.compileToFragments(o, LEVEL_PAREN));
+ fragments.push(this.makeCode('}'));
+ }
+ }
+ fragments.push(this.makeCode('`'));
+ return fragments;
+ };
+
+ return StringWithInterpolations;
+
+ })(Parens);
+
+ exports.For = For = (function(superClass1) {
+ extend1(For, superClass1);
+
+ function For(body, source) {
+ var ref3;
+ this.source = source.source, this.guard = source.guard, this.step = source.step, this.name = source.name, this.index = source.index;
+ this.body = Block.wrap([body]);
+ this.own = !!source.own;
+ this.object = !!source.object;
+ this.from = !!source.from;
+ if (this.from && this.index) {
+ this.index.error('cannot use index with for-from');
+ }
+ if (this.own && !this.object) {
+ source.ownTag.error("cannot use own with for-" + (this.from ? 'from' : 'in'));
+ }
+ if (this.object) {
+ ref3 = [this.index, this.name], this.name = ref3[0], this.index = ref3[1];
+ }
+ if (this.index instanceof Value && !this.index.isAssignable()) {
+ this.index.error('index cannot be a pattern matching expression');
+ }
+ this.range = this.source instanceof Value && this.source.base instanceof Range && !this.source.properties.length && !this.from;
+ this.pattern = this.name instanceof Value;
+ if (this.range && this.index) {
+ this.index.error('indexes do not apply to range loops');
+ }
+ if (this.range && this.pattern) {
+ this.name.error('cannot pattern match over range loops');
+ }
+ this.returns = false;
+ }
+
+ For.prototype.children = ['body', 'source', 'guard', 'step'];
+
+ For.prototype.compileNode = function(o) {
+ var body, bodyFragments, compare, compareDown, declare, declareDown, defPart, defPartFragments, down, forPartFragments, guardPart, idt1, increment, index, ivar, kvar, kvarAssign, last, lvar, name, namePart, ref, ref3, ref4, resultPart, returnResult, rvar, scope, source, step, stepNum, stepVar, svar, varPart;
+ body = Block.wrap([this.body]);
+ ref3 = body.expressions, last = ref3[ref3.length - 1];
+ if ((last != null ? last.jumps() : void 0) instanceof Return) {
+ this.returns = false;
+ }
+ source = this.range ? this.source.base : this.source;
+ scope = o.scope;
+ if (!this.pattern) {
+ name = this.name && (this.name.compile(o, LEVEL_LIST));
+ }
+ index = this.index && (this.index.compile(o, LEVEL_LIST));
+ if (name && !this.pattern) {
+ scope.find(name);
+ }
+ if (index && !(this.index instanceof Value)) {
+ scope.find(index);
+ }
+ if (this.returns) {
+ rvar = scope.freeVariable('results');
+ }
+ if (this.from) {
+ if (this.pattern) {
+ ivar = scope.freeVariable('x', {
+ single: true
+ });
+ }
+ } else {
+ ivar = (this.object && index) || scope.freeVariable('i', {
+ single: true
+ });
+ }
+ kvar = ((this.range || this.from) && name) || index || ivar;
+ kvarAssign = kvar !== ivar ? kvar + " = " : "";
+ if (this.step && !this.range) {
+ ref4 = this.cacheToCodeFragments(this.step.cache(o, LEVEL_LIST, isComplexOrAssignable)), step = ref4[0], stepVar = ref4[1];
+ if (this.step.isNumber()) {
+ stepNum = Number(stepVar);
+ }
+ }
+ if (this.pattern) {
+ name = ivar;
+ }
+ varPart = '';
+ guardPart = '';
+ defPart = '';
+ idt1 = this.tab + TAB;
+ if (this.range) {
+ forPartFragments = source.compileToFragments(merge(o, {
+ index: ivar,
+ name: name,
+ step: this.step,
+ isComplex: isComplexOrAssignable
+ }));
+ } else {
+ svar = this.source.compile(o, LEVEL_LIST);
+ if ((name || this.own) && !(this.source.unwrap() instanceof IdentifierLiteral)) {
+ defPart += "" + this.tab + (ref = scope.freeVariable('ref')) + " = " + svar + ";\n";
+ svar = ref;
+ }
+ if (name && !this.pattern && !this.from) {
+ namePart = name + " = " + svar + "[" + kvar + "]";
+ }
+ if (!this.object && !this.from) {
+ if (step !== stepVar) {
+ defPart += "" + this.tab + step + ";\n";
+ }
+ down = stepNum < 0;
+ if (!(this.step && (stepNum != null) && down)) {
+ lvar = scope.freeVariable('len');
+ }
+ declare = "" + kvarAssign + ivar + " = 0, " + lvar + " = " + svar + ".length";
+ declareDown = "" + kvarAssign + ivar + " = " + svar + ".length - 1";
+ compare = ivar + " < " + lvar;
+ compareDown = ivar + " >= 0";
+ if (this.step) {
+ if (stepNum != null) {
+ if (down) {
+ compare = compareDown;
+ declare = declareDown;
+ }
+ } else {
+ compare = stepVar + " > 0 ? " + compare + " : " + compareDown;
+ declare = "(" + stepVar + " > 0 ? (" + declare + ") : " + declareDown + ")";
+ }
+ increment = ivar + " += " + stepVar;
+ } else {
+ increment = "" + (kvar !== ivar ? "++" + ivar : ivar + "++");
+ }
+ forPartFragments = [this.makeCode(declare + "; " + compare + "; " + kvarAssign + increment)];
+ }
+ }
+ if (this.returns) {
+ resultPart = "" + this.tab + rvar + " = [];\n";
+ returnResult = "\n" + this.tab + "return " + rvar + ";";
+ body.makeReturn(rvar);
+ }
+ if (this.guard) {
+ if (body.expressions.length > 1) {
+ body.expressions.unshift(new If((new Parens(this.guard)).invert(), new StatementLiteral("continue")));
+ } else {
+ if (this.guard) {
+ body = Block.wrap([new If(this.guard, body)]);
+ }
+ }
+ }
+ if (this.pattern) {
+ body.expressions.unshift(new Assign(this.name, this.from ? new IdentifierLiteral(kvar) : new Literal(svar + "[" + kvar + "]")));
+ }
+ defPartFragments = [].concat(this.makeCode(defPart), this.pluckDirectCall(o, body));
+ if (namePart) {
+ varPart = "\n" + idt1 + namePart + ";";
+ }
+ if (this.object) {
+ forPartFragments = [this.makeCode(kvar + " in " + svar)];
+ if (this.own) {
+ guardPart = "\n" + idt1 + "if (!" + (utility('hasProp', o)) + ".call(" + svar + ", " + kvar + ")) continue;";
+ }
+ } else if (this.from) {
+ forPartFragments = [this.makeCode(kvar + " of " + svar)];
+ }
+ bodyFragments = body.compileToFragments(merge(o, {
+ indent: idt1
+ }), LEVEL_TOP);
+ if (bodyFragments && bodyFragments.length > 0) {
+ bodyFragments = [].concat(this.makeCode("\n"), bodyFragments, this.makeCode("\n"));
+ }
+ return [].concat(defPartFragments, this.makeCode("" + (resultPart || '') + this.tab + "for ("), forPartFragments, this.makeCode(") {" + guardPart + varPart), bodyFragments, this.makeCode(this.tab + "}" + (returnResult || '')));
+ };
+
+ For.prototype.pluckDirectCall = function(o, body) {
+ var base, defs, expr, fn, idx, j, len1, ref, ref3, ref4, ref5, ref6, ref7, ref8, ref9, val;
+ defs = [];
+ ref3 = body.expressions;
+ for (idx = j = 0, len1 = ref3.length; j < len1; idx = ++j) {
+ expr = ref3[idx];
+ expr = expr.unwrapAll();
+ if (!(expr instanceof Call)) {
+ continue;
+ }
+ val = (ref4 = expr.variable) != null ? ref4.unwrapAll() : void 0;
+ if (!((val instanceof Code) || (val instanceof Value && ((ref5 = val.base) != null ? ref5.unwrapAll() : void 0) instanceof Code && val.properties.length === 1 && ((ref6 = (ref7 = val.properties[0].name) != null ? ref7.value : void 0) === 'call' || ref6 === 'apply')))) {
+ continue;
+ }
+ fn = ((ref8 = val.base) != null ? ref8.unwrapAll() : void 0) || val;
+ ref = new IdentifierLiteral(o.scope.freeVariable('fn'));
+ base = new Value(ref);
+ if (val.base) {
+ ref9 = [base, val], val.base = ref9[0], base = ref9[1];
+ }
+ body.expressions[idx] = new Call(base, expr.args);
+ defs = defs.concat(this.makeCode(this.tab), new Assign(ref, fn).compileToFragments(o, LEVEL_TOP), this.makeCode(';\n'));
+ }
+ return defs;
+ };
+
+ return For;
+
+ })(While);
+
+ exports.Switch = Switch = (function(superClass1) {
+ extend1(Switch, superClass1);
+
+ function Switch(subject, cases, otherwise) {
+ this.subject = subject;
+ this.cases = cases;
+ this.otherwise = otherwise;
+ }
+
+ Switch.prototype.children = ['subject', 'cases', 'otherwise'];
+
+ Switch.prototype.isStatement = YES;
+
+ Switch.prototype.jumps = function(o) {
+ var block, conds, j, jumpNode, len1, ref3, ref4, ref5;
+ if (o == null) {
+ o = {
+ block: true
+ };
+ }
+ ref3 = this.cases;
+ for (j = 0, len1 = ref3.length; j < len1; j++) {
+ ref4 = ref3[j], conds = ref4[0], block = ref4[1];
+ if (jumpNode = block.jumps(o)) {
+ return jumpNode;
+ }
+ }
+ return (ref5 = this.otherwise) != null ? ref5.jumps(o) : void 0;
+ };
+
+ Switch.prototype.makeReturn = function(res) {
+ var j, len1, pair, ref3, ref4;
+ ref3 = this.cases;
+ for (j = 0, len1 = ref3.length; j < len1; j++) {
+ pair = ref3[j];
+ pair[1].makeReturn(res);
+ }
+ if (res) {
+ this.otherwise || (this.otherwise = new Block([new Literal('void 0')]));
+ }
+ if ((ref4 = this.otherwise) != null) {
+ ref4.makeReturn(res);
+ }
+ return this;
+ };
+
+ Switch.prototype.compileNode = function(o) {
+ var block, body, cond, conditions, expr, fragments, i, idt1, idt2, j, k, len1, len2, ref3, ref4, ref5;
+ idt1 = o.indent + TAB;
+ idt2 = o.indent = idt1 + TAB;
+ fragments = [].concat(this.makeCode(this.tab + "switch ("), (this.subject ? this.subject.compileToFragments(o, LEVEL_PAREN) : this.makeCode("false")), this.makeCode(") {\n"));
+ ref3 = this.cases;
+ for (i = j = 0, len1 = ref3.length; j < len1; i = ++j) {
+ ref4 = ref3[i], conditions = ref4[0], block = ref4[1];
+ ref5 = flatten([conditions]);
+ for (k = 0, len2 = ref5.length; k < len2; k++) {
+ cond = ref5[k];
+ if (!this.subject) {
+ cond = cond.invert();
+ }
+ fragments = fragments.concat(this.makeCode(idt1 + "case "), cond.compileToFragments(o, LEVEL_PAREN), this.makeCode(":\n"));
+ }
+ if ((body = block.compileToFragments(o, LEVEL_TOP)).length > 0) {
+ fragments = fragments.concat(body, this.makeCode('\n'));
+ }
+ if (i === this.cases.length - 1 && !this.otherwise) {
+ break;
+ }
+ expr = this.lastNonComment(block.expressions);
+ if (expr instanceof Return || (expr instanceof Literal && expr.jumps() && expr.value !== 'debugger')) {
+ continue;
+ }
+ fragments.push(cond.makeCode(idt2 + 'break;\n'));
+ }
+ if (this.otherwise && this.otherwise.expressions.length) {
+ fragments.push.apply(fragments, [this.makeCode(idt1 + "default:\n")].concat(slice.call(this.otherwise.compileToFragments(o, LEVEL_TOP)), [this.makeCode("\n")]));
+ }
+ fragments.push(this.makeCode(this.tab + '}'));
+ return fragments;
+ };
+
+ return Switch;
+
+ })(Base);
+
+ exports.If = If = (function(superClass1) {
+ extend1(If, superClass1);
+
+ function If(condition, body1, options) {
+ this.body = body1;
+ if (options == null) {
+ options = {};
+ }
+ this.condition = options.type === 'unless' ? condition.invert() : condition;
+ this.elseBody = null;
+ this.isChain = false;
+ this.soak = options.soak;
+ }
+
+ If.prototype.children = ['condition', 'body', 'elseBody'];
+
+ If.prototype.bodyNode = function() {
+ var ref3;
+ return (ref3 = this.body) != null ? ref3.unwrap() : void 0;
+ };
+
+ If.prototype.elseBodyNode = function() {
+ var ref3;
+ return (ref3 = this.elseBody) != null ? ref3.unwrap() : void 0;
+ };
+
+ If.prototype.addElse = function(elseBody) {
+ if (this.isChain) {
+ this.elseBodyNode().addElse(elseBody);
+ } else {
+ this.isChain = elseBody instanceof If;
+ this.elseBody = this.ensureBlock(elseBody);
+ this.elseBody.updateLocationDataIfMissing(elseBody.locationData);
+ }
+ return this;
+ };
+
+ If.prototype.isStatement = function(o) {
+ var ref3;
+ return (o != null ? o.level : void 0) === LEVEL_TOP || this.bodyNode().isStatement(o) || ((ref3 = this.elseBodyNode()) != null ? ref3.isStatement(o) : void 0);
+ };
+
+ If.prototype.jumps = function(o) {
+ var ref3;
+ return this.body.jumps(o) || ((ref3 = this.elseBody) != null ? ref3.jumps(o) : void 0);
+ };
+
+ If.prototype.compileNode = function(o) {
+ if (this.isStatement(o)) {
+ return this.compileStatement(o);
+ } else {
+ return this.compileExpression(o);
+ }
+ };
+
+ If.prototype.makeReturn = function(res) {
+ if (res) {
+ this.elseBody || (this.elseBody = new Block([new Literal('void 0')]));
+ }
+ this.body && (this.body = new Block([this.body.makeReturn(res)]));
+ this.elseBody && (this.elseBody = new Block([this.elseBody.makeReturn(res)]));
+ return this;
+ };
+
+ If.prototype.ensureBlock = function(node) {
+ if (node instanceof Block) {
+ return node;
+ } else {
+ return new Block([node]);
+ }
+ };
+
+ If.prototype.compileStatement = function(o) {
+ var answer, body, child, cond, exeq, ifPart, indent;
+ child = del(o, 'chainChild');
+ exeq = del(o, 'isExistentialEquals');
+ if (exeq) {
+ return new If(this.condition.invert(), this.elseBodyNode(), {
+ type: 'if'
+ }).compileToFragments(o);
+ }
+ indent = o.indent + TAB;
+ cond = this.condition.compileToFragments(o, LEVEL_PAREN);
+ body = this.ensureBlock(this.body).compileToFragments(merge(o, {
+ indent: indent
+ }));
+ ifPart = [].concat(this.makeCode("if ("), cond, this.makeCode(") {\n"), body, this.makeCode("\n" + this.tab + "}"));
+ if (!child) {
+ ifPart.unshift(this.makeCode(this.tab));
+ }
+ if (!this.elseBody) {
+ return ifPart;
+ }
+ answer = ifPart.concat(this.makeCode(' else '));
+ if (this.isChain) {
+ o.chainChild = true;
+ answer = answer.concat(this.elseBody.unwrap().compileToFragments(o, LEVEL_TOP));
+ } else {
+ answer = answer.concat(this.makeCode("{\n"), this.elseBody.compileToFragments(merge(o, {
+ indent: indent
+ }), LEVEL_TOP), this.makeCode("\n" + this.tab + "}"));
+ }
+ return answer;
+ };
+
+ If.prototype.compileExpression = function(o) {
+ var alt, body, cond, fragments;
+ cond = this.condition.compileToFragments(o, LEVEL_COND);
+ body = this.bodyNode().compileToFragments(o, LEVEL_LIST);
+ alt = this.elseBodyNode() ? this.elseBodyNode().compileToFragments(o, LEVEL_LIST) : [this.makeCode('void 0')];
+ fragments = cond.concat(this.makeCode(" ? "), body, this.makeCode(" : "), alt);
+ if (o.level >= LEVEL_COND) {
+ return this.wrapInBraces(fragments);
+ } else {
+ return fragments;
+ }
+ };
+
+ If.prototype.unfoldSoak = function() {
+ return this.soak && this;
+ };
+
+ return If;
+
+ })(Base);
+
+ UTILITIES = {
+ extend: function(o) {
+ return "function(child, parent) { for (var key in parent) { if (" + (utility('hasProp', o)) + ".call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }";
+ },
+ bind: function() {
+ return 'function(fn, me){ return function(){ return fn.apply(me, arguments); }; }';
+ },
+ indexOf: function() {
+ return "[].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; }";
+ },
+ modulo: function() {
+ return "function(a, b) { return (+a % (b = +b) + b) % b; }";
+ },
+ hasProp: function() {
+ return '{}.hasOwnProperty';
+ },
+ slice: function() {
+ return '[].slice';
+ }
+ };
+
+ LEVEL_TOP = 1;
+
+ LEVEL_PAREN = 2;
+
+ LEVEL_LIST = 3;
+
+ LEVEL_COND = 4;
+
+ LEVEL_OP = 5;
+
+ LEVEL_ACCESS = 6;
+
+ TAB = ' ';
+
+ SIMPLENUM = /^[+-]?\d+$/;
+
+ utility = function(name, o) {
+ var ref, root;
+ root = o.scope.root;
+ if (name in root.utilities) {
+ return root.utilities[name];
+ } else {
+ ref = root.freeVariable(name);
+ root.assign(ref, UTILITIES[name](o));
+ return root.utilities[name] = ref;
+ }
+ };
+
+ multident = function(code, tab) {
+ code = code.replace(/\n/g, '$&' + tab);
+ return code.replace(/\s+$/, '');
+ };
+
+ isLiteralArguments = function(node) {
+ return node instanceof IdentifierLiteral && node.value === 'arguments';
+ };
+
+ isLiteralThis = function(node) {
+ return node instanceof ThisLiteral || (node instanceof Code && node.bound) || node instanceof SuperCall;
+ };
+
+ isComplexOrAssignable = function(node) {
+ return node.isComplex() || (typeof node.isAssignable === "function" ? node.isAssignable() : void 0);
+ };
+
+ unfoldSoak = function(o, parent, name) {
+ var ifn;
+ if (!(ifn = parent[name].unfoldSoak(o))) {
+ return;
+ }
+ parent[name] = ifn.body;
+ ifn.body = new Value(parent);
+ return ifn;
+ };
+
+}).call(this);
diff --git a/modeshape-sample/node_modules/coffee-script/lib/coffee-script/optparse.js b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/optparse.js
new file mode 100644
index 0000000..4c5624f
--- /dev/null
+++ b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/optparse.js
@@ -0,0 +1,139 @@
+// Generated by CoffeeScript 1.12.7
+(function() {
+ var LONG_FLAG, MULTI_FLAG, OPTIONAL, OptionParser, SHORT_FLAG, buildRule, buildRules, normalizeArguments, repeat;
+
+ repeat = require('./helpers').repeat;
+
+ exports.OptionParser = OptionParser = (function() {
+ function OptionParser(rules, banner) {
+ this.banner = banner;
+ this.rules = buildRules(rules);
+ }
+
+ OptionParser.prototype.parse = function(args) {
+ var arg, i, isOption, j, k, len, len1, matchedRule, options, originalArgs, pos, ref, rule, seenNonOptionArg, skippingArgument, value;
+ options = {
+ "arguments": []
+ };
+ skippingArgument = false;
+ originalArgs = args;
+ args = normalizeArguments(args);
+ for (i = j = 0, len = args.length; j < len; i = ++j) {
+ arg = args[i];
+ if (skippingArgument) {
+ skippingArgument = false;
+ continue;
+ }
+ if (arg === '--') {
+ pos = originalArgs.indexOf('--');
+ options["arguments"] = options["arguments"].concat(originalArgs.slice(pos + 1));
+ break;
+ }
+ isOption = !!(arg.match(LONG_FLAG) || arg.match(SHORT_FLAG));
+ seenNonOptionArg = options["arguments"].length > 0;
+ if (!seenNonOptionArg) {
+ matchedRule = false;
+ ref = this.rules;
+ for (k = 0, len1 = ref.length; k < len1; k++) {
+ rule = ref[k];
+ if (rule.shortFlag === arg || rule.longFlag === arg) {
+ value = true;
+ if (rule.hasArgument) {
+ skippingArgument = true;
+ value = args[i + 1];
+ }
+ options[rule.name] = rule.isList ? (options[rule.name] || []).concat(value) : value;
+ matchedRule = true;
+ break;
+ }
+ }
+ if (isOption && !matchedRule) {
+ throw new Error("unrecognized option: " + arg);
+ }
+ }
+ if (seenNonOptionArg || !isOption) {
+ options["arguments"].push(arg);
+ }
+ }
+ return options;
+ };
+
+ OptionParser.prototype.help = function() {
+ var j, len, letPart, lines, ref, rule, spaces;
+ lines = [];
+ if (this.banner) {
+ lines.unshift(this.banner + "\n");
+ }
+ ref = this.rules;
+ for (j = 0, len = ref.length; j < len; j++) {
+ rule = ref[j];
+ spaces = 15 - rule.longFlag.length;
+ spaces = spaces > 0 ? repeat(' ', spaces) : '';
+ letPart = rule.shortFlag ? rule.shortFlag + ', ' : ' ';
+ lines.push(' ' + letPart + rule.longFlag + spaces + rule.description);
+ }
+ return "\n" + (lines.join('\n')) + "\n";
+ };
+
+ return OptionParser;
+
+ })();
+
+ LONG_FLAG = /^(--\w[\w\-]*)/;
+
+ SHORT_FLAG = /^(-\w)$/;
+
+ MULTI_FLAG = /^-(\w{2,})/;
+
+ OPTIONAL = /\[(\w+(\*?))\]/;
+
+ buildRules = function(rules) {
+ var j, len, results, tuple;
+ results = [];
+ for (j = 0, len = rules.length; j < len; j++) {
+ tuple = rules[j];
+ if (tuple.length < 3) {
+ tuple.unshift(null);
+ }
+ results.push(buildRule.apply(null, tuple));
+ }
+ return results;
+ };
+
+ buildRule = function(shortFlag, longFlag, description, options) {
+ var match;
+ if (options == null) {
+ options = {};
+ }
+ match = longFlag.match(OPTIONAL);
+ longFlag = longFlag.match(LONG_FLAG)[1];
+ return {
+ name: longFlag.substr(2),
+ shortFlag: shortFlag,
+ longFlag: longFlag,
+ description: description,
+ hasArgument: !!(match && match[1]),
+ isList: !!(match && match[2])
+ };
+ };
+
+ normalizeArguments = function(args) {
+ var arg, j, k, l, len, len1, match, ref, result;
+ args = args.slice(0);
+ result = [];
+ for (j = 0, len = args.length; j < len; j++) {
+ arg = args[j];
+ if (match = arg.match(MULTI_FLAG)) {
+ ref = match[1].split('');
+ for (k = 0, len1 = ref.length; k < len1; k++) {
+ l = ref[k];
+ result.push('-' + l);
+ }
+ } else {
+ result.push(arg);
+ }
+ }
+ return result;
+ };
+
+}).call(this);
diff --git a/modeshape-sample/node_modules/coffee-script/lib/coffee-script/parser.js b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/parser.js
new file mode 100755
index 0000000..e8c11b5
--- /dev/null
+++ b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/parser.js
@@ -0,0 +1,891 @@
+/* parser generated by jison 0.4.17 */
+/*
+ Returns a Parser object of the following structure:
+
+ Parser: {
+ yy: {}
+ }
+
+ Parser.prototype: {
+ yy: {},
+ trace: function(),
+ symbols_: {associative list: name ==> number},
+ terminals_: {associative list: number ==> name},
+ productions_: [...],
+ performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$),
+ table: [...],
+ defaultActions: {...},
+ parseError: function(str, hash),
+ parse: function(input),
+
+ lexer: {
+ EOF: 1,
+ parseError: function(str, hash),
+ setInput: function(input),
+ input: function(),
+ unput: function(str),
+ more: function(),
+ less: function(n),
+ pastInput: function(),
+ upcomingInput: function(),
+ showPosition: function(),
+ test_match: function(regex_match_array, rule_index),
+ next: function(),
+ lex: function(),
+ begin: function(condition),
+ popState: function(),
+ _currentRules: function(),
+ topState: function(),
+ pushState: function(condition),
+
+ options: {
+ ranges: boolean (optional: true ==> token location info will include a .range[] member)
+ flex: boolean (optional: true ==> flex-like lexing behaviour where the rules are tested exhaustively to find the longest match)
+ backtrack_lexer: boolean (optional: true ==> lexer regexes are tested in order and for each matching regex the action code is invoked; the lexer terminates the scan when a token is returned by the action code)
+ },
+
+ performAction: function(yy, yy_, $avoiding_name_collisions, YY_START),
+ rules: [...],
+ conditions: {associative list: name ==> set},
+ }
+ }
+
+
+ token location info (@$, _$, etc.): {
+ first_line: n,
+ last_line: n,
+ first_column: n,
+ last_column: n,
+ range: [start_number, end_number] (where the numbers are indexes into the input string, regular zero-based)
+ }
+
+
+ the parseError function receives a 'hash' object with these members for lexer and parser errors: {
+ text: (matched text)
+ token: (the produced terminal token, if any)
+ line: (yylineno)
+ }
+ while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: {
+ loc: (yylloc)
+ expected: (string describing the set of expected tokens)
+ recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error)
+ }
+*/
+var parser = (function(){
+var o=function(k,v,o,l){for(o=o||{},l=k.length;l--;o[k[l]]=v);return o},$V0=[1,22],$V1=[1,25],$V2=[1,83],$V3=[1,79],$V4=[1,84],$V5=[1,85],$V6=[1,81],$V7=[1,82],$V8=[1,56],$V9=[1,58],$Va=[1,59],$Vb=[1,60],$Vc=[1,61],$Vd=[1,62],$Ve=[1,49],$Vf=[1,50],$Vg=[1,32],$Vh=[1,68],$Vi=[1,69],$Vj=[1,78],$Vk=[1,47],$Vl=[1,51],$Vm=[1,52],$Vn=[1,67],$Vo=[1,65],$Vp=[1,66],$Vq=[1,64],$Vr=[1,42],$Vs=[1,48],$Vt=[1,63],$Vu=[1,73],$Vv=[1,74],$Vw=[1,75],$Vx=[1,76],$Vy=[1,46],$Vz=[1,72],$VA=[1,34],$VB=[1,35],$VC=[1,36],$VD=[1,37],$VE=[1,38],$VF=[1,39],$VG=[1,86],$VH=[1,6,32,42,131],$VI=[1,101],$VJ=[1,89],$VK=[1,88],$VL=[1,87],$VM=[1,90],$VN=[1,91],$VO=[1,92],$VP=[1,93],$VQ=[1,94],$VR=[1,95],$VS=[1,96],$VT=[1,97],$VU=[1,98],$VV=[1,99],$VW=[1,100],$VX=[1,104],$VY=[1,6,31,32,42,66,71,74,89,94,115,120,122,131,133,134,135,139,140,156,159,160,163,164,165,166,167,168,169,170,171,172,173,174],$VZ=[2,167],$V_=[1,110],$V$=[1,111],$V01=[1,112],$V11=[1,113],$V21=[1,115],$V31=[1,116],$V41=[1,109],$V51=[1,6,32,42,131,133,135,139,156],$V61=[2,27],$V71=[1,123],$V81=[1,121],$V91=[1,6,31,32,40,41,42,66,71,74,82,83,84,85,87,89,90,94,113,114,115,120,122,131,133,134,135,139,140,156,159,160,163,164,165,166,167,168,169,170,171,172,173,174],$Va1=[2,95],$Vb1=[1,6,31,32,42,46,66,71,74,82,83,84,85,87,89,90,94,113,114,115,120,122,131,133,134,135,139,140,156,159,160,163,164,165,166,167,168,169,170,171,172,173,174],$Vc1=[2,74],$Vd1=[1,128],$Ve1=[1,133],$Vf1=[1,134],$Vg1=[1,136],$Vh1=[1,6,31,32,40,41,42,55,66,71,74,82,83,84,85,87,89,90,94,113,114,115,120,122,131,133,134,135,139,140,156,159,160,163,164,165,166,167,168,169,170,171,172,173,174],$Vi1=[2,92],$Vj1=[1,6,32,42,66,71,74,89,94,115,120,122,131,133,134,135,139,140,156,159,160,163,164,165,166,167,168,169,170,171,172,173,174],$Vk1=[2,64],$Vl1=[1,161],$Vm1=[1,167],$Vn1=[1,179],$Vo1=[1,181],$Vp1=[1,176],$Vq1=[1,183],$Vr1=[1,185],$Vs1=[1,6,31,32,40,41,42,55,66,71,74,82,83,84,85,87,89,90,94,96,113,114,115,120,122,131,133,134,135,139,140,156,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175],$Vt1=[2,111],$Vu1=[1,6,31,32,40,41,42,58,66,71,74,82,83,84,85,87,89,90,94,113,114,115,120,122,131,133,134,135,139,140,156,159,160,163,164,165,166,167,168,169,170,171,172,173,174],$Vv1=[1,6,31,32,40,41,42,46,58,66,71,74,82,83,84,85,87,89,90,94,113,114,115,120,122,131,133,134,135,139,140,156,159,160,163,164,165,166,167,168,169,170,171,172,173,174],$Vw1=[40,41,114],$Vx1=[1,242],$Vy1=[1,241],$Vz1=[1,6,31,32,42,66,71,74,89,94,115,120,122,131,133,134,135,139,140,156],$VA1=[2,72],$VB1=[1,251],$VC1=[6,31,32,66,71],$VD1=[6,31,32,55,66,71,74],$VE1=[1,6,31,32,42,66,71,74,89,94,115,120,122,131,133,134,135,139,140,156,159,160,164,166,167,168,169,170,171,172,173,174],$VF1=[40,41,82,83,84,85,87,90,113,114],$VG1=[1,270],$VH1=[2,62],$VI1=[1,281],$VJ1=[1,283],$VK1=[1,288],$VL1=[1,290],$VM1=[2,188],$VN1=[1,6,31,32,40,41,42,55,66,71,74,82,83,84,85,87,89,90,94,113,114,115,120,122,131,133,134,135,139,140,146,147,148,156,159,160,163,164,165,166,167,168,169,170,171,172,173,174],$VO1=[1,299],$VP1=[6,31,32,71,115,120],$VQ1=[1,6,31,32,40,41,42,55,58,66,71,74,82,83,84,85,87,89,90,94,96,113,114,115,120,122,131,133,134,135,139,140,146,147,148,156,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175],$VR1=[1,6,31,32,42,66,71,74,89,94,115,120,122,131,140,156],$VS1=[1,6,31,32,42,66,71,74,89,94,115,120,122,131,134,140,156],$VT1=[146,147,148],$VU1=[71,146,147,148],$VV1=[6,31,94],$VW1=[1,313],$VX1=[6,31,32,71,94],$VY1=[6,31,32,58,71,94],$VZ1=[6,31,32,55,58,71,94],$V_1=[1,6,31,32,42,66,71,74,89,94,115,120,122,131,133,134,135,139,140,156,159,160,166,167,168,169,170,171,172,173,174],$V$1=[12,28,34,38,40,41,44,45,48,49,50,51,52,53,61,63,64,68,69,89,92,95,97,105,112,117,118,119,125,129,130,133,135,137,139,149,155,157,158,159,160,161,162],$V02=[2,177],$V12=[6,31,32],$V22=[2,73],$V32=[1,325],$V42=[1,326],$V52=[1,6,31,32,42,66,71,74,89,94,115,120,122,127,128,131,133,134,135,139,140,151,153,156,159,160,163,164,165,166,167,168,169,170,171,172,173,174],$V62=[32,151,153],$V72=[1,6,32,42,66,71,74,89,94,115,120,122,131,134,140,156],$V82=[1,353],$V92=[1,359],$Va2=[1,6,32,42,131,156],$Vb2=[2,87],$Vc2=[1,370],$Vd2=[1,371],$Ve2=[1,6,31,32,42,66,71,74,89,94,115,120,122,131,133,134,135,139,140,151,156,159,160,163,164,165,166,167,168,169,170,171,172,173,174],$Vf2=[1,6,31,32,42,66,71,74,89,94,115,120,122,131,133,135,139,140,156],$Vg2=[1,384],$Vh2=[1,385],$Vi2=[6,31,32,94],$Vj2=[6,31,32,71],$Vk2=[1,6,31,32,42,66,71,74,89,94,115,120,122,127,131,133,134,135,139,140,156,159,160,163,164,165,166,167,168,169,170,171,172,173,174],$Vl2=[31,71],$Vm2=[1,411],$Vn2=[1,412],$Vo2=[1,418],$Vp2=[1,419];
+var parser = {trace: function trace() { },
+yy: {},
+symbols_: {"error":2,"Root":3,"Body":4,"Line":5,"TERMINATOR":6,"Expression":7,"Statement":8,"YieldReturn":9,"Return":10,"Comment":11,"STATEMENT":12,"Import":13,"Export":14,"Value":15,"Invocation":16,"Code":17,"Operation":18,"Assign":19,"If":20,"Try":21,"While":22,"For":23,"Switch":24,"Class":25,"Throw":26,"Yield":27,"YIELD":28,"FROM":29,"Block":30,"INDENT":31,"OUTDENT":32,"Identifier":33,"IDENTIFIER":34,"Property":35,"PROPERTY":36,"AlphaNumeric":37,"NUMBER":38,"String":39,"STRING":40,"STRING_START":41,"STRING_END":42,"Regex":43,"REGEX":44,"REGEX_START":45,"REGEX_END":46,"Literal":47,"JS":48,"UNDEFINED":49,"NULL":50,"BOOL":51,"INFINITY":52,"NAN":53,"Assignable":54,"=":55,"AssignObj":56,"ObjAssignable":57,":":58,"SimpleObjAssignable":59,"ThisProperty":60,"RETURN":61,"Object":62,"HERECOMMENT":63,"PARAM_START":64,"ParamList":65,"PARAM_END":66,"FuncGlyph":67,"->":68,"=>":69,"OptComma":70,",":71,"Param":72,"ParamVar":73,"...":74,"Array":75,"Splat":76,"SimpleAssignable":77,"Accessor":78,"Parenthetical":79,"Range":80,"This":81,".":82,"?.":83,"::":84,"?::":85,"Index":86,"INDEX_START":87,"IndexValue":88,"INDEX_END":89,"INDEX_SOAK":90,"Slice":91,"{":92,"AssignList":93,"}":94,"CLASS":95,"EXTENDS":96,"IMPORT":97,"ImportDefaultSpecifier":98,"ImportNamespaceSpecifier":99,"ImportSpecifierList":100,"ImportSpecifier":101,"AS":102,"DEFAULT":103,"IMPORT_ALL":104,"EXPORT":105,"ExportSpecifierList":106,"EXPORT_ALL":107,"ExportSpecifier":108,"OptFuncExist":109,"Arguments":110,"Super":111,"SUPER":112,"FUNC_EXIST":113,"CALL_START":114,"CALL_END":115,"ArgList":116,"THIS":117,"@":118,"[":119,"]":120,"RangeDots":121,"..":122,"Arg":123,"SimpleArgs":124,"TRY":125,"Catch":126,"FINALLY":127,"CATCH":128,"THROW":129,"(":130,")":131,"WhileSource":132,"WHILE":133,"WHEN":134,"UNTIL":135,"Loop":136,"LOOP":137,"ForBody":138,"FOR":139,"BY":140,"ForStart":141,"ForSource":142,"ForVariables":143,"OWN":144,"ForValue":145,"FORIN":146,"FOROF":147,"FORFROM":148,"SWITCH":149,"Whens":150,"ELSE":151,"When":152,"LEADING_WHEN":153,"IfBlock":154,"IF":155,"POST_IF":156,"UNARY":157,"UNARY_MATH":158,"-":159,"+":160,"--":161,"++":162,"?":163,"MATH":164,"**":165,"SHIFT":166,"COMPARE":167,"&":168,"^":169,"|":170,"&&":171,"||":172,"BIN?":173,"RELATION":174,"COMPOUND_ASSIGN":175,"$accept":0,"$end":1},
+terminals_: {2:"error",6:"TERMINATOR",12:"STATEMENT",28:"YIELD",29:"FROM",31:"INDENT",32:"OUTDENT",34:"IDENTIFIER",36:"PROPERTY",38:"NUMBER",40:"STRING",41:"STRING_START",42:"STRING_END",44:"REGEX",45:"REGEX_START",46:"REGEX_END",48:"JS",49:"UNDEFINED",50:"NULL",51:"BOOL",52:"INFINITY",53:"NAN",55:"=",58:":",61:"RETURN",63:"HERECOMMENT",64:"PARAM_START",66:"PARAM_END",68:"->",69:"=>",71:",",74:"...",82:".",83:"?.",84:"::",85:"?::",87:"INDEX_START",89:"INDEX_END",90:"INDEX_SOAK",92:"{",94:"}",95:"CLASS",96:"EXTENDS",97:"IMPORT",102:"AS",103:"DEFAULT",104:"IMPORT_ALL",105:"EXPORT",107:"EXPORT_ALL",112:"SUPER",113:"FUNC_EXIST",114:"CALL_START",115:"CALL_END",117:"THIS",118:"@",119:"[",120:"]",122:"..",125:"TRY",127:"FINALLY",128:"CATCH",129:"THROW",130:"(",131:")",133:"WHILE",134:"WHEN",135:"UNTIL",137:"LOOP",139:"FOR",140:"BY",144:"OWN",146:"FORIN",147:"FOROF",148:"FORFROM",149:"SWITCH",151:"ELSE",153:"LEADING_WHEN",155:"IF",156:"POST_IF",157:"UNARY",158:"UNARY_MATH",159:"-",160:"+",161:"--",162:"++",163:"?",164:"MATH",165:"**",166:"SHIFT",167:"COMPARE",168:"&",169:"^",170:"|",171:"&&",172:"||",173:"BIN?",174:"RELATION",175:"COMPOUND_ASSIGN"},
+productions_: [0,[3,0],[3,1],[4,1],[4,3],[4,2],[5,1],[5,1],[5,1],[8,1],[8,1],[8,1],[8,1],[8,1],[7,1],[7,1],[7,1],[7,1],[7,1],[7,1],[7,1],[7,1],[7,1],[7,1],[7,1],[7,1],[7,1],[27,1],[27,2],[27,3],[30,2],[30,3],[33,1],[35,1],[37,1],[37,1],[39,1],[39,3],[43,1],[43,3],[47,1],[47,1],[47,1],[47,1],[47,1],[47,1],[47,1],[47,1],[19,3],[19,4],[19,5],[56,1],[56,3],[56,5],[56,3],[56,5],[56,1],[59,1],[59,1],[59,1],[57,1],[57,1],[10,2],[10,4],[10,1],[9,3],[9,2],[11,1],[17,5],[17,2],[67,1],[67,1],[70,0],[70,1],[65,0],[65,1],[65,3],[65,4],[65,6],[72,1],[72,2],[72,3],[72,1],[73,1],[73,1],[73,1],[73,1],[76,2],[77,1],[77,2],[77,2],[77,1],[54,1],[54,1],[54,1],[15,1],[15,1],[15,1],[15,1],[15,1],[78,2],[78,2],[78,2],[78,2],[78,1],[78,1],[86,3],[86,2],[88,1],[88,1],[62,4],[93,0],[93,1],[93,3],[93,4],[93,6],[25,1],[25,2],[25,3],[25,4],[25,2],[25,3],[25,4],[25,5],[13,2],[13,4],[13,4],[13,5],[13,7],[13,6],[13,9],[100,1],[100,3],[100,4],[100,4],[100,6],[101,1],[101,3],[101,1],[101,3],[98,1],[99,3],[14,3],[14,5],[14,2],[14,4],[14,5],[14,6],[14,3],[14,4],[14,7],[106,1],[106,3],[106,4],[106,4],[106,6],[108,1],[108,3],[108,3],[108,1],[108,3],[16,3],[16,3],[16,3],[16,1],[111,1],[111,2],[109,0],[109,1],[110,2],[110,4],[81,1],[81,1],[60,2],[75,2],[75,4],[121,1],[121,1],[80,5],[91,3],[91,2],[91,2],[91,1],[116,1],[116,3],[116,4],[116,4],[116,6],[123,1],[123,1],[123,1],[124,1],[124,3],[21,2],[21,3],[21,4],[21,5],[126,3],[126,3],[126,2],[26,2],[79,3],[79,5],[132,2],[132,4],[132,2],[132,4],[22,2],[22,2],[22,2],[22,1],[136,2],[136,2],[23,2],[23,2],[23,2],[138,2],[138,4],[138,2],[141,2],[141,3],[145,1],[145,1],[145,1],[145,1],[143,1],[143,3],[142,2],[142,2],[142,4],[142,4],[142,4],[142,6],[142,6],[142,2],[142,4],[24,5],[24,7],[24,4],[24,6],[150,1],[150,2],[152,3],[152,4],[154,3],[154,5],[20,1],[20,3],[20,3],[20,3],[18,2],[18,2],[18,2],[18,2],[18,2],[18,2],[18,2],[18,2],[18,2],[18,3],[18,3],[18,3],[18,3],[18,3],[18,3],[18,3],[18,3],[18,3],[18,3],[18,3],[18,3],[18,3],[18,3],[18,5],[18,4],[18,3]],
+performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
+/* this == yyval */
+
+var $0 = $$.length - 1;
+switch (yystate) {
+case 1:
+return this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.Block);
+break;
+case 2:
+return this.$ = $$[$0];
+break;
+case 3:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(yy.Block.wrap([$$[$0]]));
+break;
+case 4:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])($$[$0-2].push($$[$0]));
+break;
+case 5:
+this.$ = $$[$0-1];
+break;
+case 6: case 7: case 8: case 9: case 10: case 12: case 13: case 14: case 15: case 16: case 17: case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25: case 26: case 35: case 40: case 42: case 56: case 57: case 58: case 59: case 60: case 61: case 72: case 73: case 83: case 84: case 85: case 86: case 91: case 92: case 95: case 99: case 105: case 164: case 188: case 189: case 191: case 221: case 222: case 240: case 246:
+this.$ = $$[$0];
+break;
+case 11:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.StatementLiteral($$[$0]));
+break;
+case 27:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.Op($$[$0], new yy.Value(new yy.Literal(''))));
+break;
+case 28: case 250: case 251:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.Op($$[$0-1], $$[$0]));
+break;
+case 29:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.Op($$[$0-2].concat($$[$0-1]), $$[$0]));
+break;
+case 30:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.Block);
+break;
+case 31: case 106:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])($$[$0-1]);
+break;
+case 32:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.IdentifierLiteral($$[$0]));
+break;
+case 33:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.PropertyName($$[$0]));
+break;
+case 34:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.NumberLiteral($$[$0]));
+break;
+case 36:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.StringLiteral($$[$0]));
+break;
+case 37:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.StringWithInterpolations($$[$0-1]));
+break;
+case 38:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.RegexLiteral($$[$0]));
+break;
+case 39:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.RegexWithInterpolations($$[$0-1].args));
+break;
+case 41:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.PassthroughLiteral($$[$0]));
+break;
+case 43:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.UndefinedLiteral);
+break;
+case 44:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.NullLiteral);
+break;
+case 45:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.BooleanLiteral($$[$0]));
+break;
+case 46:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.InfinityLiteral($$[$0]));
+break;
+case 47:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.NaNLiteral);
+break;
+case 48:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.Assign($$[$0-2], $$[$0]));
+break;
+case 49:
+this.$ = yy.addLocationDataFn(_$[$0-3], _$[$0])(new yy.Assign($$[$0-3], $$[$0]));
+break;
+case 50:
+this.$ = yy.addLocationDataFn(_$[$0-4], _$[$0])(new yy.Assign($$[$0-4], $$[$0-1]));
+break;
+case 51: case 88: case 93: case 94: case 96: case 97: case 98: case 223: case 224:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.Value($$[$0]));
+break;
+case 52:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.Assign(yy.addLocationDataFn(_$[$0-2])(new yy.Value($$[$0-2])), $$[$0], 'object', {
+ operatorToken: yy.addLocationDataFn(_$[$0-1])(new yy.Literal($$[$0-1]))
+ }));
+break;
+case 53:
+this.$ = yy.addLocationDataFn(_$[$0-4], _$[$0])(new yy.Assign(yy.addLocationDataFn(_$[$0-4])(new yy.Value($$[$0-4])), $$[$0-1], 'object', {
+ operatorToken: yy.addLocationDataFn(_$[$0-3])(new yy.Literal($$[$0-3]))
+ }));
+break;
+case 54:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.Assign(yy.addLocationDataFn(_$[$0-2])(new yy.Value($$[$0-2])), $$[$0], null, {
+ operatorToken: yy.addLocationDataFn(_$[$0-1])(new yy.Literal($$[$0-1]))
+ }));
+break;
+case 55:
+this.$ = yy.addLocationDataFn(_$[$0-4], _$[$0])(new yy.Assign(yy.addLocationDataFn(_$[$0-4])(new yy.Value($$[$0-4])), $$[$0-1], null, {
+ operatorToken: yy.addLocationDataFn(_$[$0-3])(new yy.Literal($$[$0-3]))
+ }));
+break;
+case 62:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.Return($$[$0]));
+break;
+case 63:
+this.$ = yy.addLocationDataFn(_$[$0-3], _$[$0])(new yy.Return(new yy.Value($$[$0-1])));
+break;
+case 64:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.Return);
+break;
+case 65:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.YieldReturn($$[$0]));
+break;
+case 66:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.YieldReturn);
+break;
+case 67:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.Comment($$[$0]));
+break;
+case 68:
+this.$ = yy.addLocationDataFn(_$[$0-4], _$[$0])(new yy.Code($$[$0-3], $$[$0], $$[$0-1]));
+break;
+case 69:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.Code([], $$[$0], $$[$0-1]));
+break;
+case 70:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])('func');
+break;
+case 71:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])('boundfunc');
+break;
+case 74: case 111:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])([]);
+break;
+case 75: case 112: case 131: case 151: case 183: case 225:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])([$$[$0]]);
+break;
+case 76: case 113: case 132: case 152: case 184:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])($$[$0-2].concat($$[$0]));
+break;
+case 77: case 114: case 133: case 153: case 185:
+this.$ = yy.addLocationDataFn(_$[$0-3], _$[$0])($$[$0-3].concat($$[$0]));
+break;
+case 78: case 115: case 135: case 155: case 187:
+this.$ = yy.addLocationDataFn(_$[$0-5], _$[$0])($$[$0-5].concat($$[$0-2]));
+break;
+case 79:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.Param($$[$0]));
+break;
+case 80:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.Param($$[$0-1], null, true));
+break;
+case 81:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.Param($$[$0-2], $$[$0]));
+break;
+case 82: case 190:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.Expansion);
+break;
+case 87:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.Splat($$[$0-1]));
+break;
+case 89:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])($$[$0-1].add($$[$0]));
+break;
+case 90:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.Value($$[$0-1], [].concat($$[$0])));
+break;
+case 100:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.Access($$[$0]));
+break;
+case 101:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.Access($$[$0], 'soak'));
+break;
+case 102:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])([yy.addLocationDataFn(_$[$0-1])(new yy.Access(new yy.PropertyName('prototype'))), yy.addLocationDataFn(_$[$0])(new yy.Access($$[$0]))]);
+break;
+case 103:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])([yy.addLocationDataFn(_$[$0-1])(new yy.Access(new yy.PropertyName('prototype'), 'soak')), yy.addLocationDataFn(_$[$0])(new yy.Access($$[$0]))]);
+break;
+case 104:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.Access(new yy.PropertyName('prototype')));
+break;
+case 107:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(yy.extend($$[$0], {
+ soak: true
+ }));
+break;
+case 108:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.Index($$[$0]));
+break;
+case 109:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.Slice($$[$0]));
+break;
+case 110:
+this.$ = yy.addLocationDataFn(_$[$0-3], _$[$0])(new yy.Obj($$[$0-2], $$[$0-3].generated));
+break;
+case 116:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.Class);
+break;
+case 117:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.Class(null, null, $$[$0]));
+break;
+case 118:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.Class(null, $$[$0]));
+break;
+case 119:
+this.$ = yy.addLocationDataFn(_$[$0-3], _$[$0])(new yy.Class(null, $$[$0-1], $$[$0]));
+break;
+case 120:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.Class($$[$0]));
+break;
+case 121:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.Class($$[$0-1], null, $$[$0]));
+break;
+case 122:
+this.$ = yy.addLocationDataFn(_$[$0-3], _$[$0])(new yy.Class($$[$0-2], $$[$0]));
+break;
+case 123:
+this.$ = yy.addLocationDataFn(_$[$0-4], _$[$0])(new yy.Class($$[$0-3], $$[$0-1], $$[$0]));
+break;
+case 124:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.ImportDeclaration(null, $$[$0]));
+break;
+case 125:
+this.$ = yy.addLocationDataFn(_$[$0-3], _$[$0])(new yy.ImportDeclaration(new yy.ImportClause($$[$0-2], null), $$[$0]));
+break;
+case 126:
+this.$ = yy.addLocationDataFn(_$[$0-3], _$[$0])(new yy.ImportDeclaration(new yy.ImportClause(null, $$[$0-2]), $$[$0]));
+break;
+case 127:
+this.$ = yy.addLocationDataFn(_$[$0-4], _$[$0])(new yy.ImportDeclaration(new yy.ImportClause(null, new yy.ImportSpecifierList([])), $$[$0]));
+break;
+case 128:
+this.$ = yy.addLocationDataFn(_$[$0-6], _$[$0])(new yy.ImportDeclaration(new yy.ImportClause(null, new yy.ImportSpecifierList($$[$0-4])), $$[$0]));
+break;
+case 129:
+this.$ = yy.addLocationDataFn(_$[$0-5], _$[$0])(new yy.ImportDeclaration(new yy.ImportClause($$[$0-4], $$[$0-2]), $$[$0]));
+break;
+case 130:
+this.$ = yy.addLocationDataFn(_$[$0-8], _$[$0])(new yy.ImportDeclaration(new yy.ImportClause($$[$0-7], new yy.ImportSpecifierList($$[$0-4])), $$[$0]));
+break;
+case 134: case 154: case 170: case 186:
+this.$ = yy.addLocationDataFn(_$[$0-3], _$[$0])($$[$0-2]);
+break;
+case 136:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.ImportSpecifier($$[$0]));
+break;
+case 137:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.ImportSpecifier($$[$0-2], $$[$0]));
+break;
+case 138:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.ImportSpecifier(new yy.Literal($$[$0])));
+break;
+case 139:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.ImportSpecifier(new yy.Literal($$[$0-2]), $$[$0]));
+break;
+case 140:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.ImportDefaultSpecifier($$[$0]));
+break;
+case 141:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.ImportNamespaceSpecifier(new yy.Literal($$[$0-2]), $$[$0]));
+break;
+case 142:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.ExportNamedDeclaration(new yy.ExportSpecifierList([])));
+break;
+case 143:
+this.$ = yy.addLocationDataFn(_$[$0-4], _$[$0])(new yy.ExportNamedDeclaration(new yy.ExportSpecifierList($$[$0-2])));
+break;
+case 144:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.ExportNamedDeclaration($$[$0]));
+break;
+case 145:
+this.$ = yy.addLocationDataFn(_$[$0-3], _$[$0])(new yy.ExportNamedDeclaration(new yy.Assign($$[$0-2], $$[$0], null, {
+ moduleDeclaration: 'export'
+ })));
+break;
+case 146:
+this.$ = yy.addLocationDataFn(_$[$0-4], _$[$0])(new yy.ExportNamedDeclaration(new yy.Assign($$[$0-3], $$[$0], null, {
+ moduleDeclaration: 'export'
+ })));
+break;
+case 147:
+this.$ = yy.addLocationDataFn(_$[$0-5], _$[$0])(new yy.ExportNamedDeclaration(new yy.Assign($$[$0-4], $$[$0-1], null, {
+ moduleDeclaration: 'export'
+ })));
+break;
+case 148:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.ExportDefaultDeclaration($$[$0]));
+break;
+case 149:
+this.$ = yy.addLocationDataFn(_$[$0-3], _$[$0])(new yy.ExportAllDeclaration(new yy.Literal($$[$0-2]), $$[$0]));
+break;
+case 150:
+this.$ = yy.addLocationDataFn(_$[$0-6], _$[$0])(new yy.ExportNamedDeclaration(new yy.ExportSpecifierList($$[$0-4]), $$[$0]));
+break;
+case 156:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.ExportSpecifier($$[$0]));
+break;
+case 157:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.ExportSpecifier($$[$0-2], $$[$0]));
+break;
+case 158:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.ExportSpecifier($$[$0-2], new yy.Literal($$[$0])));
+break;
+case 159:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.ExportSpecifier(new yy.Literal($$[$0])));
+break;
+case 160:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.ExportSpecifier(new yy.Literal($$[$0-2]), $$[$0]));
+break;
+case 161:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.TaggedTemplateCall($$[$0-2], $$[$0], $$[$0-1]));
+break;
+case 162: case 163:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.Call($$[$0-2], $$[$0], $$[$0-1]));
+break;
+case 165:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.SuperCall);
+break;
+case 166:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.SuperCall($$[$0]));
+break;
+case 167:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(false);
+break;
+case 168:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(true);
+break;
+case 169:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])([]);
+break;
+case 171: case 172:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.Value(new yy.ThisLiteral));
+break;
+case 173:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.Value(yy.addLocationDataFn(_$[$0-1])(new yy.ThisLiteral), [yy.addLocationDataFn(_$[$0])(new yy.Access($$[$0]))], 'this'));
+break;
+case 174:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.Arr([]));
+break;
+case 175:
+this.$ = yy.addLocationDataFn(_$[$0-3], _$[$0])(new yy.Arr($$[$0-2]));
+break;
+case 176:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])('inclusive');
+break;
+case 177:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])('exclusive');
+break;
+case 178:
+this.$ = yy.addLocationDataFn(_$[$0-4], _$[$0])(new yy.Range($$[$0-3], $$[$0-1], $$[$0-2]));
+break;
+case 179:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.Range($$[$0-2], $$[$0], $$[$0-1]));
+break;
+case 180:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.Range($$[$0-1], null, $$[$0]));
+break;
+case 181:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.Range(null, $$[$0], $$[$0-1]));
+break;
+case 182:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])(new yy.Range(null, null, $$[$0]));
+break;
+case 192:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])([].concat($$[$0-2], $$[$0]));
+break;
+case 193:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.Try($$[$0]));
+break;
+case 194:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.Try($$[$0-1], $$[$0][0], $$[$0][1]));
+break;
+case 195:
+this.$ = yy.addLocationDataFn(_$[$0-3], _$[$0])(new yy.Try($$[$0-2], null, null, $$[$0]));
+break;
+case 196:
+this.$ = yy.addLocationDataFn(_$[$0-4], _$[$0])(new yy.Try($$[$0-3], $$[$0-2][0], $$[$0-2][1], $$[$0]));
+break;
+case 197:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])([$$[$0-1], $$[$0]]);
+break;
+case 198:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])([yy.addLocationDataFn(_$[$0-1])(new yy.Value($$[$0-1])), $$[$0]]);
+break;
+case 199:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])([null, $$[$0]]);
+break;
+case 200:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.Throw($$[$0]));
+break;
+case 201:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.Parens($$[$0-1]));
+break;
+case 202:
+this.$ = yy.addLocationDataFn(_$[$0-4], _$[$0])(new yy.Parens($$[$0-2]));
+break;
+case 203:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.While($$[$0]));
+break;
+case 204:
+this.$ = yy.addLocationDataFn(_$[$0-3], _$[$0])(new yy.While($$[$0-2], {
+ guard: $$[$0]
+ }));
+break;
+case 205:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.While($$[$0], {
+ invert: true
+ }));
+break;
+case 206:
+this.$ = yy.addLocationDataFn(_$[$0-3], _$[$0])(new yy.While($$[$0-2], {
+ invert: true,
+ guard: $$[$0]
+ }));
+break;
+case 207:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])($$[$0-1].addBody($$[$0]));
+break;
+case 208: case 209:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])($$[$0].addBody(yy.addLocationDataFn(_$[$0-1])(yy.Block.wrap([$$[$0-1]]))));
+break;
+case 210:
+this.$ = yy.addLocationDataFn(_$[$0], _$[$0])($$[$0]);
+break;
+case 211:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.While(yy.addLocationDataFn(_$[$0-1])(new yy.BooleanLiteral('true'))).addBody($$[$0]));
+break;
+case 212:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.While(yy.addLocationDataFn(_$[$0-1])(new yy.BooleanLiteral('true'))).addBody(yy.addLocationDataFn(_$[$0])(yy.Block.wrap([$$[$0]]))));
+break;
+case 213: case 214:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.For($$[$0-1], $$[$0]));
+break;
+case 215:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.For($$[$0], $$[$0-1]));
+break;
+case 216:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])({
+ source: yy.addLocationDataFn(_$[$0])(new yy.Value($$[$0]))
+ });
+break;
+case 217:
+this.$ = yy.addLocationDataFn(_$[$0-3], _$[$0])({
+ source: yy.addLocationDataFn(_$[$0-2])(new yy.Value($$[$0-2])),
+ step: $$[$0]
+ });
+break;
+case 218:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])((function () {
+ $$[$0].own = $$[$0-1].own;
+ $$[$0].ownTag = $$[$0-1].ownTag;
+ $$[$0].name = $$[$0-1][0];
+ $$[$0].index = $$[$0-1][1];
+ return $$[$0];
+ }()));
+break;
+case 219:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])($$[$0]);
+break;
+case 220:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])((function () {
+ $$[$0].own = true;
+ $$[$0].ownTag = yy.addLocationDataFn(_$[$0-1])(new yy.Literal($$[$0-1]));
+ return $$[$0];
+ }()));
+break;
+case 226:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])([$$[$0-2], $$[$0]]);
+break;
+case 227:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])({
+ source: $$[$0]
+ });
+break;
+case 228:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])({
+ source: $$[$0],
+ object: true
+ });
+break;
+case 229:
+this.$ = yy.addLocationDataFn(_$[$0-3], _$[$0])({
+ source: $$[$0-2],
+ guard: $$[$0]
+ });
+break;
+case 230:
+this.$ = yy.addLocationDataFn(_$[$0-3], _$[$0])({
+ source: $$[$0-2],
+ guard: $$[$0],
+ object: true
+ });
+break;
+case 231:
+this.$ = yy.addLocationDataFn(_$[$0-3], _$[$0])({
+ source: $$[$0-2],
+ step: $$[$0]
+ });
+break;
+case 232:
+this.$ = yy.addLocationDataFn(_$[$0-5], _$[$0])({
+ source: $$[$0-4],
+ guard: $$[$0-2],
+ step: $$[$0]
+ });
+break;
+case 233:
+this.$ = yy.addLocationDataFn(_$[$0-5], _$[$0])({
+ source: $$[$0-4],
+ step: $$[$0-2],
+ guard: $$[$0]
+ });
+break;
+case 234:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])({
+ source: $$[$0],
+ from: true
+ });
+break;
+case 235:
+this.$ = yy.addLocationDataFn(_$[$0-3], _$[$0])({
+ source: $$[$0-2],
+ guard: $$[$0],
+ from: true
+ });
+break;
+case 236:
+this.$ = yy.addLocationDataFn(_$[$0-4], _$[$0])(new yy.Switch($$[$0-3], $$[$0-1]));
+break;
+case 237:
+this.$ = yy.addLocationDataFn(_$[$0-6], _$[$0])(new yy.Switch($$[$0-5], $$[$0-3], $$[$0-1]));
+break;
+case 238:
+this.$ = yy.addLocationDataFn(_$[$0-3], _$[$0])(new yy.Switch(null, $$[$0-1]));
+break;
+case 239:
+this.$ = yy.addLocationDataFn(_$[$0-5], _$[$0])(new yy.Switch(null, $$[$0-3], $$[$0-1]));
+break;
+case 241:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])($$[$0-1].concat($$[$0]));
+break;
+case 242:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])([[$$[$0-1], $$[$0]]]);
+break;
+case 243:
+this.$ = yy.addLocationDataFn(_$[$0-3], _$[$0])([[$$[$0-2], $$[$0-1]]]);
+break;
+case 244:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.If($$[$0-1], $$[$0], {
+ type: $$[$0-2]
+ }));
+break;
+case 245:
+this.$ = yy.addLocationDataFn(_$[$0-4], _$[$0])($$[$0-4].addElse(yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.If($$[$0-1], $$[$0], {
+ type: $$[$0-2]
+ }))));
+break;
+case 247:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])($$[$0-2].addElse($$[$0]));
+break;
+case 248: case 249:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.If($$[$0], yy.addLocationDataFn(_$[$0-2])(yy.Block.wrap([$$[$0-2]])), {
+ type: $$[$0-1],
+ statement: true
+ }));
+break;
+case 252:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.Op('-', $$[$0]));
+break;
+case 253:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.Op('+', $$[$0]));
+break;
+case 254:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.Op('--', $$[$0]));
+break;
+case 255:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.Op('++', $$[$0]));
+break;
+case 256:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.Op('--', $$[$0-1], null, true));
+break;
+case 257:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.Op('++', $$[$0-1], null, true));
+break;
+case 258:
+this.$ = yy.addLocationDataFn(_$[$0-1], _$[$0])(new yy.Existence($$[$0-1]));
+break;
+case 259:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.Op('+', $$[$0-2], $$[$0]));
+break;
+case 260:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.Op('-', $$[$0-2], $$[$0]));
+break;
+case 261: case 262: case 263: case 264: case 265: case 266: case 267: case 268: case 269: case 270:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.Op($$[$0-1], $$[$0-2], $$[$0]));
+break;
+case 271:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])((function () {
+ if ($$[$0-1].charAt(0) === '!') {
+ return new yy.Op($$[$0-1].slice(1), $$[$0-2], $$[$0]).invert();
+ } else {
+ return new yy.Op($$[$0-1], $$[$0-2], $$[$0]);
+ }
+ }()));
+break;
+case 272:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.Assign($$[$0-2], $$[$0], $$[$0-1]));
+break;
+case 273:
+this.$ = yy.addLocationDataFn(_$[$0-4], _$[$0])(new yy.Assign($$[$0-4], $$[$0-1], $$[$0-3]));
+break;
+case 274:
+this.$ = yy.addLocationDataFn(_$[$0-3], _$[$0])(new yy.Assign($$[$0-3], $$[$0], $$[$0-2]));
+break;
+case 275:
+this.$ = yy.addLocationDataFn(_$[$0-2], _$[$0])(new yy.Extends($$[$0-2], $$[$0]));
+break;
+}
+},
+table: [{1:[2,1],3:1,4:2,5:3,7:4,8:5,9:6,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V1,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{1:[3]},{1:[2,2],6:$VG},o($VH,[2,3]),o($VH,[2,6],{141:77,132:102,138:103,133:$Vu,135:$Vv,139:$Vx,156:$VI,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($VH,[2,7],{141:77,132:105,138:106,133:$Vu,135:$Vv,139:$Vx,156:$VX}),o($VH,[2,8]),o($VY,[2,14],{109:107,78:108,86:114,40:$VZ,41:$VZ,114:$VZ,82:$V_,83:$V$,84:$V01,85:$V11,87:$V21,90:$V31,113:$V41}),o($VY,[2,15],{86:114,109:117,78:118,82:$V_,83:$V$,84:$V01,85:$V11,87:$V21,90:$V31,113:$V41,114:$VZ}),o($VY,[2,16]),o($VY,[2,17]),o($VY,[2,18]),o($VY,[2,19]),o($VY,[2,20]),o($VY,[2,21]),o($VY,[2,22]),o($VY,[2,23]),o($VY,[2,24]),o($VY,[2,25]),o($VY,[2,26]),o($V51,[2,9]),o($V51,[2,10]),o($V51,[2,11]),o($V51,[2,12]),o($V51,[2,13]),o([1,6,32,42,131,133,135,139,156,163,164,165,166,167,168,169,170,171,172,173,174],$V61,{15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,10:20,11:21,13:23,14:24,54:26,47:27,79:28,80:29,81:30,111:31,67:33,77:40,154:41,132:43,136:44,138:45,75:53,62:54,37:55,43:57,33:70,60:71,141:77,39:80,7:120,8:122,12:$V0,28:$V71,29:$V81,34:$V2,38:$V3,40:$V4,41:$V5,44:$V6,45:$V7,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,61:[1,119],63:$Vf,64:$Vg,68:$Vh,69:$Vi,92:$Vj,95:$Vk,97:$Vl,105:$Vm,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,137:$Vw,149:$Vy,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF}),o($V91,$Va1,{55:[1,124]}),o($V91,[2,96]),o($V91,[2,97]),o($V91,[2,98]),o($V91,[2,99]),o($Vb1,[2,164]),o([6,31,66,71],$Vc1,{65:125,72:126,73:127,33:129,60:130,75:131,62:132,34:$V2,74:$Vd1,92:$Vj,118:$Ve1,119:$Vf1}),{30:135,31:$Vg1},{7:137,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:138,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:139,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:140,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{15:142,16:143,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:144,60:71,62:54,75:53,77:141,79:28,80:29,81:30,92:$Vj,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,130:$Vt},{15:142,16:143,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:144,60:71,62:54,75:53,77:145,79:28,80:29,81:30,92:$Vj,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,130:$Vt},o($Vh1,$Vi1,{96:[1,149],161:[1,146],162:[1,147],175:[1,148]}),o($VY,[2,246],{151:[1,150]}),{30:151,31:$Vg1},{30:152,31:$Vg1},o($VY,[2,210]),{30:153,31:$Vg1},{7:154,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,31:[1,155],33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o($Vj1,[2,116],{47:27,79:28,80:29,81:30,111:31,75:53,62:54,37:55,43:57,33:70,60:71,39:80,15:142,16:143,54:144,30:156,77:158,31:$Vg1,34:$V2,38:$V3,40:$V4,41:$V5,44:$V6,45:$V7,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,92:$Vj,96:[1,157],112:$Vn,117:$Vo,118:$Vp,119:$Vq,130:$Vt}),{7:159,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o($V51,$Vk1,{15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,10:20,11:21,13:23,14:24,54:26,47:27,79:28,80:29,81:30,111:31,67:33,77:40,154:41,132:43,136:44,138:45,75:53,62:54,37:55,43:57,33:70,60:71,141:77,39:80,8:122,7:160,12:$V0,28:$V71,31:$Vl1,34:$V2,38:$V3,40:$V4,41:$V5,44:$V6,45:$V7,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,61:$Ve,63:$Vf,64:$Vg,68:$Vh,69:$Vi,92:$Vj,95:$Vk,97:$Vl,105:$Vm,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,137:$Vw,149:$Vy,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF}),o([1,6,31,32,42,71,94,131,133,135,139,156],[2,67]),{33:166,34:$V2,39:162,40:$V4,41:$V5,92:[1,165],98:163,99:164,104:$Vm1},{25:169,33:170,34:$V2,92:[1,168],95:$Vk,103:[1,171],107:[1,172]},o($Vh1,[2,93]),o($Vh1,[2,94]),o($V91,[2,40]),o($V91,[2,41]),o($V91,[2,42]),o($V91,[2,43]),o($V91,[2,44]),o($V91,[2,45]),o($V91,[2,46]),o($V91,[2,47]),{4:173,5:3,7:4,8:5,9:6,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V1,31:[1,174],33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:175,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,31:$Vn1,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,74:$Vo1,75:53,76:180,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,116:177,117:$Vo,118:$Vp,119:$Vq,120:$Vp1,123:178,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o($V91,[2,171]),o($V91,[2,172],{35:182,36:$Vq1}),o([1,6,31,32,42,46,66,71,74,82,83,84,85,87,89,90,94,113,115,120,122,131,133,134,135,139,140,156,159,160,163,164,165,166,167,168,169,170,171,172,173,174],[2,165],{110:184,114:$Vr1}),{31:[2,70]},{31:[2,71]},o($Vs1,[2,88]),o($Vs1,[2,91]),{7:186,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:187,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:188,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:190,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,30:189,31:$Vg1,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{33:195,34:$V2,60:196,62:198,75:197,80:191,92:$Vj,118:$Ve1,119:$Vq,143:192,144:[1,193],145:194},{142:199,146:[1,200],147:[1,201],148:[1,202]},o([6,31,71,94],$Vt1,{39:80,93:203,56:204,57:205,59:206,11:207,37:208,33:209,35:210,60:211,34:$V2,36:$Vq1,38:$V3,40:$V4,41:$V5,63:$Vf,118:$Ve1}),o($Vu1,[2,34]),o($Vu1,[2,35]),o($V91,[2,38]),{15:142,16:212,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:144,60:71,62:54,75:53,77:213,79:28,80:29,81:30,92:$Vj,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,130:$Vt},o([1,6,29,31,32,40,41,42,55,58,66,71,74,82,83,84,85,87,89,90,94,96,102,113,114,115,120,122,131,133,134,135,139,140,146,147,148,156,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175],[2,32]),o($Vv1,[2,36]),{4:214,5:3,7:4,8:5,9:6,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V1,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o($VH,[2,5],{7:4,8:5,9:6,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,10:20,11:21,13:23,14:24,54:26,47:27,79:28,80:29,81:30,111:31,67:33,77:40,154:41,132:43,136:44,138:45,75:53,62:54,37:55,43:57,33:70,60:71,141:77,39:80,5:215,12:$V0,28:$V1,34:$V2,38:$V3,40:$V4,41:$V5,44:$V6,45:$V7,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,61:$Ve,63:$Vf,64:$Vg,68:$Vh,69:$Vi,92:$Vj,95:$Vk,97:$Vl,105:$Vm,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,133:$Vu,135:$Vv,137:$Vw,139:$Vx,149:$Vy,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF}),o($VY,[2,258]),{7:216,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:217,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:218,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:219,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:220,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:221,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:222,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:223,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:224,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:225,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:226,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:227,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:228,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:229,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o($VY,[2,209]),o($VY,[2,214]),{7:230,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o($VY,[2,208]),o($VY,[2,213]),{39:231,40:$V4,41:$V5,110:232,114:$Vr1},o($Vs1,[2,89]),o($Vw1,[2,168]),{35:233,36:$Vq1},{35:234,36:$Vq1},o($Vs1,[2,104],{35:235,36:$Vq1}),{35:236,36:$Vq1},o($Vs1,[2,105]),{7:238,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,74:$Vx1,75:53,77:40,79:28,80:29,81:30,88:237,91:239,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,121:240,122:$Vy1,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{86:243,87:$V21,90:$V31},{110:244,114:$Vr1},o($Vs1,[2,90]),o($VH,[2,66],{15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,10:20,11:21,13:23,14:24,54:26,47:27,79:28,80:29,81:30,111:31,67:33,77:40,154:41,132:43,136:44,138:45,75:53,62:54,37:55,43:57,33:70,60:71,141:77,39:80,8:122,7:245,12:$V0,28:$V71,31:$Vl1,34:$V2,38:$V3,40:$V4,41:$V5,44:$V6,45:$V7,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,61:$Ve,63:$Vf,64:$Vg,68:$Vh,69:$Vi,92:$Vj,95:$Vk,97:$Vl,105:$Vm,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,133:$Vk1,135:$Vk1,139:$Vk1,156:$Vk1,137:$Vw,149:$Vy,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF}),o($Vz1,[2,28],{141:77,132:102,138:103,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),{7:246,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{132:105,133:$Vu,135:$Vv,138:106,139:$Vx,141:77,156:$VX},o([1,6,31,32,42,66,71,74,89,94,115,120,122,131,133,134,135,139,140,156,163,164,165,166,167,168,169,170,171,172,173,174],$V61,{15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,10:20,11:21,13:23,14:24,54:26,47:27,79:28,80:29,81:30,111:31,67:33,77:40,154:41,132:43,136:44,138:45,75:53,62:54,37:55,43:57,33:70,60:71,141:77,39:80,7:120,8:122,12:$V0,28:$V71,29:$V81,34:$V2,38:$V3,40:$V4,41:$V5,44:$V6,45:$V7,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,61:$Ve,63:$Vf,64:$Vg,68:$Vh,69:$Vi,92:$Vj,95:$Vk,97:$Vl,105:$Vm,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,137:$Vw,149:$Vy,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF}),{6:[1,248],7:247,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,31:[1,249],33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o([6,31],$VA1,{70:252,66:[1,250],71:$VB1}),o($VC1,[2,75]),o($VC1,[2,79],{55:[1,254],74:[1,253]}),o($VC1,[2,82]),o($VD1,[2,83]),o($VD1,[2,84]),o($VD1,[2,85]),o($VD1,[2,86]),{35:182,36:$Vq1},{7:255,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,31:$Vn1,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,74:$Vo1,75:53,76:180,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,116:177,117:$Vo,118:$Vp,119:$Vq,120:$Vp1,123:178,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o($VY,[2,69]),{4:257,5:3,7:4,8:5,9:6,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V1,32:[1,256],33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o([1,6,31,32,42,66,71,74,89,94,115,120,122,131,133,134,135,139,140,156,159,160,164,165,166,167,168,169,170,171,172,173,174],[2,250],{141:77,132:102,138:103,163:$VL}),o($VE1,[2,251],{141:77,132:102,138:103,163:$VL,165:$VN}),o($VE1,[2,252],{141:77,132:102,138:103,163:$VL,165:$VN}),o($VE1,[2,253],{141:77,132:102,138:103,163:$VL,165:$VN}),o($VY,[2,254],{40:$Vi1,41:$Vi1,82:$Vi1,83:$Vi1,84:$Vi1,85:$Vi1,87:$Vi1,90:$Vi1,113:$Vi1,114:$Vi1}),o($Vw1,$VZ,{109:107,78:108,86:114,82:$V_,83:$V$,84:$V01,85:$V11,87:$V21,90:$V31,113:$V41}),{78:118,82:$V_,83:$V$,84:$V01,85:$V11,86:114,87:$V21,90:$V31,109:117,113:$V41,114:$VZ},o($VF1,$Va1),o($VY,[2,255],{40:$Vi1,41:$Vi1,82:$Vi1,83:$Vi1,84:$Vi1,85:$Vi1,87:$Vi1,90:$Vi1,113:$Vi1,114:$Vi1}),o($VY,[2,256]),o($VY,[2,257]),{6:[1,260],7:258,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,31:[1,259],33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:261,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{30:262,31:$Vg1,155:[1,263]},o($VY,[2,193],{126:264,127:[1,265],128:[1,266]}),o($VY,[2,207]),o($VY,[2,215]),{31:[1,267],132:102,133:$Vu,135:$Vv,138:103,139:$Vx,141:77,156:$VI,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW},{150:268,152:269,153:$VG1},o($VY,[2,117]),{7:271,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o($Vj1,[2,120],{30:272,31:$Vg1,40:$Vi1,41:$Vi1,82:$Vi1,83:$Vi1,84:$Vi1,85:$Vi1,87:$Vi1,90:$Vi1,113:$Vi1,114:$Vi1,96:[1,273]}),o($Vz1,[2,200],{141:77,132:102,138:103,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($V51,$VH1,{141:77,132:102,138:103,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),{62:274,92:$Vj},o($V51,[2,124]),{29:[1,275],71:[1,276]},{29:[1,277]},{31:$VI1,33:282,34:$V2,94:[1,278],100:279,101:280,103:$VJ1},o([29,71],[2,140]),{102:[1,284]},{31:$VK1,33:289,34:$V2,94:[1,285],103:$VL1,106:286,108:287},o($V51,[2,144]),{55:[1,291]},{7:292,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{29:[1,293]},{6:$VG,131:[1,294]},{4:295,5:3,7:4,8:5,9:6,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V1,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o([6,31,71,120],$VM1,{141:77,132:102,138:103,121:296,74:[1,297],122:$Vy1,133:$Vu,135:$Vv,139:$Vx,156:$VI,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($VN1,[2,174]),o([6,31,120],$VA1,{70:298,71:$VO1}),o($VP1,[2,183]),{7:255,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,31:$Vn1,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,74:$Vo1,75:53,76:180,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,116:300,117:$Vo,118:$Vp,119:$Vq,123:178,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o($VP1,[2,189]),o($VP1,[2,190]),o($VQ1,[2,173]),o($VQ1,[2,33]),o($Vb1,[2,166]),{7:255,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,31:$Vn1,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,74:$Vo1,75:53,76:180,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,115:[1,301],116:302,117:$Vo,118:$Vp,119:$Vq,123:178,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{30:303,31:$Vg1,132:102,133:$Vu,135:$Vv,138:103,139:$Vx,141:77,156:$VI,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW},o($VR1,[2,203],{141:77,132:102,138:103,133:$Vu,134:[1,304],135:$Vv,139:$Vx,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($VR1,[2,205],{141:77,132:102,138:103,133:$Vu,134:[1,305],135:$Vv,139:$Vx,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($VY,[2,211]),o($VS1,[2,212],{141:77,132:102,138:103,133:$Vu,135:$Vv,139:$Vx,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o([1,6,31,32,42,66,71,74,89,94,115,120,122,131,133,134,135,139,156,159,160,163,164,165,166,167,168,169,170,171,172,173,174],[2,216],{140:[1,306]}),o($VT1,[2,219]),{33:195,34:$V2,60:196,62:198,75:197,92:$Vj,118:$Ve1,119:$Vf1,143:307,145:194},o($VT1,[2,225],{71:[1,308]}),o($VU1,[2,221]),o($VU1,[2,222]),o($VU1,[2,223]),o($VU1,[2,224]),o($VY,[2,218]),{7:309,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:310,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:311,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o($VV1,$VA1,{70:312,71:$VW1}),o($VX1,[2,112]),o($VX1,[2,51],{58:[1,314]}),o($VY1,[2,60],{55:[1,315]}),o($VX1,[2,56]),o($VY1,[2,61]),o($VZ1,[2,57]),o($VZ1,[2,58]),o($VZ1,[2,59]),{46:[1,316],78:118,82:$V_,83:$V$,84:$V01,85:$V11,86:114,87:$V21,90:$V31,109:117,113:$V41,114:$VZ},o($VF1,$Vi1),{6:$VG,42:[1,317]},o($VH,[2,4]),o($V_1,[2,259],{141:77,132:102,138:103,163:$VL,164:$VM,165:$VN}),o($V_1,[2,260],{141:77,132:102,138:103,163:$VL,164:$VM,165:$VN}),o($VE1,[2,261],{141:77,132:102,138:103,163:$VL,165:$VN}),o($VE1,[2,262],{141:77,132:102,138:103,163:$VL,165:$VN}),o([1,6,31,32,42,66,71,74,89,94,115,120,122,131,133,134,135,139,140,156,166,167,168,169,170,171,172,173,174],[2,263],{141:77,132:102,138:103,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN}),o([1,6,31,32,42,66,71,74,89,94,115,120,122,131,133,134,135,139,140,156,167,168,169,170,171,172,173],[2,264],{141:77,132:102,138:103,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,174:$VW}),o([1,6,31,32,42,66,71,74,89,94,115,120,122,131,133,134,135,139,140,156,168,169,170,171,172,173],[2,265],{141:77,132:102,138:103,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,174:$VW}),o([1,6,31,32,42,66,71,74,89,94,115,120,122,131,133,134,135,139,140,156,169,170,171,172,173],[2,266],{141:77,132:102,138:103,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,174:$VW}),o([1,6,31,32,42,66,71,74,89,94,115,120,122,131,133,134,135,139,140,156,170,171,172,173],[2,267],{141:77,132:102,138:103,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,174:$VW}),o([1,6,31,32,42,66,71,74,89,94,115,120,122,131,133,134,135,139,140,156,171,172,173],[2,268],{141:77,132:102,138:103,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,174:$VW}),o([1,6,31,32,42,66,71,74,89,94,115,120,122,131,133,134,135,139,140,156,172,173],[2,269],{141:77,132:102,138:103,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,174:$VW}),o([1,6,31,32,42,66,71,74,89,94,115,120,122,131,133,134,135,139,140,156,173],[2,270],{141:77,132:102,138:103,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,174:$VW}),o([1,6,31,32,42,66,71,74,89,94,115,120,122,131,133,134,135,139,140,156,167,168,169,170,171,172,173,174],[2,271],{141:77,132:102,138:103,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO}),o($VS1,[2,249],{141:77,132:102,138:103,133:$Vu,135:$Vv,139:$Vx,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($VS1,[2,248],{141:77,132:102,138:103,133:$Vu,135:$Vv,139:$Vx,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($Vb1,[2,161]),o($Vb1,[2,162]),o($Vs1,[2,100]),o($Vs1,[2,101]),o($Vs1,[2,102]),o($Vs1,[2,103]),{89:[1,318]},{74:$Vx1,89:[2,108],121:319,122:$Vy1,132:102,133:$Vu,135:$Vv,138:103,139:$Vx,141:77,156:$VI,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW},{89:[2,109]},{7:320,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,89:[2,182],92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o($V$1,[2,176]),o($V$1,$V02),o($Vs1,[2,107]),o($Vb1,[2,163]),o($VH,[2,65],{141:77,132:102,138:103,133:$VH1,135:$VH1,139:$VH1,156:$VH1,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($Vz1,[2,29],{141:77,132:102,138:103,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($Vz1,[2,48],{141:77,132:102,138:103,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),{7:321,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:322,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{67:323,68:$Vh,69:$Vi},o($V12,$V22,{73:127,33:129,60:130,75:131,62:132,72:324,34:$V2,74:$Vd1,92:$Vj,118:$Ve1,119:$Vf1}),{6:$V32,31:$V42},o($VC1,[2,80]),{7:327,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o($VP1,$VM1,{141:77,132:102,138:103,74:[1,328],133:$Vu,135:$Vv,139:$Vx,156:$VI,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($V52,[2,30]),{6:$VG,32:[1,329]},o($Vz1,[2,272],{141:77,132:102,138:103,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),{7:330,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:331,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o($Vz1,[2,275],{141:77,132:102,138:103,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($VY,[2,247]),{7:332,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o($VY,[2,194],{127:[1,333]}),{30:334,31:$Vg1},{30:337,31:$Vg1,33:335,34:$V2,62:336,92:$Vj},{150:338,152:269,153:$VG1},{32:[1,339],151:[1,340],152:341,153:$VG1},o($V62,[2,240]),{7:343,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,124:342,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o($V72,[2,118],{141:77,132:102,138:103,30:344,31:$Vg1,133:$Vu,135:$Vv,139:$Vx,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($VY,[2,121]),{7:345,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{32:[1,346]},{39:347,40:$V4,41:$V5},{92:[1,349],99:348,104:$Vm1},{39:350,40:$V4,41:$V5},{29:[1,351]},o($VV1,$VA1,{70:352,71:$V82}),o($VX1,[2,131]),{31:$VI1,33:282,34:$V2,100:354,101:280,103:$VJ1},o($VX1,[2,136],{102:[1,355]}),o($VX1,[2,138],{102:[1,356]}),{33:357,34:$V2},o($V51,[2,142]),o($VV1,$VA1,{70:358,71:$V92}),o($VX1,[2,151]),{31:$VK1,33:289,34:$V2,103:$VL1,106:360,108:287},o($VX1,[2,156],{102:[1,361]}),o($VX1,[2,159],{102:[1,362]}),{6:[1,364],7:363,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,31:[1,365],33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o($Va2,[2,148],{141:77,132:102,138:103,133:$Vu,135:$Vv,139:$Vx,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),{39:366,40:$V4,41:$V5},o($V91,[2,201]),{6:$VG,32:[1,367]},{7:368,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o([12,28,34,38,40,41,44,45,48,49,50,51,52,53,61,63,64,68,69,92,95,97,105,112,117,118,119,125,129,130,133,135,137,139,149,155,157,158,159,160,161,162],$V02,{6:$Vb2,31:$Vb2,71:$Vb2,120:$Vb2}),{6:$Vc2,31:$Vd2,120:[1,369]},o([6,31,32,115,120],$V22,{15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,10:20,11:21,13:23,14:24,54:26,47:27,79:28,80:29,81:30,111:31,67:33,77:40,154:41,132:43,136:44,138:45,75:53,62:54,37:55,43:57,33:70,60:71,141:77,39:80,8:122,76:180,7:255,123:372,12:$V0,28:$V71,34:$V2,38:$V3,40:$V4,41:$V5,44:$V6,45:$V7,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,61:$Ve,63:$Vf,64:$Vg,68:$Vh,69:$Vi,74:$Vo1,92:$Vj,95:$Vk,97:$Vl,105:$Vm,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,133:$Vu,135:$Vv,137:$Vw,139:$Vx,149:$Vy,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF}),o($V12,$VA1,{70:373,71:$VO1}),o($Vb1,[2,169]),o([6,31,115],$VA1,{70:374,71:$VO1}),o($Ve2,[2,244]),{7:375,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:376,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:377,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o($VT1,[2,220]),{33:195,34:$V2,60:196,62:198,75:197,92:$Vj,118:$Ve1,119:$Vf1,145:378},o([1,6,31,32,42,66,71,74,89,94,115,120,122,131,133,135,139,156],[2,227],{141:77,132:102,138:103,134:[1,379],140:[1,380],159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($Vf2,[2,228],{141:77,132:102,138:103,134:[1,381],159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($Vf2,[2,234],{141:77,132:102,138:103,134:[1,382],159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),{6:$Vg2,31:$Vh2,94:[1,383]},o($Vi2,$V22,{39:80,57:205,59:206,11:207,37:208,33:209,35:210,60:211,56:386,34:$V2,36:$Vq1,38:$V3,40:$V4,41:$V5,63:$Vf,118:$Ve1}),{7:387,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,31:[1,388],33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:389,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,31:[1,390],33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o($V91,[2,39]),o($Vv1,[2,37]),o($Vs1,[2,106]),{7:391,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,89:[2,180],92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{89:[2,181],132:102,133:$Vu,135:$Vv,138:103,139:$Vx,141:77,156:$VI,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW},o($Vz1,[2,49],{141:77,132:102,138:103,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),{32:[1,392],132:102,133:$Vu,135:$Vv,138:103,139:$Vx,141:77,156:$VI,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW},{30:393,31:$Vg1},o($VC1,[2,76]),{33:129,34:$V2,60:130,62:132,72:394,73:127,74:$Vd1,75:131,92:$Vj,118:$Ve1,119:$Vf1},o($Vj2,$Vc1,{72:126,73:127,33:129,60:130,75:131,62:132,65:395,34:$V2,74:$Vd1,92:$Vj,118:$Ve1,119:$Vf1}),o($VC1,[2,81],{141:77,132:102,138:103,133:$Vu,135:$Vv,139:$Vx,156:$VI,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($VP1,$Vb2),o($V52,[2,31]),{32:[1,396],132:102,133:$Vu,135:$Vv,138:103,139:$Vx,141:77,156:$VI,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW},o($Vz1,[2,274],{141:77,132:102,138:103,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),{30:397,31:$Vg1,132:102,133:$Vu,135:$Vv,138:103,139:$Vx,141:77,156:$VI,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW},{30:398,31:$Vg1},o($VY,[2,195]),{30:399,31:$Vg1},{30:400,31:$Vg1},o($Vk2,[2,199]),{32:[1,401],151:[1,402],152:341,153:$VG1},o($VY,[2,238]),{30:403,31:$Vg1},o($V62,[2,241]),{30:404,31:$Vg1,71:[1,405]},o($Vl2,[2,191],{141:77,132:102,138:103,133:$Vu,135:$Vv,139:$Vx,156:$VI,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($VY,[2,119]),o($V72,[2,122],{141:77,132:102,138:103,30:406,31:$Vg1,133:$Vu,135:$Vv,139:$Vx,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($V51,[2,63]),o($V51,[2,125]),{29:[1,407]},{31:$VI1,33:282,34:$V2,100:408,101:280,103:$VJ1},o($V51,[2,126]),{39:409,40:$V4,41:$V5},{6:$Vm2,31:$Vn2,94:[1,410]},o($Vi2,$V22,{33:282,101:413,34:$V2,103:$VJ1}),o($V12,$VA1,{70:414,71:$V82}),{33:415,34:$V2},{33:416,34:$V2},{29:[2,141]},{6:$Vo2,31:$Vp2,94:[1,417]},o($Vi2,$V22,{33:289,108:420,34:$V2,103:$VL1}),o($V12,$VA1,{70:421,71:$V92}),{33:422,34:$V2,103:[1,423]},{33:424,34:$V2},o($Va2,[2,145],{141:77,132:102,138:103,133:$Vu,135:$Vv,139:$Vx,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),{7:425,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:426,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o($V51,[2,149]),{131:[1,427]},{120:[1,428],132:102,133:$Vu,135:$Vv,138:103,139:$Vx,141:77,156:$VI,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW},o($VN1,[2,175]),{7:255,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,74:$Vo1,75:53,76:180,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,123:429,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:255,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,31:$Vn1,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,74:$Vo1,75:53,76:180,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,116:430,117:$Vo,118:$Vp,119:$Vq,123:178,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o($VP1,[2,184]),{6:$Vc2,31:$Vd2,32:[1,431]},{6:$Vc2,31:$Vd2,115:[1,432]},o($VS1,[2,204],{141:77,132:102,138:103,133:$Vu,135:$Vv,139:$Vx,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($VS1,[2,206],{141:77,132:102,138:103,133:$Vu,135:$Vv,139:$Vx,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($VS1,[2,217],{141:77,132:102,138:103,133:$Vu,135:$Vv,139:$Vx,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($VT1,[2,226]),{7:433,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:434,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:435,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:436,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o($VN1,[2,110]),{11:207,33:209,34:$V2,35:210,36:$Vq1,37:208,38:$V3,39:80,40:$V4,41:$V5,56:437,57:205,59:206,60:211,63:$Vf,118:$Ve1},o($Vj2,$Vt1,{39:80,56:204,57:205,59:206,11:207,37:208,33:209,35:210,60:211,93:438,34:$V2,36:$Vq1,38:$V3,40:$V4,41:$V5,63:$Vf,118:$Ve1}),o($VX1,[2,113]),o($VX1,[2,52],{141:77,132:102,138:103,133:$Vu,135:$Vv,139:$Vx,156:$VI,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),{7:439,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o($VX1,[2,54],{141:77,132:102,138:103,133:$Vu,135:$Vv,139:$Vx,156:$VI,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),{7:440,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{89:[2,179],132:102,133:$Vu,135:$Vv,138:103,139:$Vx,141:77,156:$VI,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW},o($VY,[2,50]),o($VY,[2,68]),o($VC1,[2,77]),o($V12,$VA1,{70:441,71:$VB1}),o($VY,[2,273]),o($Ve2,[2,245]),o($VY,[2,196]),o($Vk2,[2,197]),o($Vk2,[2,198]),o($VY,[2,236]),{30:442,31:$Vg1},{32:[1,443]},o($V62,[2,242],{6:[1,444]}),{7:445,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},o($VY,[2,123]),{39:446,40:$V4,41:$V5},o($VV1,$VA1,{70:447,71:$V82}),o($V51,[2,127]),{29:[1,448]},{33:282,34:$V2,101:449,103:$VJ1},{31:$VI1,33:282,34:$V2,100:450,101:280,103:$VJ1},o($VX1,[2,132]),{6:$Vm2,31:$Vn2,32:[1,451]},o($VX1,[2,137]),o($VX1,[2,139]),o($V51,[2,143],{29:[1,452]}),{33:289,34:$V2,103:$VL1,108:453},{31:$VK1,33:289,34:$V2,103:$VL1,106:454,108:287},o($VX1,[2,152]),{6:$Vo2,31:$Vp2,32:[1,455]},o($VX1,[2,157]),o($VX1,[2,158]),o($VX1,[2,160]),o($Va2,[2,146],{141:77,132:102,138:103,133:$Vu,135:$Vv,139:$Vx,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),{32:[1,456],132:102,133:$Vu,135:$Vv,138:103,139:$Vx,141:77,156:$VI,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW},o($V91,[2,202]),o($V91,[2,178]),o($VP1,[2,185]),o($V12,$VA1,{70:457,71:$VO1}),o($VP1,[2,186]),o($Vb1,[2,170]),o([1,6,31,32,42,66,71,74,89,94,115,120,122,131,133,134,135,139,156],[2,229],{141:77,132:102,138:103,140:[1,458],159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($Vf2,[2,231],{141:77,132:102,138:103,134:[1,459],159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($Vz1,[2,230],{141:77,132:102,138:103,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($Vz1,[2,235],{141:77,132:102,138:103,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($VX1,[2,114]),o($V12,$VA1,{70:460,71:$VW1}),{32:[1,461],132:102,133:$Vu,135:$Vv,138:103,139:$Vx,141:77,156:$VI,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW},{32:[1,462],132:102,133:$Vu,135:$Vv,138:103,139:$Vx,141:77,156:$VI,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW},{6:$V32,31:$V42,32:[1,463]},{32:[1,464]},o($VY,[2,239]),o($V62,[2,243]),o($Vl2,[2,192],{141:77,132:102,138:103,133:$Vu,135:$Vv,139:$Vx,156:$VI,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($V51,[2,129]),{6:$Vm2,31:$Vn2,94:[1,465]},{39:466,40:$V4,41:$V5},o($VX1,[2,133]),o($V12,$VA1,{70:467,71:$V82}),o($VX1,[2,134]),{39:468,40:$V4,41:$V5},o($VX1,[2,153]),o($V12,$VA1,{70:469,71:$V92}),o($VX1,[2,154]),o($V51,[2,147]),{6:$Vc2,31:$Vd2,32:[1,470]},{7:471,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{7:472,8:122,10:20,11:21,12:$V0,13:23,14:24,15:7,16:8,17:9,18:10,19:11,20:12,21:13,22:14,23:15,24:16,25:17,26:18,27:19,28:$V71,33:70,34:$V2,37:55,38:$V3,39:80,40:$V4,41:$V5,43:57,44:$V6,45:$V7,47:27,48:$V8,49:$V9,50:$Va,51:$Vb,52:$Vc,53:$Vd,54:26,60:71,61:$Ve,62:54,63:$Vf,64:$Vg,67:33,68:$Vh,69:$Vi,75:53,77:40,79:28,80:29,81:30,92:$Vj,95:$Vk,97:$Vl,105:$Vm,111:31,112:$Vn,117:$Vo,118:$Vp,119:$Vq,125:$Vr,129:$Vs,130:$Vt,132:43,133:$Vu,135:$Vv,136:44,137:$Vw,138:45,139:$Vx,141:77,149:$Vy,154:41,155:$Vz,157:$VA,158:$VB,159:$VC,160:$VD,161:$VE,162:$VF},{6:$Vg2,31:$Vh2,32:[1,473]},o($VX1,[2,53]),o($VX1,[2,55]),o($VC1,[2,78]),o($VY,[2,237]),{29:[1,474]},o($V51,[2,128]),{6:$Vm2,31:$Vn2,32:[1,475]},o($V51,[2,150]),{6:$Vo2,31:$Vp2,32:[1,476]},o($VP1,[2,187]),o($Vz1,[2,232],{141:77,132:102,138:103,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($Vz1,[2,233],{141:77,132:102,138:103,159:$VJ,160:$VK,163:$VL,164:$VM,165:$VN,166:$VO,167:$VP,168:$VQ,169:$VR,170:$VS,171:$VT,172:$VU,173:$VV,174:$VW}),o($VX1,[2,115]),{39:477,40:$V4,41:$V5},o($VX1,[2,135]),o($VX1,[2,155]),o($V51,[2,130])],
+defaultActions: {68:[2,70],69:[2,71],239:[2,109],357:[2,141]},
+parseError: function parseError(str, hash) {
+ if (hash.recoverable) {
+ this.trace(str);
+ } else {
+ function _parseError (msg, hash) {
+ this.message = msg;
+ this.hash = hash;
+ }
+ _parseError.prototype = Error;
+
+ throw new _parseError(str, hash);
+ }
+},
+parse: function parse(input) {
+ var self = this, stack = [0], tstack = [], vstack = [null], lstack = [], table = this.table, yytext = '', yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;
+ var args = lstack.slice.call(arguments, 1);
+ var lexer = Object.create(this.lexer);
+ var sharedState = { yy: {} };
+ for (var k in this.yy) {
+ if (Object.prototype.hasOwnProperty.call(this.yy, k)) {
+ sharedState.yy[k] = this.yy[k];
+ }
+ }
+ lexer.setInput(input, sharedState.yy);
+ sharedState.yy.lexer = lexer;
+ sharedState.yy.parser = this;
+ if (typeof lexer.yylloc == 'undefined') {
+ lexer.yylloc = {};
+ }
+ var yyloc = lexer.yylloc;
+ lstack.push(yyloc);
+ var ranges = lexer.options && lexer.options.ranges;
+ if (typeof sharedState.yy.parseError === 'function') {
+ this.parseError = sharedState.yy.parseError;
+ } else {
+ this.parseError = Object.getPrototypeOf(this).parseError;
+ }
+ function popStack(n) {
+ stack.length = stack.length - 2 * n;
+ vstack.length = vstack.length - n;
+ lstack.length = lstack.length - n;
+ }
+ _token_stack:
+ var lex = function () {
+ var token;
+ token = lexer.lex() || EOF;
+ if (typeof token !== 'number') {
+ token = self.symbols_[token] || token;
+ }
+ return token;
+ };
+ var symbol, preErrorSymbol, state, action, a, r, yyval = {}, p, len, newState, expected;
+ while (true) {
+ state = stack[stack.length - 1];
+ if (this.defaultActions[state]) {
+ action = this.defaultActions[state];
+ } else {
+ if (symbol === null || typeof symbol == 'undefined') {
+ symbol = lex();
+ }
+ action = table[state] && table[state][symbol];
+ }
+ if (typeof action === 'undefined' || !action.length || !action[0]) {
+ var errStr = '';
+ expected = [];
+ for (p in table[state]) {
+ if (this.terminals_[p] && p > TERROR) {
+ expected.push('\'' + this.terminals_[p] + '\'');
+ }
+ }
+ if (lexer.showPosition) {
+ errStr = 'Parse error on line ' + (yylineno + 1) + ':\n' + lexer.showPosition() + '\nExpecting ' + expected.join(', ') + ', got \'' + (this.terminals_[symbol] || symbol) + '\'';
+ } else {
+ errStr = 'Parse error on line ' + (yylineno + 1) + ': Unexpected ' + (symbol == EOF ? 'end of input' : '\'' + (this.terminals_[symbol] || symbol) + '\'');
+ }
+ this.parseError(errStr, {
+ text: lexer.match,
+ token: this.terminals_[symbol] || symbol,
+ line: lexer.yylineno,
+ loc: yyloc,
+ expected: expected
+ });
+ }
+ if (action[0] instanceof Array && action.length > 1) {
+ throw new Error('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol);
+ }
+ switch (action[0]) {
+ case 1:
+ stack.push(symbol);
+ vstack.push(lexer.yytext);
+ lstack.push(lexer.yylloc);
+ stack.push(action[1]);
+ symbol = null;
+ if (!preErrorSymbol) {
+ yyleng = lexer.yyleng;
+ yytext = lexer.yytext;
+ yylineno = lexer.yylineno;
+ yyloc = lexer.yylloc;
+ if (recovering > 0) {
+ recovering--;
+ }
+ } else {
+ symbol = preErrorSymbol;
+ preErrorSymbol = null;
+ }
+ break;
+ case 2:
+ len = this.productions_[action[1]][1];
+ yyval.$ = vstack[vstack.length - len];
+ yyval._$ = {
+ first_line: lstack[lstack.length - (len || 1)].first_line,
+ last_line: lstack[lstack.length - 1].last_line,
+ first_column: lstack[lstack.length - (len || 1)].first_column,
+ last_column: lstack[lstack.length - 1].last_column
+ };
+ if (ranges) {
+ yyval._$.range = [
+ lstack[lstack.length - (len || 1)].range[0],
+ lstack[lstack.length - 1].range[1]
+ ];
+ }
+ r = this.performAction.apply(yyval, [
+ yytext,
+ yyleng,
+ yylineno,
+ sharedState.yy,
+ action[1],
+ vstack,
+ lstack
+ ].concat(args));
+ if (typeof r !== 'undefined') {
+ return r;
+ }
+ if (len) {
+ stack = stack.slice(0, -1 * len * 2);
+ vstack = vstack.slice(0, -1 * len);
+ lstack = lstack.slice(0, -1 * len);
+ }
+ stack.push(this.productions_[action[1]][0]);
+ vstack.push(yyval.$);
+ lstack.push(yyval._$);
+ newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
+ stack.push(newState);
+ break;
+ case 3:
+ return true;
+ }
+ }
+ return true;
+}};
+
+function Parser () {
+ this.yy = {};
+}
+Parser.prototype = parser;parser.Parser = Parser;
+return new Parser;
+})();
+
+
+if (typeof require !== 'undefined' && typeof exports !== 'undefined') {
+exports.parser = parser;
+exports.Parser = parser.Parser;
+exports.parse = function () { return parser.parse.apply(parser, arguments); };
+exports.main = function commonjsMain(args) {
+ if (!args[1]) {
+ console.log('Usage: '+args[0]+' FILE');
+ process.exit(1);
+ }
+ var source = '';
+ var fs = require('fs');
+ if (typeof fs !== 'undefined' && fs !== null)
+ source = fs.readFileSync(require('path').normalize(args[1]), "utf8");
+ return exports.parser.parse(source);
+};
+if (typeof module !== 'undefined' && require.main === module) {
+ exports.main(process.argv.slice(1));
+}
+}
\ No newline at end of file
diff --git a/modeshape-sample/node_modules/coffee-script/lib/coffee-script/register.js b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/register.js
new file mode 100644
index 0000000..7d36ffc
--- /dev/null
+++ b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/register.js
@@ -0,0 +1,66 @@
+// Generated by CoffeeScript 1.12.7
+(function() {
+ var CoffeeScript, Module, binary, child_process, ext, findExtension, fork, helpers, i, len, loadFile, path, ref;
+
+ CoffeeScript = require('./coffee-script');
+
+ child_process = require('child_process');
+
+ helpers = require('./helpers');
+
+ path = require('path');
+
+ loadFile = function(module, filename) {
+ var answer;
+ answer = CoffeeScript._compileFile(filename, false, true);
+ return module._compile(answer, filename);
+ };
+
+ if (require.extensions) {
+ ref = CoffeeScript.FILE_EXTENSIONS;
+ for (i = 0, len = ref.length; i < len; i++) {
+ ext = ref[i];
+ require.extensions[ext] = loadFile;
+ }
+ Module = require('module');
+ findExtension = function(filename) {
+ var curExtension, extensions;
+ extensions = path.basename(filename).split('.');
+ if (extensions[0] === '') {
+ extensions.shift();
+ }
+ while (extensions.shift()) {
+ curExtension = '.' + extensions.join('.');
+ if (Module._extensions[curExtension]) {
+ return curExtension;
+ }
+ }
+ return '.js';
+ };
+ Module.prototype.load = function(filename) {
+ var extension;
+ this.filename = filename;
+ this.paths = Module._nodeModulePaths(path.dirname(filename));
+ extension = findExtension(filename);
+ Module._extensions[extension](this, filename);
+ return this.loaded = true;
+ };
+ }
+
+ if (child_process) {
+ fork = child_process.fork;
+ binary = require.resolve('../../bin/coffee');
+ child_process.fork = function(path, args, options) {
+ if (helpers.isCoffee(path)) {
+ if (!Array.isArray(args)) {
+ options = args || {};
+ args = [];
+ }
+ args = [path].concat(args);
+ path = binary;
+ }
+ return fork(path, args, options);
+ };
+ }
+
+}).call(this);
diff --git a/modeshape-sample/node_modules/coffee-script/lib/coffee-script/repl.js b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/repl.js
new file mode 100644
index 0000000..e74fe5e
--- /dev/null
+++ b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/repl.js
@@ -0,0 +1,203 @@
+// Generated by CoffeeScript 1.12.7
+(function() {
+ var CoffeeScript, addHistory, addMultilineHandler, fs, getCommandId, merge, nodeREPL, path, ref, replDefaults, runInContext, updateSyntaxError, vm;
+
+ fs = require('fs');
+
+ path = require('path');
+
+ vm = require('vm');
+
+ nodeREPL = require('repl');
+
+ CoffeeScript = require('./coffee-script');
+
+ ref = require('./helpers'), merge = ref.merge, updateSyntaxError = ref.updateSyntaxError;
+
+ replDefaults = {
+ prompt: 'coffee> ',
+ historyFile: process.env.HOME ? path.join(process.env.HOME, '.coffee_history') : void 0,
+ historyMaxInputSize: 10240,
+ "eval": function(input, context, filename, cb) {
+ var Assign, Block, Literal, Value, ast, err, js, ref1, referencedVars, token, tokens;
+ input = input.replace(/\uFF00/g, '\n');
+ input = input.replace(/^\(([\s\S]*)\n\)$/m, '$1');
+ input = input.replace(/^\s*try\s*{([\s\S]*)}\s*catch.*$/m, '$1');
+ ref1 = require('./nodes'), Block = ref1.Block, Assign = ref1.Assign, Value = ref1.Value, Literal = ref1.Literal;
+ try {
+ tokens = CoffeeScript.tokens(input);
+ referencedVars = (function() {
+ var i, len, results;
+ results = [];
+ for (i = 0, len = tokens.length; i < len; i++) {
+ token = tokens[i];
+ if (token[0] === 'IDENTIFIER') {
+ results.push(token[1]);
+ }
+ }
+ return results;
+ })();
+ ast = CoffeeScript.nodes(tokens);
+ ast = new Block([new Assign(new Value(new Literal('__')), ast, '=')]);
+ js = ast.compile({
+ bare: true,
+ locals: Object.keys(context),
+ referencedVars: referencedVars
+ });
+ return cb(null, runInContext(js, context, filename));
+ } catch (error) {
+ err = error;
+ updateSyntaxError(err, input);
+ return cb(err);
+ }
+ }
+ };
+
+ runInContext = function(js, context, filename) {
+ if (context === global) {
+ return vm.runInThisContext(js, filename);
+ } else {
+ return vm.runInContext(js, context, filename);
+ }
+ };
+
+ addMultilineHandler = function(repl) {
+ var inputStream, multiline, nodeLineListener, origPrompt, outputStream, ref1, rli;
+ rli = repl.rli, inputStream = repl.inputStream, outputStream = repl.outputStream;
+ origPrompt = (ref1 = repl._prompt) != null ? ref1 : repl.prompt;
+ multiline = {
+ enabled: false,
+ initialPrompt: origPrompt.replace(/^[^> ]*/, function(x) {
+ return x.replace(/./g, '-');
+ }),
+ prompt: origPrompt.replace(/^[^> ]*>?/, function(x) {
+ return x.replace(/./g, '.');
+ }),
+ buffer: ''
+ };
+ nodeLineListener = rli.listeners('line')[0];
+ rli.removeListener('line', nodeLineListener);
+ rli.on('line', function(cmd) {
+ if (multiline.enabled) {
+ multiline.buffer += cmd + "\n";
+ rli.setPrompt(multiline.prompt);
+ rli.prompt(true);
+ } else {
+ rli.setPrompt(origPrompt);
+ nodeLineListener(cmd);
+ }
+ });
+ return inputStream.on('keypress', function(char, key) {
+ if (!(key && key.ctrl && !key.meta && !key.shift && key.name === 'v')) {
+ return;
+ }
+ if (multiline.enabled) {
+ if (!multiline.buffer.match(/\n/)) {
+ multiline.enabled = !multiline.enabled;
+ rli.setPrompt(origPrompt);
+ rli.prompt(true);
+ return;
+ }
+ if ((rli.line != null) && !rli.line.match(/^\s*$/)) {
+ return;
+ }
+ multiline.enabled = !multiline.enabled;
+ rli.line = '';
+ rli.cursor = 0;
+ rli.output.cursorTo(0);
+ rli.output.clearLine(1);
+ multiline.buffer = multiline.buffer.replace(/\n/g, '\uFF00');
+ rli.emit('line', multiline.buffer);
+ multiline.buffer = '';
+ } else {
+ multiline.enabled = !multiline.enabled;
+ rli.setPrompt(multiline.initialPrompt);
+ rli.prompt(true);
+ }
+ });
+ };
+
+ addHistory = function(repl, filename, maxSize) {
+ var buffer, fd, lastLine, readFd, size, stat;
+ lastLine = null;
+ try {
+ stat = fs.statSync(filename);
+ size = Math.min(maxSize, stat.size);
+ readFd = fs.openSync(filename, 'r');
+ buffer = new Buffer(size);
+ fs.readSync(readFd, buffer, 0, size, stat.size - size);
+ fs.closeSync(readFd);
+ repl.rli.history = buffer.toString().split('\n').reverse();
+ if (stat.size > maxSize) {
+ repl.rli.history.pop();
+ }
+ if (repl.rli.history[0] === '') {
+ repl.rli.history.shift();
+ }
+ repl.rli.historyIndex = -1;
+ lastLine = repl.rli.history[0];
+ } catch (error) {}
+ fd = fs.openSync(filename, 'a');
+ repl.rli.addListener('line', function(code) {
+ if (code && code.length && code !== '.history' && code !== '.exit' && lastLine !== code) {
+ fs.writeSync(fd, code + "\n");
+ return lastLine = code;
+ }
+ });
+ repl.on('exit', function() {
+ return fs.closeSync(fd);
+ });
+ return repl.commands[getCommandId(repl, 'history')] = {
+ help: 'Show command history',
+ action: function() {
+ repl.outputStream.write((repl.rli.history.slice(0).reverse().join('\n')) + "\n");
+ return repl.displayPrompt();
+ }
+ };
+ };
+
+ getCommandId = function(repl, commandName) {
+ var commandsHaveLeadingDot;
+ commandsHaveLeadingDot = repl.commands['.help'] != null;
+ if (commandsHaveLeadingDot) {
+ return "." + commandName;
+ } else {
+ return commandName;
+ }
+ };
+
+ module.exports = {
+ start: function(opts) {
+ var build, major, minor, ref1, repl;
+ if (opts == null) {
+ opts = {};
+ }
+ ref1 = process.versions.node.split('.').map(function(n) {
+ return parseInt(n, 10);
+ }), major = ref1[0], minor = ref1[1], build = ref1[2];
+ if (major === 0 && minor < 8) {
+ console.warn("Node 0.8.0+ required for CoffeeScript REPL");
+ process.exit(1);
+ }
+ CoffeeScript.register();
+ process.argv = ['coffee'].concat(process.argv.slice(2));
+ opts = merge(replDefaults, opts);
+ repl = nodeREPL.start(opts);
+ if (opts.prelude) {
+ runInContext(opts.prelude, repl.context, 'prelude');
+ }
+ repl.on('exit', function() {
+ if (!repl.rli.closed) {
+ return repl.outputStream.write('\n');
+ }
+ });
+ addMultilineHandler(repl);
+ if (opts.historyFile) {
+ addHistory(repl, opts.historyFile, opts.historyMaxInputSize);
+ }
+ repl.commands[getCommandId(repl, 'load')].help = 'Load code from a file into this REPL session';
+ return repl;
+ }
+ };
+
+}).call(this);
diff --git a/modeshape-sample/node_modules/coffee-script/lib/coffee-script/rewriter.js b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/rewriter.js
new file mode 100644
index 0000000..b0e25e1
--- /dev/null
+++ b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/rewriter.js
@@ -0,0 +1,537 @@
+// Generated by CoffeeScript 1.12.7
+(function() {
+ var BALANCED_PAIRS, CALL_CLOSERS, EXPRESSION_CLOSE, EXPRESSION_END, EXPRESSION_START, IMPLICIT_CALL, IMPLICIT_END, IMPLICIT_FUNC, IMPLICIT_UNSPACED_CALL, INVERSES, LINEBREAKS, Rewriter, SINGLE_CLOSERS, SINGLE_LINERS, generate, k, left, len, ref, rite,
+ indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; },
+ slice = [].slice;
+
+ generate = function(tag, value, origin) {
+ var tok;
+ tok = [tag, value];
+ tok.generated = true;
+ if (origin) {
+ tok.origin = origin;
+ }
+ return tok;
+ };
+
+ exports.Rewriter = Rewriter = (function() {
+ function Rewriter() {}
+
+ Rewriter.prototype.rewrite = function(tokens1) {
+ this.tokens = tokens1;
+ this.removeLeadingNewlines();
+ this.closeOpenCalls();
+ this.closeOpenIndexes();
+ this.normalizeLines();
+ this.tagPostfixConditionals();
+ this.addImplicitBracesAndParens();
+ this.addLocationDataToGeneratedTokens();
+ this.fixOutdentLocationData();
+ return this.tokens;
+ };
+
+ Rewriter.prototype.scanTokens = function(block) {
+ var i, token, tokens;
+ tokens = this.tokens;
+ i = 0;
+ while (token = tokens[i]) {
+ i += block.call(this, token, i, tokens);
+ }
+ return true;
+ };
+
+ Rewriter.prototype.detectEnd = function(i, condition, action) {
+ var levels, ref, ref1, token, tokens;
+ tokens = this.tokens;
+ levels = 0;
+ while (token = tokens[i]) {
+ if (levels === 0 && condition.call(this, token, i)) {
+ return action.call(this, token, i);
+ }
+ if (!token || levels < 0) {
+ return action.call(this, token, i - 1);
+ }
+ if (ref = token[0], indexOf.call(EXPRESSION_START, ref) >= 0) {
+ levels += 1;
+ } else if (ref1 = token[0], indexOf.call(EXPRESSION_END, ref1) >= 0) {
+ levels -= 1;
+ }
+ i += 1;
+ }
+ return i - 1;
+ };
+
+ Rewriter.prototype.removeLeadingNewlines = function() {
+ var i, k, len, ref, tag;
+ ref = this.tokens;
+ for (i = k = 0, len = ref.length; k < len; i = ++k) {
+ tag = ref[i][0];
+ if (tag !== 'TERMINATOR') {
+ break;
+ }
+ }
+ if (i) {
+ return this.tokens.splice(0, i);
+ }
+ };
+
+ Rewriter.prototype.closeOpenCalls = function() {
+ var action, condition;
+ condition = function(token, i) {
+ var ref;
+ return ((ref = token[0]) === ')' || ref === 'CALL_END') || token[0] === 'OUTDENT' && this.tag(i - 1) === ')';
+ };
+ action = function(token, i) {
+ return this.tokens[token[0] === 'OUTDENT' ? i - 1 : i][0] = 'CALL_END';
+ };
+ return this.scanTokens(function(token, i) {
+ if (token[0] === 'CALL_START') {
+ this.detectEnd(i + 1, condition, action);
+ }
+ return 1;
+ });
+ };
+
+ Rewriter.prototype.closeOpenIndexes = function() {
+ var action, condition;
+ condition = function(token, i) {
+ var ref;
+ return (ref = token[0]) === ']' || ref === 'INDEX_END';
+ };
+ action = function(token, i) {
+ return token[0] = 'INDEX_END';
+ };
+ return this.scanTokens(function(token, i) {
+ if (token[0] === 'INDEX_START') {
+ this.detectEnd(i + 1, condition, action);
+ }
+ return 1;
+ });
+ };
+
+ Rewriter.prototype.indexOfTag = function() {
+ var fuzz, i, j, k, pattern, ref, ref1;
+ i = arguments[0], pattern = 2 <= arguments.length ? slice.call(arguments, 1) : [];
+ fuzz = 0;
+ for (j = k = 0, ref = pattern.length; 0 <= ref ? k < ref : k > ref; j = 0 <= ref ? ++k : --k) {
+ while (this.tag(i + j + fuzz) === 'HERECOMMENT') {
+ fuzz += 2;
+ }
+ if (pattern[j] == null) {
+ continue;
+ }
+ if (typeof pattern[j] === 'string') {
+ pattern[j] = [pattern[j]];
+ }
+ if (ref1 = this.tag(i + j + fuzz), indexOf.call(pattern[j], ref1) < 0) {
+ return -1;
+ }
+ }
+ return i + j + fuzz - 1;
+ };
+
+ Rewriter.prototype.looksObjectish = function(j) {
+ var end, index;
+ if (this.indexOfTag(j, '@', null, ':') > -1 || this.indexOfTag(j, null, ':') > -1) {
+ return true;
+ }
+ index = this.indexOfTag(j, EXPRESSION_START);
+ if (index > -1) {
+ end = null;
+ this.detectEnd(index + 1, (function(token) {
+ var ref;
+ return ref = token[0], indexOf.call(EXPRESSION_END, ref) >= 0;
+ }), (function(token, i) {
+ return end = i;
+ }));
+ if (this.tag(end + 1) === ':') {
+ return true;
+ }
+ }
+ return false;
+ };
+
+ Rewriter.prototype.findTagsBackwards = function(i, tags) {
+ var backStack, ref, ref1, ref2, ref3, ref4, ref5;
+ backStack = [];
+ while (i >= 0 && (backStack.length || (ref2 = this.tag(i), indexOf.call(tags, ref2) < 0) && ((ref3 = this.tag(i), indexOf.call(EXPRESSION_START, ref3) < 0) || this.tokens[i].generated) && (ref4 = this.tag(i), indexOf.call(LINEBREAKS, ref4) < 0))) {
+ if (ref = this.tag(i), indexOf.call(EXPRESSION_END, ref) >= 0) {
+ backStack.push(this.tag(i));
+ }
+ if ((ref1 = this.tag(i), indexOf.call(EXPRESSION_START, ref1) >= 0) && backStack.length) {
+ backStack.pop();
+ }
+ i -= 1;
+ }
+ return ref5 = this.tag(i), indexOf.call(tags, ref5) >= 0;
+ };
+
+ Rewriter.prototype.addImplicitBracesAndParens = function() {
+ var stack, start;
+ stack = [];
+ start = null;
+ return this.scanTokens(function(token, i, tokens) {
+ var endImplicitCall, endImplicitObject, forward, inImplicit, inImplicitCall, inImplicitControl, inImplicitObject, isImplicit, isImplicitCall, isImplicitObject, k, newLine, nextTag, offset, prevTag, prevToken, ref, ref1, ref2, ref3, ref4, ref5, s, sameLine, stackIdx, stackItem, stackTag, stackTop, startIdx, startImplicitCall, startImplicitObject, startsLine, tag;
+ tag = token[0];
+ prevTag = (prevToken = i > 0 ? tokens[i - 1] : [])[0];
+ nextTag = (i < tokens.length - 1 ? tokens[i + 1] : [])[0];
+ stackTop = function() {
+ return stack[stack.length - 1];
+ };
+ startIdx = i;
+ forward = function(n) {
+ return i - startIdx + n;
+ };
+ isImplicit = function(stackItem) {
+ var ref;
+ return stackItem != null ? (ref = stackItem[2]) != null ? ref.ours : void 0 : void 0;
+ };
+ isImplicitObject = function(stackItem) {
+ return isImplicit(stackItem) && (stackItem != null ? stackItem[0] : void 0) === '{';
+ };
+ isImplicitCall = function(stackItem) {
+ return isImplicit(stackItem) && (stackItem != null ? stackItem[0] : void 0) === '(';
+ };
+ inImplicit = function() {
+ return isImplicit(stackTop());
+ };
+ inImplicitCall = function() {
+ return isImplicitCall(stackTop());
+ };
+ inImplicitObject = function() {
+ return isImplicitObject(stackTop());
+ };
+ inImplicitControl = function() {
+ var ref;
+ return inImplicit && ((ref = stackTop()) != null ? ref[0] : void 0) === 'CONTROL';
+ };
+ startImplicitCall = function(j) {
+ var idx;
+ idx = j != null ? j : i;
+ stack.push([
+ '(', idx, {
+ ours: true
+ }
+ ]);
+ tokens.splice(idx, 0, generate('CALL_START', '(', ['', 'implicit function call', token[2]]));
+ if (j == null) {
+ return i += 1;
+ }
+ };
+ endImplicitCall = function() {
+ stack.pop();
+ tokens.splice(i, 0, generate('CALL_END', ')', ['', 'end of input', token[2]]));
+ return i += 1;
+ };
+ startImplicitObject = function(j, startsLine) {
+ var idx, val;
+ if (startsLine == null) {
+ startsLine = true;
+ }
+ idx = j != null ? j : i;
+ stack.push([
+ '{', idx, {
+ sameLine: true,
+ startsLine: startsLine,
+ ours: true
+ }
+ ]);
+ val = new String('{');
+ val.generated = true;
+ tokens.splice(idx, 0, generate('{', val, token));
+ if (j == null) {
+ return i += 1;
+ }
+ };
+ endImplicitObject = function(j) {
+ j = j != null ? j : i;
+ stack.pop();
+ tokens.splice(j, 0, generate('}', '}', token));
+ return i += 1;
+ };
+ if (inImplicitCall() && (tag === 'IF' || tag === 'TRY' || tag === 'FINALLY' || tag === 'CATCH' || tag === 'CLASS' || tag === 'SWITCH')) {
+ stack.push([
+ 'CONTROL', i, {
+ ours: true
+ }
+ ]);
+ return forward(1);
+ }
+ if (tag === 'INDENT' && inImplicit()) {
+ if (prevTag !== '=>' && prevTag !== '->' && prevTag !== '[' && prevTag !== '(' && prevTag !== ',' && prevTag !== '{' && prevTag !== 'TRY' && prevTag !== 'ELSE' && prevTag !== '=') {
+ while (inImplicitCall()) {
+ endImplicitCall();
+ }
+ }
+ if (inImplicitControl()) {
+ stack.pop();
+ }
+ stack.push([tag, i]);
+ return forward(1);
+ }
+ if (indexOf.call(EXPRESSION_START, tag) >= 0) {
+ stack.push([tag, i]);
+ return forward(1);
+ }
+ if (indexOf.call(EXPRESSION_END, tag) >= 0) {
+ while (inImplicit()) {
+ if (inImplicitCall()) {
+ endImplicitCall();
+ } else if (inImplicitObject()) {
+ endImplicitObject();
+ } else {
+ stack.pop();
+ }
+ }
+ start = stack.pop();
+ }
+ if ((indexOf.call(IMPLICIT_FUNC, tag) >= 0 && token.spaced || tag === '?' && i > 0 && !tokens[i - 1].spaced) && (indexOf.call(IMPLICIT_CALL, nextTag) >= 0 || indexOf.call(IMPLICIT_UNSPACED_CALL, nextTag) >= 0 && !((ref = tokens[i + 1]) != null ? ref.spaced : void 0) && !((ref1 = tokens[i + 1]) != null ? ref1.newLine : void 0))) {
+ if (tag === '?') {
+ tag = token[0] = 'FUNC_EXIST';
+ }
+ startImplicitCall(i + 1);
+ return forward(2);
+ }
+ if (indexOf.call(IMPLICIT_FUNC, tag) >= 0 && this.indexOfTag(i + 1, 'INDENT') > -1 && this.looksObjectish(i + 2) && !this.findTagsBackwards(i, ['CLASS', 'EXTENDS', 'IF', 'CATCH', 'SWITCH', 'LEADING_WHEN', 'FOR', 'WHILE', 'UNTIL'])) {
+ startImplicitCall(i + 1);
+ stack.push(['INDENT', i + 2]);
+ return forward(3);
+ }
+ if (tag === ':') {
+ s = (function() {
+ var ref2;
+ switch (false) {
+ case ref2 = this.tag(i - 1), indexOf.call(EXPRESSION_END, ref2) < 0:
+ return start[1];
+ case this.tag(i - 2) !== '@':
+ return i - 2;
+ default:
+ return i - 1;
+ }
+ }).call(this);
+ while (this.tag(s - 2) === 'HERECOMMENT') {
+ s -= 2;
+ }
+ this.insideForDeclaration = nextTag === 'FOR';
+ startsLine = s === 0 || (ref2 = this.tag(s - 1), indexOf.call(LINEBREAKS, ref2) >= 0) || tokens[s - 1].newLine;
+ if (stackTop()) {
+ ref3 = stackTop(), stackTag = ref3[0], stackIdx = ref3[1];
+ if ((stackTag === '{' || stackTag === 'INDENT' && this.tag(stackIdx - 1) === '{') && (startsLine || this.tag(s - 1) === ',' || this.tag(s - 1) === '{')) {
+ return forward(1);
+ }
+ }
+ startImplicitObject(s, !!startsLine);
+ return forward(2);
+ }
+ if (indexOf.call(LINEBREAKS, tag) >= 0) {
+ for (k = stack.length - 1; k >= 0; k += -1) {
+ stackItem = stack[k];
+ if (!isImplicit(stackItem)) {
+ break;
+ }
+ if (isImplicitObject(stackItem)) {
+ stackItem[2].sameLine = false;
+ }
+ }
+ }
+ newLine = prevTag === 'OUTDENT' || prevToken.newLine;
+ if (indexOf.call(IMPLICIT_END, tag) >= 0 || indexOf.call(CALL_CLOSERS, tag) >= 0 && newLine) {
+ while (inImplicit()) {
+ ref4 = stackTop(), stackTag = ref4[0], stackIdx = ref4[1], (ref5 = ref4[2], sameLine = ref5.sameLine, startsLine = ref5.startsLine);
+ if (inImplicitCall() && prevTag !== ',') {
+ endImplicitCall();
+ } else if (inImplicitObject() && !this.insideForDeclaration && sameLine && tag !== 'TERMINATOR' && prevTag !== ':') {
+ endImplicitObject();
+ } else if (inImplicitObject() && tag === 'TERMINATOR' && prevTag !== ',' && !(startsLine && this.looksObjectish(i + 1))) {
+ if (nextTag === 'HERECOMMENT') {
+ return forward(1);
+ }
+ endImplicitObject();
+ } else {
+ break;
+ }
+ }
+ }
+ if (tag === ',' && !this.looksObjectish(i + 1) && inImplicitObject() && !this.insideForDeclaration && (nextTag !== 'TERMINATOR' || !this.looksObjectish(i + 2))) {
+ offset = nextTag === 'OUTDENT' ? 1 : 0;
+ while (inImplicitObject()) {
+ endImplicitObject(i + offset);
+ }
+ }
+ return forward(1);
+ });
+ };
+
+ Rewriter.prototype.addLocationDataToGeneratedTokens = function() {
+ return this.scanTokens(function(token, i, tokens) {
+ var column, line, nextLocation, prevLocation, ref, ref1;
+ if (token[2]) {
+ return 1;
+ }
+ if (!(token.generated || token.explicit)) {
+ return 1;
+ }
+ if (token[0] === '{' && (nextLocation = (ref = tokens[i + 1]) != null ? ref[2] : void 0)) {
+ line = nextLocation.first_line, column = nextLocation.first_column;
+ } else if (prevLocation = (ref1 = tokens[i - 1]) != null ? ref1[2] : void 0) {
+ line = prevLocation.last_line, column = prevLocation.last_column;
+ } else {
+ line = column = 0;
+ }
+ token[2] = {
+ first_line: line,
+ first_column: column,
+ last_line: line,
+ last_column: column
+ };
+ return 1;
+ });
+ };
+
+ Rewriter.prototype.fixOutdentLocationData = function() {
+ return this.scanTokens(function(token, i, tokens) {
+ var prevLocationData;
+ if (!(token[0] === 'OUTDENT' || (token.generated && token[0] === 'CALL_END') || (token.generated && token[0] === '}'))) {
+ return 1;
+ }
+ prevLocationData = tokens[i - 1][2];
+ token[2] = {
+ first_line: prevLocationData.last_line,
+ first_column: prevLocationData.last_column,
+ last_line: prevLocationData.last_line,
+ last_column: prevLocationData.last_column
+ };
+ return 1;
+ });
+ };
+
+ Rewriter.prototype.normalizeLines = function() {
+ var action, condition, indent, outdent, starter;
+ starter = indent = outdent = null;
+ condition = function(token, i) {
+ var ref, ref1, ref2, ref3;
+ return token[1] !== ';' && (ref = token[0], indexOf.call(SINGLE_CLOSERS, ref) >= 0) && !(token[0] === 'TERMINATOR' && (ref1 = this.tag(i + 1), indexOf.call(EXPRESSION_CLOSE, ref1) >= 0)) && !(token[0] === 'ELSE' && starter !== 'THEN') && !(((ref2 = token[0]) === 'CATCH' || ref2 === 'FINALLY') && (starter === '->' || starter === '=>')) || (ref3 = token[0], indexOf.call(CALL_CLOSERS, ref3) >= 0) && (this.tokens[i - 1].newLine || this.tokens[i - 1][0] === 'OUTDENT');
+ };
+ action = function(token, i) {
+ return this.tokens.splice((this.tag(i - 1) === ',' ? i - 1 : i), 0, outdent);
+ };
+ return this.scanTokens(function(token, i, tokens) {
+ var j, k, ref, ref1, ref2, tag;
+ tag = token[0];
+ if (tag === 'TERMINATOR') {
+ if (this.tag(i + 1) === 'ELSE' && this.tag(i - 1) !== 'OUTDENT') {
+ tokens.splice.apply(tokens, [i, 1].concat(slice.call(this.indentation())));
+ return 1;
+ }
+ if (ref = this.tag(i + 1), indexOf.call(EXPRESSION_CLOSE, ref) >= 0) {
+ tokens.splice(i, 1);
+ return 0;
+ }
+ }
+ if (tag === 'CATCH') {
+ for (j = k = 1; k <= 2; j = ++k) {
+ if (!((ref1 = this.tag(i + j)) === 'OUTDENT' || ref1 === 'TERMINATOR' || ref1 === 'FINALLY')) {
+ continue;
+ }
+ tokens.splice.apply(tokens, [i + j, 0].concat(slice.call(this.indentation())));
+ return 2 + j;
+ }
+ }
+ if (indexOf.call(SINGLE_LINERS, tag) >= 0 && this.tag(i + 1) !== 'INDENT' && !(tag === 'ELSE' && this.tag(i + 1) === 'IF')) {
+ starter = tag;
+ ref2 = this.indentation(tokens[i]), indent = ref2[0], outdent = ref2[1];
+ if (starter === 'THEN') {
+ indent.fromThen = true;
+ }
+ tokens.splice(i + 1, 0, indent);
+ this.detectEnd(i + 2, condition, action);
+ if (tag === 'THEN') {
+ tokens.splice(i, 1);
+ }
+ return 1;
+ }
+ return 1;
+ });
+ };
+
+ Rewriter.prototype.tagPostfixConditionals = function() {
+ var action, condition, original;
+ original = null;
+ condition = function(token, i) {
+ var prevTag, tag;
+ tag = token[0];
+ prevTag = this.tokens[i - 1][0];
+ return tag === 'TERMINATOR' || (tag === 'INDENT' && indexOf.call(SINGLE_LINERS, prevTag) < 0);
+ };
+ action = function(token, i) {
+ if (token[0] !== 'INDENT' || (token.generated && !token.fromThen)) {
+ return original[0] = 'POST_' + original[0];
+ }
+ };
+ return this.scanTokens(function(token, i) {
+ if (token[0] !== 'IF') {
+ return 1;
+ }
+ original = token;
+ this.detectEnd(i + 1, condition, action);
+ return 1;
+ });
+ };
+
+ Rewriter.prototype.indentation = function(origin) {
+ var indent, outdent;
+ indent = ['INDENT', 2];
+ outdent = ['OUTDENT', 2];
+ if (origin) {
+ indent.generated = outdent.generated = true;
+ indent.origin = outdent.origin = origin;
+ } else {
+ indent.explicit = outdent.explicit = true;
+ }
+ return [indent, outdent];
+ };
+
+ Rewriter.prototype.generate = generate;
+
+ Rewriter.prototype.tag = function(i) {
+ var ref;
+ return (ref = this.tokens[i]) != null ? ref[0] : void 0;
+ };
+
+ return Rewriter;
+
+ })();
+
+ BALANCED_PAIRS = [['(', ')'], ['[', ']'], ['{', '}'], ['INDENT', 'OUTDENT'], ['CALL_START', 'CALL_END'], ['PARAM_START', 'PARAM_END'], ['INDEX_START', 'INDEX_END'], ['STRING_START', 'STRING_END'], ['REGEX_START', 'REGEX_END']];
+
+ exports.INVERSES = INVERSES = {};
+
+ EXPRESSION_START = [];
+
+ EXPRESSION_END = [];
+
+ for (k = 0, len = BALANCED_PAIRS.length; k < len; k++) {
+ ref = BALANCED_PAIRS[k], left = ref[0], rite = ref[1];
+ EXPRESSION_START.push(INVERSES[rite] = left);
+ EXPRESSION_END.push(INVERSES[left] = rite);
+ }
+
+ EXPRESSION_CLOSE = ['CATCH', 'THEN', 'ELSE', 'FINALLY'].concat(EXPRESSION_END);
+
+ IMPLICIT_FUNC = ['IDENTIFIER', 'PROPERTY', 'SUPER', ')', 'CALL_END', ']', 'INDEX_END', '@', 'THIS'];
+
+ IMPLICIT_CALL = ['IDENTIFIER', 'PROPERTY', 'NUMBER', 'INFINITY', 'NAN', 'STRING', 'STRING_START', 'REGEX', 'REGEX_START', 'JS', 'NEW', 'PARAM_START', 'CLASS', 'IF', 'TRY', 'SWITCH', 'THIS', 'UNDEFINED', 'NULL', 'BOOL', 'UNARY', 'YIELD', 'UNARY_MATH', 'SUPER', 'THROW', '@', '->', '=>', '[', '(', '{', '--', '++'];
+
+ IMPLICIT_UNSPACED_CALL = ['+', '-'];
+
+ IMPLICIT_END = ['POST_IF', 'FOR', 'WHILE', 'UNTIL', 'WHEN', 'BY', 'LOOP', 'TERMINATOR'];
+
+ SINGLE_LINERS = ['ELSE', '->', '=>', 'TRY', 'FINALLY', 'THEN'];
+
+ SINGLE_CLOSERS = ['TERMINATOR', 'CATCH', 'FINALLY', 'ELSE', 'OUTDENT', 'LEADING_WHEN'];
+
+ LINEBREAKS = ['TERMINATOR', 'INDENT', 'OUTDENT'];
+
+ CALL_CLOSERS = ['.', '?.', '::', '?::'];
+
+}).call(this);
diff --git a/modeshape-sample/node_modules/coffee-script/lib/coffee-script/scope.js b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/scope.js
new file mode 100644
index 0000000..cd24739
--- /dev/null
+++ b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/scope.js
@@ -0,0 +1,165 @@
+// Generated by CoffeeScript 1.12.7
+(function() {
+ var Scope,
+ indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
+
+ exports.Scope = Scope = (function() {
+ function Scope(parent, expressions, method, referencedVars) {
+ var ref, ref1;
+ this.parent = parent;
+ this.expressions = expressions;
+ this.method = method;
+ this.referencedVars = referencedVars;
+ this.variables = [
+ {
+ name: 'arguments',
+ type: 'arguments'
+ }
+ ];
+ this.positions = {};
+ if (!this.parent) {
+ this.utilities = {};
+ }
+ this.root = (ref = (ref1 = this.parent) != null ? ref1.root : void 0) != null ? ref : this;
+ }
+
+ Scope.prototype.add = function(name, type, immediate) {
+ if (this.shared && !immediate) {
+ return this.parent.add(name, type, immediate);
+ }
+ if (Object.prototype.hasOwnProperty.call(this.positions, name)) {
+ return this.variables[this.positions[name]].type = type;
+ } else {
+ return this.positions[name] = this.variables.push({
+ name: name,
+ type: type
+ }) - 1;
+ }
+ };
+
+ Scope.prototype.namedMethod = function() {
+ var ref;
+ if (((ref = this.method) != null ? ref.name : void 0) || !this.parent) {
+ return this.method;
+ }
+ return this.parent.namedMethod();
+ };
+
+ Scope.prototype.find = function(name, type) {
+ if (type == null) {
+ type = 'var';
+ }
+ if (this.check(name)) {
+ return true;
+ }
+ this.add(name, type);
+ return false;
+ };
+
+ Scope.prototype.parameter = function(name) {
+ if (this.shared && this.parent.check(name, true)) {
+ return;
+ }
+ return this.add(name, 'param');
+ };
+
+ Scope.prototype.check = function(name) {
+ var ref;
+ return !!(this.type(name) || ((ref = this.parent) != null ? ref.check(name) : void 0));
+ };
+
+ Scope.prototype.temporary = function(name, index, single) {
+ var diff, endCode, letter, newCode, num, startCode;
+ if (single == null) {
+ single = false;
+ }
+ if (single) {
+ startCode = name.charCodeAt(0);
+ endCode = 'z'.charCodeAt(0);
+ diff = endCode - startCode;
+ newCode = startCode + index % (diff + 1);
+ letter = String.fromCharCode(newCode);
+ num = Math.floor(index / (diff + 1));
+ return "" + letter + (num || '');
+ } else {
+ return "" + name + (index || '');
+ }
+ };
+
+ Scope.prototype.type = function(name) {
+ var i, len, ref, v;
+ ref = this.variables;
+ for (i = 0, len = ref.length; i < len; i++) {
+ v = ref[i];
+ if (v.name === name) {
+ return v.type;
+ }
+ }
+ return null;
+ };
+
+ Scope.prototype.freeVariable = function(name, options) {
+ var index, ref, temp;
+ if (options == null) {
+ options = {};
+ }
+ index = 0;
+ while (true) {
+ temp = this.temporary(name, index, options.single);
+ if (!(this.check(temp) || indexOf.call(this.root.referencedVars, temp) >= 0)) {
+ break;
+ }
+ index++;
+ }
+ if ((ref = options.reserve) != null ? ref : true) {
+ this.add(temp, 'var', true);
+ }
+ return temp;
+ };
+
+ Scope.prototype.assign = function(name, value) {
+ this.add(name, {
+ value: value,
+ assigned: true
+ }, true);
+ return this.hasAssignments = true;
+ };
+
+ Scope.prototype.hasDeclarations = function() {
+ return !!this.declaredVariables().length;
+ };
+
+ Scope.prototype.declaredVariables = function() {
+ var v;
+ return ((function() {
+ var i, len, ref, results;
+ ref = this.variables;
+ results = [];
+ for (i = 0, len = ref.length; i < len; i++) {
+ v = ref[i];
+ if (v.type === 'var') {
+ results.push(v.name);
+ }
+ }
+ return results;
+ }).call(this)).sort();
+ };
+
+ Scope.prototype.assignedVariables = function() {
+ var i, len, ref, results, v;
+ ref = this.variables;
+ results = [];
+ for (i = 0, len = ref.length; i < len; i++) {
+ v = ref[i];
+ if (v.type.assigned) {
+ results.push(v.name + " = " + v.type.value);
+ }
+ }
+ return results;
+ };
+
+ return Scope;
+
+ })();
+
+}).call(this);
diff --git a/modeshape-sample/node_modules/coffee-script/lib/coffee-script/sourcemap.js b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/sourcemap.js
new file mode 100644
index 0000000..56b86a8
--- /dev/null
+++ b/modeshape-sample/node_modules/coffee-script/lib/coffee-script/sourcemap.js
@@ -0,0 +1,161 @@
+// Generated by CoffeeScript 1.12.7
+(function() {
+ var LineMap, SourceMap;
+
+ LineMap = (function() {
+ function LineMap(line1) {
+ this.line = line1;
+ this.columns = [];
+ }
+
+ LineMap.prototype.add = function(column, arg, options) {
+ var sourceColumn, sourceLine;
+ sourceLine = arg[0], sourceColumn = arg[1];
+ if (options == null) {
+ options = {};
+ }
+ if (this.columns[column] && options.noReplace) {
+ return;
+ }
+ return this.columns[column] = {
+ line: this.line,
+ column: column,
+ sourceLine: sourceLine,
+ sourceColumn: sourceColumn
+ };
+ };
+
+ LineMap.prototype.sourceLocation = function(column) {
+ var mapping;
+ while (!((mapping = this.columns[column]) || (column <= 0))) {
+ column--;
+ }
+ return mapping && [mapping.sourceLine, mapping.sourceColumn];
+ };
+
+ return LineMap;
+
+ })();
+
+ SourceMap = (function() {
+ var BASE64_CHARS, VLQ_CONTINUATION_BIT, VLQ_SHIFT, VLQ_VALUE_MASK;
+
+ function SourceMap() {
+ this.lines = [];
+ }
+
+ SourceMap.prototype.add = function(sourceLocation, generatedLocation, options) {
+ var base, column, line, lineMap;
+ if (options == null) {
+ options = {};
+ }
+ line = generatedLocation[0], column = generatedLocation[1];
+ lineMap = ((base = this.lines)[line] || (base[line] = new LineMap(line)));
+ return lineMap.add(column, sourceLocation, options);
+ };
+
+ SourceMap.prototype.sourceLocation = function(arg) {
+ var column, line, lineMap;
+ line = arg[0], column = arg[1];
+ while (!((lineMap = this.lines[line]) || (line <= 0))) {
+ line--;
+ }
+ return lineMap && lineMap.sourceLocation(column);
+ };
+
+ SourceMap.prototype.generate = function(options, code) {
+ var buffer, i, j, lastColumn, lastSourceColumn, lastSourceLine, len, len1, lineMap, lineNumber, mapping, needComma, ref, ref1, v3, writingline;
+ if (options == null) {
+ options = {};
+ }
+ if (code == null) {
+ code = null;
+ }
+ writingline = 0;
+ lastColumn = 0;
+ lastSourceLine = 0;
+ lastSourceColumn = 0;
+ needComma = false;
+ buffer = "";
+ ref = this.lines;
+ for (lineNumber = i = 0, len = ref.length; i < len; lineNumber = ++i) {
+ lineMap = ref[lineNumber];
+ if (lineMap) {
+ ref1 = lineMap.columns;
+ for (j = 0, len1 = ref1.length; j < len1; j++) {
+ mapping = ref1[j];
+ if (!(mapping)) {
+ continue;
+ }
+ while (writingline < mapping.line) {
+ lastColumn = 0;
+ needComma = false;
+ buffer += ";";
+ writingline++;
+ }
+ if (needComma) {
+ buffer += ",";
+ needComma = false;
+ }
+ buffer += this.encodeVlq(mapping.column - lastColumn);
+ lastColumn = mapping.column;
+ buffer += this.encodeVlq(0);
+ buffer += this.encodeVlq(mapping.sourceLine - lastSourceLine);
+ lastSourceLine = mapping.sourceLine;
+ buffer += this.encodeVlq(mapping.sourceColumn - lastSourceColumn);
+ lastSourceColumn = mapping.sourceColumn;
+ needComma = true;
+ }
+ }
+ }
+ v3 = {
+ version: 3,
+ file: options.generatedFile || '',
+ sourceRoot: options.sourceRoot || '',
+ sources: options.sourceFiles || [''],
+ names: [],
+ mappings: buffer
+ };
+ if (options.inlineMap) {
+ v3.sourcesContent = [code];
+ }
+ return v3;
+ };
+
+ VLQ_SHIFT = 5;
+
+ VLQ_CONTINUATION_BIT = 1 << VLQ_SHIFT;
+
+ VLQ_VALUE_MASK = VLQ_CONTINUATION_BIT - 1;
+
+ SourceMap.prototype.encodeVlq = function(value) {
+ var answer, nextChunk, signBit, valueToEncode;
+ answer = '';
+ signBit = value < 0 ? 1 : 0;
+ valueToEncode = (Math.abs(value) << 1) + signBit;
+ while (valueToEncode || !answer) {
+ nextChunk = valueToEncode & VLQ_VALUE_MASK;
+ valueToEncode = valueToEncode >> VLQ_SHIFT;
+ if (valueToEncode) {
+ nextChunk |= VLQ_CONTINUATION_BIT;
+ }
+ answer += this.encodeBase64(nextChunk);
+ }
+ return answer;
+ };
+
+ BASE64_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+ SourceMap.prototype.encodeBase64 = function(value) {
+ return BASE64_CHARS[value] || (function() {
+ throw new Error("Cannot Base64 encode value: " + value);
+ })();
+ };
+
+ return SourceMap;
+
+ })();
+
+ module.exports = SourceMap;
+
+}).call(this);
diff --git a/modeshape-sample/node_modules/coffee-script/package.json b/modeshape-sample/node_modules/coffee-script/package.json
new file mode 100644
index 0000000..3cb160b
--- /dev/null
+++ b/modeshape-sample/node_modules/coffee-script/package.json
@@ -0,0 +1,48 @@
+{
+ "name": "coffee-script",
+ "description": "Unfancy JavaScript",
+ "keywords": [
+ "javascript",
+ "language",
+ "coffeescript",
+ "compiler"
+ ],
+ "author": "Jeremy Ashkenas",
+ "version": "1.12.7",
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.8.0"
+ },
+ "directories": {
+ "lib": "./lib/coffee-script"
+ },
+ "main": "./lib/coffee-script/coffee-script",
+ "bin": {
+ "coffee": "./bin/coffee",
+ "cake": "./bin/cake"
+ },
+ "files": [
+ "bin",
+ "lib",
+ "register.js",
+ "repl.js"
+ ],
+ "scripts": {
+ "test": "node ./bin/cake test",
+ "test-harmony": "node --harmony ./bin/cake test"
+ },
+ "homepage": "http://coffeescript.org",
+ "bugs": "https://github.com/jashkenas/coffeescript/issues",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/jashkenas/coffeescript.git"
+ },
+ "devDependencies": {
+ "docco": "~0.7.0",
+ "google-closure-compiler-js": "^20170626.0.0",
+ "highlight.js": "~9.12.0",
+ "jison": ">=0.4.17",
+ "markdown-it": "^8.3.1",
+ "underscore": "~1.8.3"
+ }
+}
diff --git a/modeshape-sample/node_modules/coffee-script/register.js b/modeshape-sample/node_modules/coffee-script/register.js
new file mode 100644
index 0000000..97b33d7
--- /dev/null
+++ b/modeshape-sample/node_modules/coffee-script/register.js
@@ -0,0 +1 @@
+require('./lib/coffee-script/register');
diff --git a/modeshape-sample/node_modules/coffee-script/repl.js b/modeshape-sample/node_modules/coffee-script/repl.js
new file mode 100644
index 0000000..d2706a7
--- /dev/null
+++ b/modeshape-sample/node_modules/coffee-script/repl.js
@@ -0,0 +1 @@
+module.exports = require('./lib/coffee-script/repl');
diff --git a/modeshape-sample/package-lock.json b/modeshape-sample/package-lock.json
new file mode 100644
index 0000000..404eca5
--- /dev/null
+++ b/modeshape-sample/package-lock.json
@@ -0,0 +1,32 @@
+{
+ "name": "modeshape-sample",
+ "lockfileVersion": 2,
+ "requires": true,
+ "packages": {
+ "": {
+ "dependencies": {
+ "coffee-script": "^1.12.7"
+ }
+ },
+ "node_modules/coffee-script": {
+ "version": "1.12.7",
+ "resolved": "https://registry.npmjs.org/coffee-script/-/coffee-script-1.12.7.tgz",
+ "integrity": "sha512-fLeEhqwymYat/MpTPUjSKHVYYl0ec2mOyALEMLmzr5i1isuG+6jfI2j2d5oBO3VIzgUXgBVIcOT9uH1TFxBckw==",
+ "deprecated": "CoffeeScript on NPM has moved to \"coffeescript\" (no hyphen)",
+ "bin": {
+ "cake": "bin/cake",
+ "coffee": "bin/coffee"
+ },
+ "engines": {
+ "node": ">=0.8.0"
+ }
+ }
+ },
+ "dependencies": {
+ "coffee-script": {
+ "version": "1.12.7",
+ "resolved": "https://registry.npmjs.org/coffee-script/-/coffee-script-1.12.7.tgz",
+ "integrity": "sha512-fLeEhqwymYat/MpTPUjSKHVYYl0ec2mOyALEMLmzr5i1isuG+6jfI2j2d5oBO3VIzgUXgBVIcOT9uH1TFxBckw=="
+ }
+ }
+}
diff --git a/modeshape-sample/package.json b/modeshape-sample/package.json
new file mode 100644
index 0000000..538ad86
--- /dev/null
+++ b/modeshape-sample/package.json
@@ -0,0 +1,5 @@
+{
+ "dependencies": {
+ "coffee-script": "^1.12.7"
+ }
+}
diff --git a/modeshape-sample/pom.xml b/modeshape-sample/pom.xml
index d3c3184..53c0c74 100644
--- a/modeshape-sample/pom.xml
+++ b/modeshape-sample/pom.xml
@@ -7,12 +7,12 @@
org.wisdom-framework.jcr
wisdom-jcr
- 0.5.0-SNAPSHOT
+ 0.5.0
../pom.xml
modeshape-sample
- 0.5.0-SNAPSHOT
+ 0.5.0
wisdom
diff --git a/pom.xml b/pom.xml
index effc7b1..f25296d 100644
--- a/pom.xml
+++ b/pom.xml
@@ -12,7 +12,7 @@
org.wisdom-framework.jcr
wisdom-jcr
- 0.5.0-SNAPSHOT
+ 0.5.0
pom
diff --git a/wisdom-jcr-core/pom.xml b/wisdom-jcr-core/pom.xml
index 2ca6065..2d2a0cb 100644
--- a/wisdom-jcr-core/pom.xml
+++ b/wisdom-jcr-core/pom.xml
@@ -5,7 +5,7 @@
org.wisdom-framework.jcr
wisdom-jcr
- 0.5.0-SNAPSHOT
+ 0.5.0
4.0.0
diff --git a/wisdom-jcr-providers/pom.xml b/wisdom-jcr-providers/pom.xml
index eb48042..5b3a34e 100644
--- a/wisdom-jcr-providers/pom.xml
+++ b/wisdom-jcr-providers/pom.xml
@@ -5,7 +5,7 @@
wisdom-jcr
org.wisdom-framework.jcr
- 0.5.0-SNAPSHOT
+ 0.5.0
4.0.0
diff --git a/wisdom-jcr-query/pom.xml b/wisdom-jcr-query/pom.xml
index f5a62c7..d21b8cd 100644
--- a/wisdom-jcr-query/pom.xml
+++ b/wisdom-jcr-query/pom.xml
@@ -5,7 +5,7 @@
wisdom-jcr
org.wisdom-framework.jcr
- 0.5.0-SNAPSHOT
+ 0.5.0
4.0.0
diff --git a/wisdom-jcr-script/pom.xml b/wisdom-jcr-script/pom.xml
index 92b13cf..2692333 100644
--- a/wisdom-jcr-script/pom.xml
+++ b/wisdom-jcr-script/pom.xml
@@ -5,7 +5,7 @@
wisdom-jcr
org.wisdom-framework.jcr
- 0.5.0-SNAPSHOT
+ 0.5.0
4.0.0
diff --git a/wisdom-jcr-web-explorer/pom.xml b/wisdom-jcr-web-explorer/pom.xml
index 9c83d0f..b5781ba 100644
--- a/wisdom-jcr-web-explorer/pom.xml
+++ b/wisdom-jcr-web-explorer/pom.xml
@@ -5,7 +5,7 @@
wisdom-jcr
org.wisdom-framework.jcr
- 0.5.0-SNAPSHOT
+ 0.5.0
4.0.0
diff --git a/wisdom-modeshape-backup/pom.xml b/wisdom-modeshape-backup/pom.xml
index 2f741bb..5a5fc70 100644
--- a/wisdom-modeshape-backup/pom.xml
+++ b/wisdom-modeshape-backup/pom.xml
@@ -5,7 +5,7 @@
wisdom-jcr
org.wisdom-framework.jcr
- 0.5.0-SNAPSHOT
+ 0.5.0
4.0.0
diff --git a/wisdom-modeshape-index/pom.xml b/wisdom-modeshape-index/pom.xml
index 156e947..d77c01c 100644
--- a/wisdom-modeshape-index/pom.xml
+++ b/wisdom-modeshape-index/pom.xml
@@ -5,7 +5,7 @@
wisdom-jcr
org.wisdom-framework.jcr
- 0.5.0-SNAPSHOT
+ 0.5.0
4.0.0
diff --git a/wisdom-modeshape-monitoring/pom.xml b/wisdom-modeshape-monitoring/pom.xml
index 3ebc8c2..575e681 100644
--- a/wisdom-modeshape-monitoring/pom.xml
+++ b/wisdom-modeshape-monitoring/pom.xml
@@ -5,7 +5,7 @@
wisdom-jcr
org.wisdom-framework.jcr
- 0.5.0-SNAPSHOT
+ 0.5.0
4.0.0
diff --git a/wisdom-modeshape-web-jcr-rest/pom.xml b/wisdom-modeshape-web-jcr-rest/pom.xml
index f1ef8bd..93fb041 100644
--- a/wisdom-modeshape-web-jcr-rest/pom.xml
+++ b/wisdom-modeshape-web-jcr-rest/pom.xml
@@ -5,7 +5,7 @@
wisdom-jcr
org.wisdom-framework.jcr
- 0.5.0-SNAPSHOT
+ 0.5.0
4.0.0
@@ -20,7 +20,7 @@
org.wisdom-framework.jcr
wisdom-modeshape
- 0.5.0-SNAPSHOT
+ 0.5.0
org.apache.felix
diff --git a/wisdom-modeshape/pom.xml b/wisdom-modeshape/pom.xml
index 542e794..604eb77 100644
--- a/wisdom-modeshape/pom.xml
+++ b/wisdom-modeshape/pom.xml
@@ -5,7 +5,7 @@
org.wisdom-framework.jcr
wisdom-jcr
- 0.5.0-SNAPSHOT
+ 0.5.0
4.0.0