From 1b2c10f2b2f284778999e8b539e6ce830c6c41a8 Mon Sep 17 00:00:00 2001 From: Firebase Operations Date: Thu, 4 Aug 2016 21:35:44 +0000 Subject: [PATCH] [firebase-release] Updated Bolt Language Compiler to 0.8.1 --- dist/bolt.js | 8676 ++++++++++++++++++++++++++++++++++++++++++++++++++ package.json | 2 +- 2 files changed, 8677 insertions(+), 1 deletion(-) create mode 100644 dist/bolt.js diff --git a/dist/bolt.js b/dist/bolt.js new file mode 100644 index 0000000..c5c29ef --- /dev/null +++ b/dist/bolt.js @@ -0,0 +1,8676 @@ +(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o this.parts.length || i < -this.parts.length) { + var l = this.parts.length; + throw new Error("Path reference out of bounds: " + i + + " [" + -l + " .. " + l + "]"); + } + if (i < 0) { + return this.parts[this.parts.length + i]; + } + return this.parts[i]; + }; + return PathTemplate; +}()); +exports.PathTemplate = PathTemplate; +; +var Schema = (function () { + function Schema() { + } + Schema.isGeneric = function (schema) { + return schema.params !== undefined && schema.params.length > 0; + }; + return Schema; +}()); +exports.Schema = Schema; +; +exports.string = valueGen('String'); +exports.boolean = valueGen('Boolean'); +exports.number = valueGen('Number'); +exports.array = valueGen('Array'); +exports.neg = opGen('neg', 1); +exports.not = opGen('!', 1); +exports.mult = opGen('*'); +exports.div = opGen('/'); +exports.mod = opGen('%'); +exports.add = opGen('+'); +exports.sub = opGen('-'); +exports.eq = opGen('=='); +exports.lt = opGen('<'); +exports.lte = opGen('<='); +exports.gt = opGen('>'); +exports.gte = opGen('>='); +exports.ne = opGen('!='); +exports.and = opGen('&&'); +exports.or = opGen('||'); +exports.ternary = opGen('?:', 3); +exports.value = opGen('value', 1); +function variable(name) { + return { type: 'var', valueType: 'Any', name: name }; +} +exports.variable = variable; +function literal(name) { + return { type: 'literal', valueType: 'Any', name: name }; +} +exports.literal = literal; +function nullType() { + return { type: 'Null', valueType: 'Null' }; +} +exports.nullType = nullType; +function reference(base, prop) { + return { + type: 'ref', + valueType: 'Any', + base: base, + accessor: prop + }; +} +exports.reference = reference; +var reIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_]*$/; +function isIdentifierStringExp(exp) { + return exp.type === 'String' && reIdentifier.test(exp.value); +} +exports.isIdentifierStringExp = isIdentifierStringExp; +// Shallow copy of an expression (so it can be modified and preserve +// immutability of the original expression). +function copyExp(exp) { + exp = util.extend({}, exp); + switch (exp.type) { + case 'op': + case 'call': + var opExp = exp; + opExp.args = util.copyArray(opExp.args); + return opExp; + case 'union': + var unionExp = exp; + unionExp.types = util.copyArray(unionExp.types); + return unionExp; + case 'generic': + var genericExp = exp; + genericExp.params = util.copyArray(genericExp.params); + return genericExp; + default: + return exp; + } +} +exports.copyExp = copyExp; +// Make a (shallow) copy of the base expression, setting (or removing) it's +// valueType. +// +// valueType is a string indicating the type of evaluating an expression (e.g. +// 'Snapshot') - used to know when type coercion is needed in the context +// of parent expressions. +function cast(base, valueType) { + var result = copyExp(base); + result.valueType = valueType; + return result; +} +exports.cast = cast; +function call(ref, args) { + if (args === void 0) { args = []; } + return { type: 'call', valueType: 'Any', ref: ref, args: args }; +} +exports.call = call; +// Return empty string if not a function. +function getFunctionName(exp) { + if (exp.ref.type === 'ref') { + return ''; + } + return exp.ref.name; +} +exports.getFunctionName = getFunctionName; +// Return empty string if not a (simple) method call -- ref.fn() +function getMethodName(exp) { + if (exp.ref.type === 'var') { + return exp.ref.name; + } + if (exp.ref.type !== 'ref') { + return ''; + } + return getPropName(exp.ref); +} +exports.getMethodName = getMethodName; +function getPropName(ref) { + if (ref.accessor.type !== 'String') { + return ''; + } + return ref.accessor.value; +} +exports.getPropName = getPropName; +// TODO: Type of function signature does not fail this declaration? +function builtin(fn) { + return { type: 'builtin', valueType: 'Any', fn: fn }; +} +exports.builtin = builtin; +function snapshotVariable(name) { + return cast(variable(name), 'Snapshot'); +} +exports.snapshotVariable = snapshotVariable; +function snapshotParent(base) { + if (base.valueType !== 'Snapshot') { + throw new Error(errors.typeMismatch + "expected Snapshot"); + } + return cast(call(reference(cast(base, 'Any'), exports.string('parent'))), 'Snapshot'); +} +exports.snapshotParent = snapshotParent; +function ensureValue(exp) { + if (exp.valueType === 'Snapshot') { + return snapshotValue(exp); + } + return exp; +} +exports.ensureValue = ensureValue; +// ref.val() +function snapshotValue(exp) { + return call(reference(cast(exp, 'Any'), exports.string('val'))); +} +exports.snapshotValue = snapshotValue; +// Ensure expression is a boolean (when used in a boolean context). +function ensureBoolean(exp) { + exp = ensureValue(exp); + if (isCall(exp, 'val')) { + exp = exports.eq(exp, exports.boolean(true)); + } + return exp; +} +exports.ensureBoolean = ensureBoolean; +function isCall(exp, methodName) { + return exp.type === 'call' && exp.ref.type === 'ref' && + exp.ref.accessor.type === 'String' && + exp.ref.accessor.value === methodName; +} +exports.isCall = isCall; +// Return value generating function for a given Type. +function valueGen(typeName) { + return function (val) { + return { + type: typeName, + valueType: typeName, + value: val // The (constant) value itself. + }; + }; +} +function regexp(pattern, modifiers) { + if (modifiers === void 0) { modifiers = ""; } + switch (modifiers) { + case "": + case "i": + break; + default: + throw new Error("Unsupported RegExp modifier: " + modifiers); + } + return { + type: 'RegExp', + valueType: 'RegExp', + value: pattern, + modifiers: modifiers + }; +} +exports.regexp = regexp; +function cmpValues(v1, v2) { + if (v1.type !== v2.type) { + return false; + } + return v1.value === v2.value; +} +function isOp(opType, exp) { + return exp.type === 'op' && exp.op === opType; +} +// Return a generating function to make an operator exp node. +function opGen(opType, arity) { + if (arity === void 0) { arity = 2; } + return function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i - 0] = arguments[_i]; + } + if (args.length !== arity) { + throw new Error("Operator has " + args.length + + " arguments (expecting " + arity + ")."); + } + return op(opType, args); + }; +} +exports.andArray = leftAssociateGen('&&', exports.boolean(true), exports.boolean(false)); +exports.orArray = leftAssociateGen('||', exports.boolean(false), exports.boolean(true)); +// Create an expression builder function which operates on arrays of values. +// Returns new expression like v1 op v2 op v3 ... +// +// - Any identityValue's in array input are ignored. +// - If zeroValue is found - just return zeroValue. +// +// Our function re-orders top-level op in array elements to the resulting +// expression is left-associating. E.g.: +// +// [a && b, c && d] => (((a && b) && c) && d) +// (NOT (a && b) && (c && d)) +function leftAssociateGen(opType, identityValue, zeroValue) { + return function (a) { + var i; + function reducer(result, current) { + if (result === undefined) { + return current; + } + return op(opType, [result, current]); + } + // First flatten all top-level op values to one flat array. + var flat = []; + for (i = 0; i < a.length; i++) { + flatten(opType, a[i], flat); + } + var result = []; + for (i = 0; i < flat.length; i++) { + // Remove identifyValues from array. + if (cmpValues(flat[i], identityValue)) { + continue; + } + // Just return zeroValue if found + if (cmpValues(flat[i], zeroValue)) { + return zeroValue; + } + result.push(flat[i]); + } + if (result.length === 0) { + return identityValue; + } + // Return left-associative expression of opType. + return result.reduce(reducer); + }; +} +// Flatten the top level tree of op into a single flat array of expressions. +function flatten(opType, exp, flat) { + var i; + if (flat === undefined) { + flat = []; + } + if (!isOp(opType, exp)) { + flat.push(exp); + return flat; + } + for (i = 0; i < exp.args.length; i++) { + flatten(opType, exp.args[i], flat); + } + return flat; +} +exports.flatten = flatten; +function op(opType, args) { + return { + type: 'op', + valueType: 'Any', + op: opType, + args: args // Arguments to the operator Array + }; +} +exports.op = op; +// Warning: NOT an expression type! +function method(params, body) { + return { + params: params, + body: body + }; +} +exports.method = method; +function typeType(typeName) { + return { type: "type", valueType: "type", name: typeName }; +} +exports.typeType = typeType; +function unionType(types) { + return { type: "union", valueType: "type", types: types }; +} +exports.unionType = unionType; +function genericType(typeName, params) { + return { type: "generic", valueType: "type", name: typeName, params: params }; +} +exports.genericType = genericType; +var Symbols = (function () { + function Symbols() { + this.functions = {}; + this.paths = []; + this.schema = {}; + } + Symbols.prototype.register = function (map, typeName, name, object) { + if (map[name]) { + logger.error("Duplicated " + typeName + " definition: " + name + "."); + } + else { + map[name] = object; + } + return map[name]; + }; + Symbols.prototype.registerFunction = function (name, params, body) { + return this.register(this.functions, 'functions', name, method(params, body)); + }; + Symbols.prototype.registerPath = function (template, isType, methods) { + if (methods === void 0) { methods = {}; } + isType = isType || typeType('Any'); + var p = { + template: template.copy(), + isType: isType, + methods: methods + }; + this.paths.push(p); + return p; + }; + Symbols.prototype.registerSchema = function (name, derivedFrom, properties, methods, params) { + if (properties === void 0) { properties = {}; } + if (methods === void 0) { methods = {}; } + if (params === void 0) { params = []; } + derivedFrom = derivedFrom || typeType(Object.keys(properties).length > 0 ? 'Object' : 'Any'); + var s = { + derivedFrom: derivedFrom, + properties: properties, + methods: methods, + params: params + }; + return this.register(this.schema, 'schema', name, s); + }; + Symbols.prototype.isDerivedFrom = function (type, ancestor) { + var _this = this; + if (ancestor === 'Any') { + return true; + } + switch (type.type) { + case 'type': + case 'generic': + var simpleType = type; + if (simpleType.name === ancestor) { + return true; + } + if (simpleType.name === 'Any') { + return false; + } + var schema = this.schema[simpleType.name]; + if (!schema) { + return false; + } + return this.isDerivedFrom(schema.derivedFrom, ancestor); + case 'union': + return type.types + .map(function (subType) { return _this.isDerivedFrom(subType, ancestor); }) + .reduce(util.or); + default: + throw new Error("Unknown type: " + type.type); + } + }; + return Symbols; +}()); +exports.Symbols = Symbols; +var JS_OPS = { + 'value': { rep: "", p: 18 }, + 'neg': { rep: "-", p: 15 }, + '!': { p: 15 }, + '*': { p: 14 }, + '/': { p: 14 }, + '%': { p: 14 }, + '+': { p: 13 }, + '-': { p: 13 }, + '<': { p: 11 }, + '<=': { p: 11 }, + '>': { p: 11 }, + '>=': { p: 11 }, + 'in': { p: 11 }, + '==': { p: 10 }, + "!=": { p: 10 }, + '&&': { p: 6 }, + '||': { p: 5 }, + '?:': { p: 4 }, + ',': { p: 0 } +}; +// From an AST, decode as an expression (string). +function decodeExpression(exp, outerPrecedence) { + if (outerPrecedence === undefined) { + outerPrecedence = 0; + } + var innerPrecedence = precedenceOf(exp); + var result = ''; + switch (exp.type) { + case 'Boolean': + case 'Number': + result = JSON.stringify(exp.value); + break; + case 'String': + result = util.quoteString(exp.value); + break; + // RegExp assumed to be in pre-quoted format. + case 'RegExp': + var regexp_1 = exp; + result = '/' + regexp_1.value + '/'; + if (regexp_1.modifiers !== '') { + result += regexp_1.modifiers; + } + break; + case 'Array': + result = '[' + decodeArray(exp.value) + ']'; + break; + case 'Null': + result = 'null'; + break; + case 'var': + case 'literal': + result = exp.name; + break; + case 'ref': + var expRef = exp; + if (isIdentifierStringExp(expRef.accessor)) { + result = decodeExpression(expRef.base, innerPrecedence) + '.' + expRef.accessor.value; + } + else { + result = decodeExpression(expRef.base, innerPrecedence) + + '[' + decodeExpression(expRef.accessor) + ']'; + } + break; + case 'call': + var expCall = exp; + result = decodeExpression(expCall.ref) + '(' + decodeArray(expCall.args) + ')'; + break; + case 'builtin': + result = decodeExpression(exp); + break; + case 'op': + var expOp = exp; + var rep = JS_OPS[expOp.op].rep === undefined ? expOp.op : JS_OPS[expOp.op].rep; + if (expOp.args.length === 1) { + result = rep + decodeExpression(expOp.args[0], innerPrecedence); + } + else if (expOp.args.length === 2) { + result = + decodeExpression(expOp.args[0], innerPrecedence) + + ' ' + rep + ' ' + + // All ops are left associative - so nudge the innerPrecendence + // down on the right hand side to force () for right-associating + // operations. + decodeExpression(expOp.args[1], innerPrecedence + 1); + } + else if (expOp.args.length === 3) { + result = + decodeExpression(expOp.args[0], innerPrecedence) + ' ? ' + + decodeExpression(expOp.args[1], innerPrecedence) + ' : ' + + decodeExpression(expOp.args[2], innerPrecedence); + } + break; + case 'type': + result = exp.name; + break; + case 'union': + result = exp.types.map(decodeExpression).join(' | '); + break; + case 'generic': + var genericType_1 = exp; + return genericType_1.name + '<' + decodeArray(genericType_1.params) + '>'; + default: + result = "***UNKNOWN TYPE*** (" + exp.type + ")"; + break; + } + if (innerPrecedence < outerPrecedence) { + result = '(' + result + ')'; + } + return result; +} +exports.decodeExpression = decodeExpression; +function decodeArray(args) { + return args.map(decodeExpression).join(', '); +} +function precedenceOf(exp) { + var result; + switch (exp.type) { + case 'op': + result = JS_OPS[exp.op].p; + break; + // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence + // lists call as 17 and ref as 18 - but how could they be anything other than left to right? + // http://www.scriptingmaster.com/javascript/operator-precedence.asp - agrees. + case 'call': + result = 18; + break; + case 'ref': + result = 18; + break; + default: + result = 19; + break; + } + return result; +} + + +},{"./logger":3,"./util":7}],2:[function(require,module,exports){ +/* + * Copyright 2015 Google Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +"use strict"; +// TODO(koss): After node 0.10 leaves LTS - remove polyfilled Promise library. +if (typeof Promise === 'undefined') { + require('es6-promise').polyfill(); +} +var parser = require('./rules-parser'); +var generator = require('./rules-generator'); +var astImport = require('./ast'); +exports.FILE_EXTENSION = 'bolt'; +exports.ast = astImport; +exports.parse = parser.parse; +exports.Generator = generator.Generator; +exports.decodeExpression = exports.ast.decodeExpression; +exports.generate = generator.generate; + + +},{"./ast":1,"./rules-generator":5,"./rules-parser":6,"es6-promise":9}],3:[function(require,module,exports){ +"use strict"; +/* + * Copyright 2015 Google Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +var lastError; +var lastMessage; +var errorCount; +var silenceOutput; +var getContext = function () { return ({}); }; +reset(); +function reset() { + lastError = undefined; + lastMessage = undefined; + errorCount = 0; + silenceOutput = false; +} +exports.reset = reset; +function silent(f) { + if (f === void 0) { f = true; } + silenceOutput = f; +} +exports.silent = silent; +function setContext(fn) { + getContext = fn; +} +exports.setContext = setContext; +function error(s) { + var err = errorString(s); + // De-dup identical messages + if (err === lastMessage) { + return; + } + lastMessage = err; + lastError = lastMessage; + if (!silenceOutput) { + console.error(lastError); + } + errorCount += 1; +} +exports.error = error; +function warn(s) { + var err = errorString(s); + // De-dup identical messages + if (err === lastMessage) { + return; + } + lastMessage = err; + if (!silenceOutput) { + console.warn(lastMessage); + } +} +exports.warn = warn; +function getLastMessage() { + return lastMessage; +} +exports.getLastMessage = getLastMessage; +function errorString(s) { + var ctx = getContext(); + if (ctx.line !== undefined && ctx.column !== undefined) { + return 'bolt:' + ctx.line + ':' + ctx.column + ': ' + s; + } + else { + return 'bolt: ' + s; + } +} +function hasErrors() { + return errorCount > 0; +} +exports.hasErrors = hasErrors; +function errorSummary() { + if (errorCount === 1) { + return lastError; + } + if (errorCount !== 0) { + return "Fatal errors: " + errorCount; + } + return ""; +} +exports.errorSummary = errorSummary; + + +},{}],4:[function(require,module,exports){ +"use strict"; +/* + * Copyright 2015 Google Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +var parser = require('./rules-parser'); +function parseExpression(expression) { + var result = parser.parse('function f() {return ' + expression + ';}'); + return result.functions.f.body; +} +exports.parseExpression = parseExpression; + + +},{"./rules-parser":6}],5:[function(require,module,exports){ +"use strict"; +/* + * Copyright 2015 Google Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +var util = require('./util'); +var ast = require('./ast'); +var logger_1 = require('./logger'); +var parser = require('./rules-parser'); +var parse_util_1 = require('./parse-util'); +var errors = { + badIndex: "The index function must return a String or an array of Strings.", + noPaths: "Must have at least one path expression.", + nonObject: "Type contains properties and must extend 'Object'.", + missingSchema: "Missing definition for type.", + recursive: "Recursive function call.", + mismatchParams: "Incorrect number of function arguments.", + generateFailed: "Could not generate JSON: ", + noSuchType: "No type definition for: ", + badSchemaMethod: "Unsupported method name in type statement: ", + badPathMethod: "Unsupported method name in path statement: ", + badWriteAlias: "Cannot have both a write() method and a write-aliasing method: ", + coercion: "Cannot convert value: ", + undefinedFunction: "Undefined function: ", + application: "Bolt application error: ", + invalidGeneric: "Invalid generic schema usage: ", + invalidMapKey: "Map - Key must derive from String type.", + invalidWildChildren: "Types can have at most one $wild property and cannot mix with other properties.", + invalidPropertyName: "Property names cannot contain any of: . $ # [ ] / or control characters: " +}; +var INVALID_KEY_REGEX = /[\[\].#$\/\u0000-\u001F\u007F]/; +; +var builtinSchemaNames = ['Any', 'Null', 'String', 'Number', 'Boolean', 'Object']; +// Method names allowed in Bolt files. +var valueMethods = ['length', 'includes', 'startsWith', 'beginsWith', 'endsWith', + 'replace', 'toLowerCase', 'toUpperCase', 'test', 'contains', + 'matches']; +// TODO: Make sure users don't call internal methods...make private to impl. +var snapshotMethods = ['parent', 'child', 'hasChildren', 'val', 'isString', 'isNumber', + 'isBoolean'].concat(valueMethods); +var writeAliases = { + 'create': parse_util_1.parseExpression('prior(this) == null'), + 'update': parse_util_1.parseExpression('prior(this) != null && this != null'), + 'delete': parse_util_1.parseExpression('prior(this) != null && this == null') +}; +// Usage: +// json = bolt.generate(bolt-text) +function generate(symbols) { + if (typeof symbols === 'string') { + symbols = parser.parse(symbols); + } + var gen = new Generator(symbols); + return gen.generateRules(); +} +exports.generate = generate; +// Symbols contains: +// functions: {} +// schema: {} +// paths: {} +var Generator = (function () { + function Generator(symbols) { + this.symbols = symbols; + this.validators = {}; + this.rules = {}; + this.errorCount = 0; + this.runSilently = false; + this.allowUndefinedFunctions = false; + this.keyIndex = 0; + // TODO: globals should be part of this.symbols (nested scopes) + this.globals = { + "root": ast.call(ast.variable('@root')) + }; + this.registerBuiltinSchema(); + } + // Return Firebase compatible Rules JSON for a the given symbols definitions. + Generator.prototype.generateRules = function () { + var _this = this; + this.errorCount = 0; + var paths = this.symbols.paths; + var schema = this.symbols.schema; + var name; + paths.forEach(function (path) { + _this.validateMethods(errors.badPathMethod, path.methods, ['validate', 'read', 'write', 'index']); + }); + for (name in schema) { + if (!util.arrayIncludes(builtinSchemaNames, name)) { + this.validateMethods(errors.badSchemaMethod, schema[name].methods, ['validate', 'read', 'write']); + } + } + if (paths.length === 0) { + this.fatal(errors.noPaths); + } + paths.forEach(function (path) { return _this.updateRules(path); }); + this.convertExpressions(this.rules); + if (this.errorCount !== 0) { + throw new Error(errors.generateFailed + this.errorCount + " errors."); + } + util.deletePropName(this.rules, '.scope'); + util.pruneEmptyChildren(this.rules); + return { + rules: this.rules + }; + }; + Generator.prototype.validateMethods = function (m, methods, allowed) { + var _this = this; + if (util.arrayIncludes(allowed, 'write')) { + allowed = allowed.concat(Object.keys(writeAliases)); + } + for (var method in methods) { + if (!util.arrayIncludes(allowed, method)) { + logger_1.warn(m + util.quoteString(method) + + " (allowed: " + allowed.map(util.quoteString).join(', ') + ")"); + } + } + if ('write' in methods) { + Object.keys(writeAliases).forEach(function (alias) { + if (alias in methods) { + _this.fatal(errors.badWriteAlias + alias); + } + }); + } + }; + Generator.prototype.registerBuiltinSchema = function () { + var self = this; + var thisVar = ast.variable('this'); + function registerAsCall(name, methodName) { + self.symbols.registerSchema(name, ast.typeType('Any'), undefined, { + validate: ast.method(['this'], ast.call(ast.reference(ast.cast(thisVar, 'Any'), ast.string(methodName)))) + }); + } + this.symbols.registerSchema('Any', ast.typeType('Any'), undefined, { + validate: ast.method(['this'], ast.boolean(true)) + }); + registerAsCall('Object', 'hasChildren'); + // Because of the way firebase treats Null values, there is no way to + // write a validation rule, that will EVER be called with this == null + // (firebase allows values to be deleted no matter their validation rules). + // So, comparing this == null will always return false -> that is what + // we do here, which will be optimized away if ORed with other validations. + this.symbols.registerSchema('Null', ast.typeType('Any'), undefined, { + validate: ast.method(['this'], ast.boolean(false)) + }); + self.symbols.registerSchema('String', ast.typeType('Any'), undefined, { + validate: ast.method(['this'], ast.call(ast.reference(ast.cast(thisVar, 'Any'), ast.string('isString')))), + includes: ast.method(['this', 's'], ast.call(ast.reference(ast.value(thisVar), ast.string('contains')), [ast.value(ast.variable('s'))])), + startsWith: ast.method(['this', 's'], ast.call(ast.reference(ast.value(thisVar), ast.string('beginsWith')), [ast.value(ast.variable('s'))])), + endsWith: ast.method(['this', 's'], ast.call(ast.reference(ast.value(thisVar), ast.string('endsWith')), [ast.value(ast.variable('s'))])), + replace: ast.method(['this', 's', 'r'], ast.call(ast.reference(ast.value(thisVar), ast.string('replace')), [ast.value(ast.variable('s')), ast.value(ast.variable('r'))])), + test: ast.method(['this', 'r'], ast.call(ast.reference(ast.value(thisVar), ast.string('matches')), [ast.call(ast.variable('@RegExp'), [ast.variable('r')])])) + }); + registerAsCall('Number', 'isNumber'); + registerAsCall('Boolean', 'isBoolean'); + this.symbols.registerFunction('@RegExp', ['r'], ast.builtin(this.ensureType.bind(this, 'RegExp'))); + var map = this.symbols.registerSchema('Map', ast.typeType('Any'), undefined, undefined, ['Key', 'Value']); + map.getValidator = this.getMapValidator.bind(this); + }; + // type Map => { + // $key: { + // '.validate': $key instanceof Key and this instanceof Value; + // '.validate': 'newData.hasChildren()' + // } + // Key must derive from String + Generator.prototype.getMapValidator = function (params) { + var keyType = params[0]; + var valueType = params[1]; + if (keyType.type !== 'type' || !this.symbols.isDerivedFrom(keyType, 'String')) { + throw new Error(errors.invalidMapKey + " (" + ast.decodeExpression(keyType) + " does not)"); + } + var validator = {}; + var index = this.uniqueKey(); + validator[index] = {}; + extendValidator(validator, this.ensureValidator(ast.typeType('Object'))); + // First validate the key (omit terminal String type validation). + while (keyType.name !== 'String') { + var schema = this.symbols.schema[keyType.name]; + if (schema.methods['validate']) { + var exp = this.partialEval(schema.methods['validate'].body, { 'this': ast.literal(index) }); + extendValidator(validator[index], { '.validate': [exp] }); + } + keyType = schema.derivedFrom; + } + extendValidator(validator[index], this.ensureValidator(valueType)); + return validator; + }; + Generator.prototype.uniqueKey = function () { + this.keyIndex += 1; + return '$key' + this.keyIndex; + }; + // Collection schema has exactly one $wildchild property + Generator.prototype.isCollectionSchema = function (schema) { + var props = Object.keys(schema.properties); + var result = props.length === 1 && props[0][0] === '$'; + return result; + }; + // Ensure we have a definition for a validator for the given schema. + Generator.prototype.ensureValidator = function (type) { + var key = ast.decodeExpression(type); + if (!this.validators[key]) { + this.validators[key] = { '.validate': ast.literal('***TYPE RECURSION***') }; + this.validators[key] = this.createValidator(type); + } + return this.validators[key]; + }; + Generator.prototype.createValidator = function (type) { + var _this = this; + switch (type.type) { + case 'type': + return this.createValidatorFromSchemaName(type.name); + case 'union': + var union_1 = {}; + type.types.forEach(function (typePart) { + // Make a copy + var singleType = extendValidator({}, _this.ensureValidator(typePart)); + mapValidator(singleType, ast.andArray); + extendValidator(union_1, singleType); + }); + mapValidator(union_1, ast.orArray); + return union_1; + case 'generic': + var genericType = type; + return this.createValidatorFromGeneric(genericType.name, genericType.params); + default: + throw new Error(errors.application + "invalid internal type: " + type.type); + } + }; + Generator.prototype.createValidatorFromGeneric = function (schemaName, params) { + var schema = this.symbols.schema[schemaName]; + if (schema === undefined || !ast.Schema.isGeneric(schema)) { + throw new Error(errors.noSuchType + schemaName + " (generic)"); + } + var schemaParams = schema.params; + if (params.length !== schemaParams.length) { + throw new Error(errors.invalidGeneric + " expected <" + schemaParams.join(', ') + ">"); + } + // Call custom validator, if given. + if (schema.getValidator) { + return schema.getValidator(params); + } + var bindings = {}; + for (var i = 0; i < params.length; i++) { + bindings[schemaParams[i]] = params[i]; + } + // Expand generics and generate validator from schema. + schema = this.replaceGenericsInSchema(schema, bindings); + return this.createValidatorFromSchema(schema); + }; + Generator.prototype.replaceGenericsInSchema = function (schema, bindings) { + var _this = this; + var expandedSchema = { + derivedFrom: this.replaceGenericsInExp(schema.derivedFrom, bindings), + properties: {}, + methods: {} + }; + var props = Object.keys(schema.properties); + props.forEach(function (prop) { + expandedSchema.properties[prop] = + _this.replaceGenericsInExp(schema.properties[prop], bindings); + }); + var methods = Object.keys(schema.methods); + methods.forEach(function (methodName) { + expandedSchema.methods[methodName] = _this.replaceGenericsInMethod(schema.methods[methodName], bindings); + }); + return expandedSchema; + }; + Generator.prototype.replaceGenericsInExp = function (exp, bindings) { + var self = this; + function replaceGenericsInArray(exps) { + return exps.map(function (expPart) { + return self.replaceGenericsInExp(expPart, bindings); + }); + } + switch (exp.type) { + case 'op': + case 'call': + var opType = ast.copyExp(exp); + opType.args = replaceGenericsInArray(opType.args); + return opType; + case 'type': + var simpleType = exp; + return bindings[simpleType.name] || simpleType; + case 'union': + var unionType = exp; + return ast.unionType(replaceGenericsInArray(unionType.types)); + case 'generic': + var genericType = exp; + return ast.genericType(genericType.name, replaceGenericsInArray(genericType.params)); + default: + return exp; + } + }; + Generator.prototype.replaceGenericsInMethod = function (method, bindings) { + var expandedMethod = { + params: method.params, + body: method.body + }; + expandedMethod.body = this.replaceGenericsInExp(method.body, bindings); + return expandedMethod; + }; + Generator.prototype.createValidatorFromSchemaName = function (schemaName) { + var schema = this.symbols.schema[schemaName]; + if (!schema) { + throw new Error(errors.noSuchType + schemaName); + } + if (ast.Schema.isGeneric(schema)) { + throw new Error(errors.noSuchType + schemaName + " used as non-generic type."); + } + return this.createValidatorFromSchema(schema); + }; + Generator.prototype.createValidatorFromSchema = function (schema) { + var _this = this; + var hasProps = Object.keys(schema.properties).length > 0 && + !this.isCollectionSchema(schema); + if (hasProps && !this.symbols.isDerivedFrom(schema.derivedFrom, 'Object')) { + this.fatal(errors.nonObject + " (is " + ast.decodeExpression(schema.derivedFrom) + ")"); + return {}; + } + var validator = {}; + if (!(schema.derivedFrom.type === 'type' && + schema.derivedFrom.name === 'Any')) { + extendValidator(validator, this.ensureValidator(schema.derivedFrom)); + } + var requiredProperties = []; + var wildProperties = 0; + Object.keys(schema.properties).forEach(function (propName) { + if (propName[0] === '$') { + wildProperties += 1; + if (INVALID_KEY_REGEX.test(propName.slice(1))) { + _this.fatal(errors.invalidPropertyName + propName); + } + } + else { + if (INVALID_KEY_REGEX.test(propName)) { + _this.fatal(errors.invalidPropertyName + propName); + } + } + if (!validator[propName]) { + validator[propName] = {}; + } + var propType = schema.properties[propName]; + if (propName[0] !== '$' && !_this.isNullableType(propType)) { + requiredProperties.push(propName); + } + extendValidator(validator[propName], _this.ensureValidator(propType)); + }); + if (wildProperties > 1 || wildProperties === 1 && requiredProperties.length > 0) { + this.fatal(errors.invalidWildChildren); + } + if (requiredProperties.length > 0) { + // this.hasChildren(requiredProperties) + extendValidator(validator, { '.validate': [hasChildrenExp(requiredProperties)] }); + } + // Disallow $other properties by default + if (hasProps) { + validator['$other'] = {}; + extendValidator(validator['$other'], { '.validate': ast.boolean(false) }); + } + this.extendValidationMethods(validator, schema.methods); + return validator; + }; + Generator.prototype.isNullableType = function (type) { + var result = this.symbols.isDerivedFrom(type, 'Null') || + this.symbols.isDerivedFrom(type, 'Map'); + return result; + }; + // Update rules based on the given path expression. + Generator.prototype.updateRules = function (path) { + var i; + var location = util.ensureObjectPath(this.rules, path.template.getLabels()); + var exp; + extendValidator(location, this.ensureValidator(path.isType)); + location['.scope'] = path.template.getScope(); + this.extendValidationMethods(location, path.methods); + // Write indices + if (path.methods['index']) { + switch (path.methods['index'].body.type) { + case 'String': + exp = ast.array([path.methods['index'].body]); + break; + case 'Array': + exp = path.methods['index'].body; + break; + default: + this.fatal(errors.badIndex); + return; + } + var indices = []; + for (i = 0; i < exp.value.length; i++) { + if (exp.value[i].type !== 'String') { + this.fatal(errors.badIndex + " (not " + exp.value[i].type + ")"); + } + else { + indices.push(exp.value[i].value); + } + } + // TODO: Error check not over-writing index rules. + location['.indexOn'] = indices; + } + }; + Generator.prototype.extendValidationMethods = function (validator, methods) { + var writeMethods = []; + ['create', 'update', 'delete'].forEach(function (method) { + if (method in methods) { + writeMethods.push(ast.andArray([writeAliases[method], methods[method].body])); + } + }); + if (writeMethods.length !== 0) { + extendValidator(validator, { '.write': ast.orArray(writeMethods) }); + } + ['validate', 'read', 'write'].forEach(function (method) { + if (method in methods) { + var methodValidator = {}; + methodValidator['.' + method] = methods[method].body; + extendValidator(validator, methodValidator); + } + }); + }; + // Return union validator (||) over each schema + Generator.prototype.unionValidators = function (schema) { + var union = {}; + schema.forEach(function (typeName) { + // First and the validator terms for a single type + // Todo extend to unions and generics + var singleType = extendValidator({}, this.ensureValidator(typeName)); + mapValidator(singleType, ast.andArray); + extendValidator(union, singleType); + }.bind(this)); + mapValidator(union, ast.orArray); + return union; + }; + // Convert expressions to text, and at the same time, apply pruning operations + // to remove no-op rules. + Generator.prototype.convertExpressions = function (validator) { + var _this = this; + var methodThisIs = { '.validate': 'newData', + '.read': 'data', + '.write': 'newData' }; + function hasWildcardSibling(path) { + var parts = path.getLabels(); + var childPart = parts.pop(); + var parent = util.deepLookup(validator, parts); + if (parent === undefined) { + return false; + } + for (var _i = 0, _a = Object.keys(parent); _i < _a.length; _i++) { + var prop = _a[_i]; + if (prop === childPart) { + continue; + } + if (prop[0] === '$') { + return true; + } + } + return false; + } + mapValidator(validator, function (value, prop, scope, path) { + if (prop in methodThisIs) { + var result = _this.getExpressionText(ast.andArray(collapseHasChildren(value)), methodThisIs[prop], scope, path); + // Remove no-op .read or .write rule if no sibling wildcard props. + if ((prop === '.read' || prop === '.write') && result === 'false') { + if (!hasWildcardSibling(path)) { + return undefined; + } + } + // Remove no-op .validate rule if no sibling wildcard props. + if (prop === '.validate' && result === 'true') { + if (!hasWildcardSibling(path)) { + return undefined; + } + } + return result; + } + return value; + }); + }; + Generator.prototype.getExpressionText = function (exp, thisIs, scope, path) { + if (!('type' in exp)) { + throw new Error(errors.application + "Not an expression: " + util.prettyJSON(exp)); + } + // First evaluate w/o binding of this to specific location. + this.allowUndefinedFunctions = true; + scope = util.extend({}, scope, { 'this': ast.cast(ast.call(ast.variable('@getThis')), 'Snapshot') }); + exp = this.partialEval(exp, scope); + // Now re-evaluate the flattened expression. + this.allowUndefinedFunctions = false; + this.thisIs = thisIs; + this.symbols.registerFunction('@getThis', [], ast.builtin(this.getThis.bind(this))); + this.symbols.registerFunction('@root', [], ast.builtin(this.getRootReference.bind(this, path))); + this.symbols.registerFunction('prior', ['exp'], ast.builtin(this.prior.bind(this))); + this.symbols.registerFunction('key', [], ast.builtin(this.getKey.bind(this, path.length() === 0 ? '' : path.getPart(-1).label))); + exp = this.partialEval(exp); + delete this.symbols.functions['@getThis']; + delete this.symbols.functions['@root']; + delete this.symbols.functions['prior']; + delete this.symbols.functions['key']; + // Top level expressions should never be to a snapshot reference - should + // always evaluate to a boolean. + exp = ast.ensureBoolean(exp); + return ast.decodeExpression(exp); + }; + /* + * Wrapper for partialEval debugging. + */ + Generator.prototype.partialEval = function (exp, params, functionCalls) { + if (params === void 0) { params = {}; } + if (functionCalls === void 0) { functionCalls = {}; } + // Wrap real call for debugging. + var result = this.partialEvalReal(exp, params, functionCalls); + // console.log(ast.decodeExpression(exp) + " => " + ast.decodeExpression(result)); + return result; + }; + // Partial evaluation of expressions - copy of expression tree (immutable). + // + // - Expand inline function calls. + // - Replace local and global variables with their values. + // - Expand snapshot references using child('ref'). + // - Coerce snapshot references to values as needed. + Generator.prototype.partialEvalReal = function (exp, params, functionCalls) { + if (params === void 0) { params = {}; } + if (functionCalls === void 0) { functionCalls = {}; } + var self = this; + function subExpression(exp2) { + return self.partialEval(exp2, params, functionCalls); + } + function valueExpression(exp2) { + return ast.ensureValue(subExpression(exp2)); + } + function booleanExpression(exp2) { + return ast.ensureBoolean(subExpression(exp2)); + } + function lookupVar(exp2) { + // TODO: Unbound variable access should be an error. + return params[exp2.name] || self.globals[exp2.name] || exp2; + } + // Convert ref[prop] => ref.child(prop) + function snapshotChild(ref) { + return ast.cast(ast.call(ast.reference(ref.base, ast.string('child')), [ref.accessor]), 'Snapshot'); + } + switch (exp.type) { + case 'op': + var expOp = ast.copyExp(exp); + // Ensure arguments are boolean (or values) where needed. + if (expOp.op === 'value') { + expOp.args[0] = valueExpression(expOp.args[0]); + } + else if (expOp.op === '||' || expOp.op === '&&' || expOp.op === '!') { + for (var i = 0; i < expOp.args.length; i++) { + expOp.args[i] = booleanExpression(expOp.args[i]); + } + } + else if (expOp.op === '?:') { + expOp.args[0] = booleanExpression(expOp.args[0]); + expOp.args[1] = valueExpression(expOp.args[1]); + expOp.args[2] = valueExpression(expOp.args[2]); + } + else { + for (var i = 0; i < expOp.args.length; i++) { + expOp.args[i] = valueExpression(expOp.args[i]); + } + } + return expOp; + case 'var': + return lookupVar(exp); + case 'ref': + var expRef = ast.copyExp(exp); + expRef.base = subExpression(expRef.base); + // var[ref] => var[ref] + if (expRef.base.valueType !== 'Snapshot') { + expRef.accessor = subExpression(expRef.accessor); + return expRef; + } + var propName = ast.getPropName(expRef); + // snapshot.prop (static string property) + if (propName !== '') { + // snapshot.valueMethod => snapshot.val().valueMethod + if (util.arrayIncludes(valueMethods, propName)) { + expRef.base = valueExpression(expRef.base); + return expRef; + } + // snapshot.ssMethod => snapshot.ssMethod + if (util.arrayIncludes(snapshotMethods, propName)) { + return expRef; + } + } + // snapshot[exp] => snapshot.child(exp) or + // snapshot[ref] => snapshot.child(ref.val()) + expRef.accessor = valueExpression(expRef.accessor); + return snapshotChild(expRef); + case 'call': + var expCall = ast.copyExp(exp); + expCall.ref = subExpression(expCall.ref); + var callee = this.lookupFunction(expCall.ref); + // Expand the function call inline + if (callee) { + var fn = callee.fn; + if (callee.self) { + expCall.args.unshift(ast.ensureValue(callee.self)); + } + if (fn.params.length !== expCall.args.length) { + this.fatal(errors.mismatchParams + " ( " + + callee.methodName + " expects " + fn.params.length + + " but actually passed " + expCall.args.length + ")"); + return exp; + } + if (fn.body.type === 'builtin') { + return fn.body.fn(expCall.args, params); + } + var innerParams = {}; + for (var i = 0; i < fn.params.length; i++) { + innerParams[fn.params[i]] = subExpression(expCall.args[i]); + } + if (functionCalls[callee.methodName]) { + throw new Error(errors.recursive + " (" + callee.methodName + ")"); + } + functionCalls[callee.methodName] = true; + var result = this.partialEval(fn.body, innerParams, functionCalls); + functionCalls[callee.methodName] = false; + return result; + } + // Can't expand function - but just expand the arguments. + if (!this.allowUndefinedFunctions) { + var funcName = ast.getMethodName(expCall); + if (funcName !== '' && !(funcName in this.symbols.schema['String'].methods || + util.arrayIncludes(snapshotMethods, funcName))) { + this.fatal(errors.undefinedFunction + ast.decodeExpression(expCall.ref)); + } + } + for (var i = 0; i < expCall.args.length; i++) { + expCall.args[i] = subExpression(expCall.args[i]); + } + // Hack for snapshot.parent().val() + // Todo - build table-based method signatures. + if (ast.getMethodName(expCall) === 'parent') { + expCall = ast.cast(expCall, 'Snapshot'); + } + return expCall; + // Expression types (like literals) than need no expansion. + default: + return exp; + } + }; + // Builtin function - convert all 'this' to 'data' (from 'newData'). + // Args are function arguments, and params are the local (function) scope variables. + Generator.prototype.prior = function (args, params) { + var lastThisIs = this.thisIs; + this.thisIs = 'data'; + var exp = this.partialEval(args[0], params); + this.thisIs = lastThisIs; + return exp; + }; + // Builtin function - current value of 'this' + Generator.prototype.getThis = function (args, params) { + return ast.snapshotVariable(this.thisIs); + }; + // Builtin function - ensure type of argument + Generator.prototype.ensureType = function (type, args, params) { + if (args.length !== 1) { + throw new Error(errors.application + "ensureType arguments."); + } + var exp = this.partialEval(args[0], params); + if (exp.type !== type) { + throw new Error(errors.coercion + ast.decodeExpression(exp) + " => " + type); + } + return exp; + }; + // Builtin function - return the parent key of 'this'. + Generator.prototype.getKey = function (key, args, params) { + if (args.length !== 0) { + throw new Error(errors.mismatchParams + "(found " + args.length + " but expected 1)"); + } + return key[0] === '$' ? ast.literal(key) : ast.string(key); + }; + // Builtin function - return the reference to the root + // When in read mode - use 'root' + // When in write/validate - use path to root via newData.parent()... + Generator.prototype.getRootReference = function (path, args, params) { + if (args.length !== 0) { + throw new Error(errors.application + "@root arguments."); + } + // 'data' case + if (this.thisIs === 'data') { + return ast.snapshotVariable('root'); + } + // TODO(koss): Remove this special case if JSON supports newRoot instead. + // 'newData' case - traverse to root via parent()'s. + var result = ast.snapshotVariable('newData'); + for (var i = 0; i < path.length(); i++) { + result = ast.snapshotParent(result); + } + return result; + }; + // Lookup globally defined function. + Generator.prototype.lookupFunction = function (ref) { + // Function call. + if (ref.type === 'var') { + var refVar = ref; + var fn = this.symbols.functions[refVar.name]; + if (!fn) { + return undefined; + } + return { self: undefined, fn: fn, methodName: refVar.name }; + } + // Method call. + if (ref.type === 'ref') { + var refRef = ref; + // TODO: Require static type validation before calling String methods. + if (refRef.base.op !== 'value' && + refRef.accessor.value in this.symbols.schema['String'].methods) { + var methodName = refRef.accessor.value; + return { self: refRef.base, + fn: this.symbols.schema['String'].methods[methodName], + methodName: 'String.' + methodName + }; + } + } + return undefined; + }; + Generator.prototype.fatal = function (s) { + logger_1.error(s); + this.errorCount += 1; + }; + return Generator; +}()); +exports.Generator = Generator; +; +// Merge all .X terms into target. +function extendValidator(target, src) { + if (src === undefined) { + throw new Error(errors.application + "Illegal validation source."); + } + for (var prop in src) { + if (!src.hasOwnProperty(prop)) { + continue; + } + if (prop[0] === '.') { + if (target[prop] === undefined) { + target[prop] = []; + } + if (util.isType(src[prop], 'array')) { + util.extendArray(target[prop], src[prop]); + } + else { + target[prop].push(src[prop]); + } + } + else { + if (!target[prop]) { + target[prop] = {}; + } + extendValidator(target[prop], src[prop]); + } + } + return target; +} +exports.extendValidator = extendValidator; +// Call fn(value, prop, path) on all '.props' and assiging the value back into the +// validator. +function mapValidator(v, fn, scope, path) { + if (!scope) { + scope = {}; + } + if (!path) { + path = new ast.PathTemplate(); + } + if ('.scope' in v) { + scope = v['.scope']; + } + for (var prop in v) { + if (!v.hasOwnProperty(prop)) { + continue; + } + if (prop[0] === '.') { + var value = fn(v[prop], prop, scope, path); + if (value !== undefined) { + v[prop] = value; + } + else { + delete v[prop]; + } + } + else if (!util.isType(v[prop], 'object')) { + continue; + } + else { + var child = new ast.PathTemplate([prop]); + path.push(child); + mapValidator(v[prop], fn, scope, path); + path.pop(child); + } + } +} +exports.mapValidator = mapValidator; +// Collapse all hasChildren calls into one (combining their arguments). +// E.g. [newData.hasChildren(), newData.hasChildren(['x']), newData.hasChildren(['y'])] => +// newData.hasChildren(['x', 'y']) +function collapseHasChildren(exps) { + var hasHasChildren = false; + var combined = []; + var result = []; + exps.forEach(function (exp) { + if (exp.type !== 'call') { + result.push(exp); + return; + } + var expCall = exp; + if (ast.getMethodName(expCall) !== 'hasChildren') { + result.push(exp); + return; + } + if (expCall.args.length === 0) { + hasHasChildren = true; + return; + } + // Expect one argument of Array type. + if (expCall.args.length !== 1 || expCall.args[0].type !== 'Array') { + throw new Error(errors.application + "Invalid argument to hasChildren(): " + + expCall.args[0].type); + } + var args = expCall.args[0].value; + args.forEach(function (arg) { + hasHasChildren = true; + if (arg.type !== 'String') { + throw new Error(errors.application + "Expect string argument to hasChildren(), not: " + + arg.type); + } + combined.push(arg.value); + }); + }); + if (hasHasChildren) { + result.unshift(hasChildrenExp(combined)); + } + return result; +} +// Generate this.hasChildren([props, ...]) or this.hasChildren() +function hasChildrenExp(props) { + var args = props.length === 0 ? [] : [ast.array(props.map(ast.string))]; + return ast.call(ast.reference(ast.cast(ast.variable('this'), 'Any'), ast.string('hasChildren')), args); +} + + +},{"./ast":1,"./logger":3,"./parse-util":4,"./rules-parser":6,"./util":7}],6:[function(require,module,exports){ +module.exports = (function() { + /* + * Generated by PEG.js 0.8.0. + * + * http://pegjs.majda.cz/ + */ + + function peg$subclass(child, parent) { + function ctor() { this.constructor = child; } + ctor.prototype = parent.prototype; + child.prototype = new ctor(); + } + + function SyntaxError(message, expected, found, offset, line, column) { + this.message = message; + this.expected = expected; + this.found = found; + this.offset = offset; + this.line = line; + this.column = column; + + this.name = "SyntaxError"; + } + + peg$subclass(SyntaxError, Error); + + function parse(input) { + var options = arguments.length > 1 ? arguments[1] : {}, + + peg$FAILED = {}, + + peg$startRuleFunctions = { start: peg$parsestart }, + peg$startRuleFunction = peg$parsestart, + + peg$c0 = peg$FAILED, + peg$c1 = function() { + if (logger.hasErrors()) { + throw(new Error(logger.errorSummary())); + } + return symbols; + }, + peg$c2 = [], + peg$c3 = { type: "other", description: "function definition" }, + peg$c4 = null, + peg$c5 = function(func, body) { + if (func.name === null) { + error("Missing function name."); + return; + } + if (func.params === null) { + error("Function " + func.name + " missing parameters."); + return; + } + if (body === null) { + error("Function " + func.name + " missing or invalid function body."); + return; + } + symbols.registerFunction(ensureLowerCase(func.name, "Function names"), func.params, body); + }, + peg$c6 = "function", + peg$c7 = { type: "literal", value: "function", description: "\"function\"" }, + peg$c8 = function(name, params) { return {name: name, params: params}; }, + peg$c9 = function(name, params) {return {name: name, params: params}; }, + peg$c10 = { type: "other", description: "path statement" }, + peg$c11 = "is", + peg$c12 = { type: "literal", value: "is", description: "\"is\"" }, + peg$c13 = function(id) { return id; }, + peg$c14 = "{", + peg$c15 = { type: "literal", value: "{", description: "\"{\"" }, + peg$c16 = "}", + peg$c17 = { type: "literal", value: "}", description: "\"}\"" }, + peg$c18 = function(all) { return all; }, + peg$c19 = ";", + peg$c20 = { type: "literal", value: ";", description: "\";\"" }, + peg$c21 = function() { return {}; }, + peg$c22 = function(path, isType, methods) { + if (path === null) { + return; + } + if (methods === null) { + error("Missing body of path statement."); + return; + } + symbols.registerPath(currentPath, isType, methods); + currentPath.pop(path); + }, + peg$c23 = "path", + peg$c24 = { type: "literal", value: "path", description: "\"path\"" }, + peg$c25 = function(path) { + if (path === null) { + error("Missing Path Template in path statement."); + return path; + } + currentPath.push(path); + return path; + }, + peg$c26 = function(path) { + currentPath.push(path); return path; + }, + peg$c27 = { type: "other", description: "path template" }, + peg$c28 = "/", + peg$c29 = { type: "literal", value: "/", description: "\"/\"" }, + peg$c30 = function(part) { return part; }, + peg$c31 = function(parts) { + var hasError = false; + if (parts.length === 1 && parts[0] === null) { + parts = []; + } + parts = parts.map(function(part) { + if (part === null) { + hasError = true; + return ''; + } + return part; + }); + if (hasError) { + error((parts[parts.length - 1] === '' + ? "Paths may not end in a slash (/) character" + : "Paths may not contain an empty part") + ": /" + parts.map(function(part) { return part.label; }).join('/')); + } + return new ast.PathTemplate(parts); + }, + peg$c32 = "=", + peg$c33 = { type: "literal", value: "=", description: "\"=\"" }, + peg$c34 = "*", + peg$c35 = { type: "literal", value: "*", description: "\"*\"" }, + peg$c36 = function(id) { + return new ast.PathPart(id, id); + }, + peg$c37 = /^[^ \/;]/, + peg$c38 = { type: "class", value: "[^ \\/;]", description: "[^ \\/;]" }, + peg$c39 = function(chars) { + var result = chars.join(''); + if (chars[0] === '$') { + warn("Use of " + result + " to capture a path segment is deprecated; " + + "use {" + result + "} or {" + result.slice(1) + "}, instead."); + } + return new ast.PathPart(result); + }, + peg$c40 = function(all) { + var result = {}; + for (var i = 0; i < all.length; i++) { + var method = all[i]; + // Skip embedded path statements. + if (method === undefined) { + continue; + } + if (typeof method == 'string') { + error("Invalid path or method: '" + method + "'."); + continue; + } + if (method.name in result) { + error("Duplicate method name: " + method.name); + } + result[method.name] = ast.method(method.params, method.body); + } + return result; + }, + peg$c41 = { type: "other", description: "type statement" }, + peg$c42 = "type", + peg$c43 = { type: "literal", value: "type", description: "\"type\"" }, + peg$c44 = "<", + peg$c45 = { type: "literal", value: "<", description: "\"<\"" }, + peg$c46 = ">", + peg$c47 = { type: "literal", value: ">", description: "\">\"" }, + peg$c48 = function(list) { return ensureUpperCase(list, "Type names"); }, + peg$c49 = "extends", + peg$c50 = { type: "literal", value: "extends", description: "\"extends\"" }, + peg$c51 = function(type) { return type; }, + peg$c52 = function() { return {properties: {}, methods: {}}; }, + peg$c53 = function(type, params, ext, body) { + if (params === null) { + params = []; + } + if (type === null) { + error("Missing type name."); + return; + } + if (body === null) { + error("Missing or invalid type statement body."); + return; + } + symbols.registerSchema(ensureUpperCase(type, "Type names"), + ext, body.properties, body.methods, params); + }, + peg$c54 = function(all) { + var result = { + properties: {}, + methods: {} + }; + + function addPart(part) { + // TODO: Make sure methods and properties don't shadow each other. + if (typeof part === 'string') { + error("Invalid property or method: '" + part + "'."); + return; + } + if ('type' in part) { + if (result.properties[part.name]) { + error("Duplicate property name: " + part.name); + } + result.properties[part.name] = part.type; + } else { + if (result.methods[part.name]) { + error("Duplicate method name: " + part.name); + } + result.methods[part.name] = ast.method(part.params, part.body); + } + } + + for (var i = 0; i < all.length; i++) { + addPart(all[i]); + } + + return result; + }, + peg$c55 = ":", + peg$c56 = { type: "literal", value: ":", description: "\":\"" }, + peg$c57 = function(name, type) { + return { + name: name, + type: type + }; + }, + peg$c58 = ",", + peg$c59 = { type: "literal", value: ",", description: "\",\"" }, + peg$c60 = function(sep) { return sep; }, + peg$c61 = { type: "other", description: "method" }, + peg$c62 = function(name, params, body, sep) { + if (sep !== null) { + warn("Extra separator (" + sep + ") not needed."); + } + return { + name: ensureLowerCase(name, "Method names"), + params: params, + body: body + }; + }, + peg$c63 = "return", + peg$c64 = { type: "literal", value: "return", description: "\"return\"" }, + peg$c65 = function(exp) { return exp; }, + peg$c66 = function(exp) { + warn("Use of fn(x) = exp; format is deprecated; use fn(x) { exp }, instead.") + return exp; + }, + peg$c67 = "(", + peg$c68 = { type: "literal", value: "(", description: "\"(\"" }, + peg$c69 = ")", + peg$c70 = { type: "literal", value: ")", description: "\")\"" }, + peg$c71 = function(list) { return ensureLowerCase(list, "Function arguments"); }, + peg$c72 = function(head, tail) { + if (!head) { + return []; + } + tail.unshift(head); + return tail; + }, + peg$c73 = "|", + peg$c74 = { type: "literal", value: "|", description: "\"|\"" }, + peg$c75 = function(head, tail) { + if (tail.length == 0) { + return head; + } + tail.unshift(head); + return ast.unionType(tail); + }, + peg$c76 = "[]", + peg$c77 = { type: "literal", value: "[]", description: "\"[]\"" }, + peg$c78 = function() {return {isMap: true}; }, + peg$c79 = function(types) {return {types: types};}, + peg$c80 = function(type, opt) { + type = ensureUpperCase(type, "Type names"); + if (!opt) { + return ast.typeType(type); + } + if (opt.isMap) { + return ast.genericType('Map', [ast.typeType('String'), + ast.typeType(type)]); + } + return ast.genericType(type, opt.types); + }, + peg$c81 = function(head, tail) { + var result = [head]; + util.extendArray(result, tail); + return result; + }, + peg$c82 = void 0, + peg$c83 = function(name) { return ast.variable(name); }, + peg$c84 = function(expression) { return expression; }, + peg$c85 = "[", + peg$c86 = { type: "literal", value: "[", description: "\"[\"" }, + peg$c87 = "]", + peg$c88 = { type: "literal", value: "]", description: "\"]\"" }, + peg$c89 = function(name) { return name; }, + peg$c90 = ".", + peg$c91 = { type: "literal", value: ".", description: "\".\"" }, + peg$c92 = function(base, accessors) { + var result = base; + for (var i = 0; i < accessors.length; i++) { + var exp = typeof accessors[i] == 'string' ? ast.string(accessors[i]) : accessors[i]; + result = ast.reference(result, exp); + } + return result; + }, + peg$c93 = function(ref, args) { + return ast.call(ref, args); + }, + peg$c94 = function(args) { return args }, + peg$c95 = function(name) { return name }, + peg$c96 = function(base, argumentsOrAccessors) { + var result = base; + for (var i = 0; i < argumentsOrAccessors.length; i++) { + var part = argumentsOrAccessors[i]; + if (typeof part == 'string') { + result = ast.reference(result, ast.string(part)); + } else if (util.isType(part, 'array')) { + result = ast.call(result, part); + } else { + result = ast.reference(result, part); + } + } + return result; + }, + peg$c97 = function(args) { + return args !== null ? args : []; + }, + peg$c98 = function(head, tail) { + tail.unshift(head); + return tail; + }, + peg$c99 = function(op, expression) { + if (op == "noop") { + return expression; + } + return ast.op(op, [expression]); + }, + peg$c100 = "+", + peg$c101 = { type: "literal", value: "+", description: "\"+\"" }, + peg$c102 = function() { return "noop"; }, + peg$c103 = "-", + peg$c104 = { type: "literal", value: "-", description: "\"-\"" }, + peg$c105 = function() { return "neg"; }, + peg$c106 = "!", + peg$c107 = { type: "literal", value: "!", description: "\"!\"" }, + peg$c108 = function(op, exp) { return {op: op, exp: exp}; }, + peg$c109 = function(head, tail) { + return leftAssociative(head, tail); + }, + peg$c110 = "%", + peg$c111 = { type: "literal", value: "%", description: "\"%\"" }, + peg$c112 = "<=", + peg$c113 = { type: "literal", value: "<=", description: "\"<=\"" }, + peg$c114 = ">=", + peg$c115 = { type: "literal", value: ">=", description: "\">=\"" }, + peg$c116 = "===", + peg$c117 = { type: "literal", value: "===", description: "\"===\"" }, + peg$c118 = "==", + peg$c119 = { type: "literal", value: "==", description: "\"==\"" }, + peg$c120 = function() { return "=="; }, + peg$c121 = function() { error("Equality operator should be written as ==, not =."); return "=="; }, + peg$c122 = "!==", + peg$c123 = { type: "literal", value: "!==", description: "\"!==\"" }, + peg$c124 = "!=", + peg$c125 = { type: "literal", value: "!=", description: "\"!=\"" }, + peg$c126 = function() { return "!="; }, + peg$c127 = "&&", + peg$c128 = { type: "literal", value: "&&", description: "\"&&\"" }, + peg$c129 = "and", + peg$c130 = { type: "literal", value: "and", description: "\"and\"" }, + peg$c131 = function() { return "&&"; }, + peg$c132 = "||", + peg$c133 = { type: "literal", value: "||", description: "\"||\"" }, + peg$c134 = "or", + peg$c135 = { type: "literal", value: "or", description: "\"or\"" }, + peg$c136 = function() { return "||"; }, + peg$c137 = "?", + peg$c138 = { type: "literal", value: "?", description: "\"?\"" }, + peg$c139 = function(condition, trueExpression, falseExpression) { + return ast.op('?:', [condition, trueExpression, falseExpression]); + }, + peg$c140 = "null", + peg$c141 = { type: "literal", value: "null", description: "\"null\"" }, + peg$c142 = function() { return ast.nullType() }, + peg$c143 = function(elements) { return ast.array(elements); }, + peg$c144 = "true", + peg$c145 = { type: "literal", value: "true", description: "\"true\"" }, + peg$c146 = function() { return ast.boolean(true); }, + peg$c147 = "false", + peg$c148 = { type: "literal", value: "false", description: "\"false\"" }, + peg$c149 = function() { return ast.boolean(false); }, + peg$c150 = { type: "other", description: "number" }, + peg$c151 = /^[+\-]/, + peg$c152 = { type: "class", value: "[+\\-]", description: "[+\\-]" }, + peg$c153 = function(unary, literal) { + if (unary == '-') { + return ast.number(-literal); + } + return ast.number(literal); + }, + peg$c154 = function(parts) { + return parseFloat(parts); + }, + peg$c155 = function(parts) { return parseFloat(parts); }, + peg$c156 = "0", + peg$c157 = { type: "literal", value: "0", description: "\"0\"" }, + peg$c158 = /^[0-9]/, + peg$c159 = { type: "class", value: "[0-9]", description: "[0-9]" }, + peg$c160 = /^[1-9]/, + peg$c161 = { type: "class", value: "[1-9]", description: "[1-9]" }, + peg$c162 = /^[eE]/, + peg$c163 = { type: "class", value: "[eE]", description: "[eE]" }, + peg$c164 = /^[\-+]/, + peg$c165 = { type: "class", value: "[\\-+]", description: "[\\-+]" }, + peg$c166 = /^[xX]/, + peg$c167 = { type: "class", value: "[xX]", description: "[xX]" }, + peg$c168 = function(digits) { return parseInt(digits, 16); }, + peg$c169 = /^[0-9a-fA-F]/, + peg$c170 = { type: "class", value: "[0-9a-fA-F]", description: "[0-9a-fA-F]" }, + peg$c171 = { type: "other", description: "regexp" }, + peg$c172 = /^[a-z]/, + peg$c173 = { type: "class", value: "[a-z]", description: "[a-z]" }, + peg$c174 = function(pattern, modifiers) { + if (modifiers) { + return ast.regexp(pattern, modifiers.join("")); + } + return ast.regexp(pattern); + }, + peg$c175 = /^[^\\\/]/, + peg$c176 = { type: "class", value: "[^\\\\\\/]", description: "[^\\\\\\/]" }, + peg$c177 = function(chars) { return chars.join(""); }, + peg$c178 = "\\", + peg$c179 = { type: "literal", value: "\\", description: "\"\\\\\"" }, + peg$c180 = { type: "any", description: "any character" }, + peg$c181 = function(char_) { return "\\" + char_; }, + peg$c182 = { type: "other", description: "string" }, + peg$c183 = function(s) { return ast.string(s); }, + peg$c184 = "\"", + peg$c185 = { type: "literal", value: "\"", description: "\"\\\"\"" }, + peg$c186 = "'", + peg$c187 = { type: "literal", value: "'", description: "\"'\"" }, + peg$c188 = function(parts) { + return parts[1]; + }, + peg$c189 = function(char_) { return char_; }, + peg$c190 = function(sequence) { return sequence; }, + peg$c191 = function(sequence) { return sequence; }, + peg$c192 = function() { return "\0"; }, + peg$c193 = /^['"\\bfnrt]/, + peg$c194 = { type: "class", value: "['\"\\\\bfnrt]", description: "['\"\\\\bfnrt]" }, + peg$c195 = function(char_) { + return char_ + .replace("b", "\b") + .replace("f", "\f") + .replace("n", "\n") + .replace("r", "\r") + .replace("t", "\t") + }, + peg$c196 = function(char_) { return char_; }, + peg$c197 = "x", + peg$c198 = { type: "literal", value: "x", description: "\"x\"" }, + peg$c199 = "u", + peg$c200 = { type: "literal", value: "u", description: "\"u\"" }, + peg$c201 = function(digits) { + return String.fromCharCode(parseInt(digits, 16)); + }, + peg$c202 = { type: "other", description: "identifier" }, + peg$c203 = /^[a-zA-Z_$]/, + peg$c204 = { type: "class", value: "[a-zA-Z_$]", description: "[a-zA-Z_$]" }, + peg$c205 = /^[a-zA-Z_$0-9]/, + peg$c206 = { type: "class", value: "[a-zA-Z_$0-9]", description: "[a-zA-Z_$0-9]" }, + peg$c207 = function(start, rest) { + return start + rest.join(""); + }, + peg$c208 = { type: "other", description: "whitespace" }, + peg$c209 = /^[ \t\r\n]/, + peg$c210 = { type: "class", value: "[ \\t\\r\\n]", description: "[ \\t\\r\\n]" }, + peg$c211 = { type: "other", description: "comment" }, + peg$c212 = "/*", + peg$c213 = { type: "literal", value: "/*", description: "\"/*\"" }, + peg$c214 = "*/", + peg$c215 = { type: "literal", value: "*/", description: "\"*/\"" }, + peg$c216 = "//", + peg$c217 = { type: "literal", value: "//", description: "\"//\"" }, + peg$c218 = /^[;,}]/, + peg$c219 = { type: "class", value: "[;,}]", description: "[;,}]" }, + peg$c220 = function(chars) { return chars.join(''); }, + peg$c221 = /^[\n\r]/, + peg$c222 = { type: "class", value: "[\\n\\r]", description: "[\\n\\r]" }, + + peg$currPos = 0, + peg$reportedPos = 0, + peg$cachedPos = 0, + peg$cachedPosDetails = { line: 1, column: 1, seenCR: false }, + peg$maxFailPos = 0, + peg$maxFailExpected = [], + peg$silentFails = 0, + + peg$result; + + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error("Can't start parsing from rule \"" + options.startRule + "\"."); + } + + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + + function text() { + return input.substring(peg$reportedPos, peg$currPos); + } + + function offset() { + return peg$reportedPos; + } + + function line() { + return peg$computePosDetails(peg$reportedPos).line; + } + + function column() { + return peg$computePosDetails(peg$reportedPos).column; + } + + function expected(description) { + throw peg$buildException( + null, + [{ type: "other", description: description }], + peg$reportedPos + ); + } + + function error(message) { + throw peg$buildException(message, null, peg$reportedPos); + } + + function peg$computePosDetails(pos) { + function advance(details, startPos, endPos) { + var p, ch; + + for (p = startPos; p < endPos; p++) { + ch = input.charAt(p); + if (ch === "\n") { + if (!details.seenCR) { details.line++; } + details.column = 1; + details.seenCR = false; + } else if (ch === "\r" || ch === "\u2028" || ch === "\u2029") { + details.line++; + details.column = 1; + details.seenCR = true; + } else { + details.column++; + details.seenCR = false; + } + } + } + + if (peg$cachedPos !== pos) { + if (peg$cachedPos > pos) { + peg$cachedPos = 0; + peg$cachedPosDetails = { line: 1, column: 1, seenCR: false }; + } + advance(peg$cachedPosDetails, peg$cachedPos, pos); + peg$cachedPos = pos; + } + + return peg$cachedPosDetails; + } + + function peg$fail(expected) { + if (peg$currPos < peg$maxFailPos) { return; } + + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + + peg$maxFailExpected.push(expected); + } + + function peg$buildException(message, expected, pos) { + function cleanupExpected(expected) { + var i = 1; + + expected.sort(function(a, b) { + if (a.description < b.description) { + return -1; + } else if (a.description > b.description) { + return 1; + } else { + return 0; + } + }); + + while (i < expected.length) { + if (expected[i - 1] === expected[i]) { + expected.splice(i, 1); + } else { + i++; + } + } + } + + function buildMessage(expected, found) { + function stringEscape(s) { + function hex(ch) { return ch.charCodeAt(0).toString(16).toUpperCase(); } + + return s + .replace(/\\/g, '\\\\') + .replace(/"/g, '\\"') + .replace(/\x08/g, '\\b') + .replace(/\t/g, '\\t') + .replace(/\n/g, '\\n') + .replace(/\f/g, '\\f') + .replace(/\r/g, '\\r') + .replace(/[\x00-\x07\x0B\x0E\x0F]/g, function(ch) { return '\\x0' + hex(ch); }) + .replace(/[\x10-\x1F\x80-\xFF]/g, function(ch) { return '\\x' + hex(ch); }) + .replace(/[\u0180-\u0FFF]/g, function(ch) { return '\\u0' + hex(ch); }) + .replace(/[\u1080-\uFFFF]/g, function(ch) { return '\\u' + hex(ch); }); + } + + var expectedDescs = new Array(expected.length), + expectedDesc, foundDesc, i; + + for (i = 0; i < expected.length; i++) { + expectedDescs[i] = expected[i].description; + } + + expectedDesc = expected.length > 1 + ? expectedDescs.slice(0, -1).join(", ") + + " or " + + expectedDescs[expected.length - 1] + : expectedDescs[0]; + + foundDesc = found ? "\"" + stringEscape(found) + "\"" : "end of input"; + + return "Expected " + expectedDesc + " but " + foundDesc + " found."; + } + + var posDetails = peg$computePosDetails(pos), + found = pos < input.length ? input.charAt(pos) : null; + + if (expected !== null) { + cleanupExpected(expected); + } + + return new SyntaxError( + message !== null ? message : buildMessage(expected, found), + expected, + found, + pos, + posDetails.line, + posDetails.column + ); + } + + function peg$parsestart() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = peg$parse_(); + if (s1 !== peg$FAILED) { + s2 = peg$parseStatements(); + if (s2 !== peg$FAILED) { + s3 = peg$parse_(); + if (s3 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c1(); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseStatements() { + var s0, s1, s2, s3; + + s0 = []; + s1 = peg$currPos; + s2 = peg$parseStatement(); + if (s2 !== peg$FAILED) { + s3 = peg$parse_(); + if (s3 !== peg$FAILED) { + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$c0; + } + } else { + peg$currPos = s1; + s1 = peg$c0; + } + while (s1 !== peg$FAILED) { + s0.push(s1); + s1 = peg$currPos; + s2 = peg$parseStatement(); + if (s2 !== peg$FAILED) { + s3 = peg$parse_(); + if (s3 !== peg$FAILED) { + s2 = [s2, s3]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$c0; + } + } else { + peg$currPos = s1; + s1 = peg$c0; + } + } + + return s0; + } + + function peg$parseStatement() { + var s0; + + s0 = peg$parseFunction(); + if (s0 === peg$FAILED) { + s0 = peg$parsePath(); + if (s0 === peg$FAILED) { + s0 = peg$parseSchema(); + } + } + + return s0; + } + + function peg$parseFunction() { + var s0, s1, s2; + + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseFunctionStart(); + if (s1 !== peg$FAILED) { + s2 = peg$parseFunctionBody(); + if (s2 === peg$FAILED) { + s2 = peg$c4; + } + if (s2 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c5(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c3); } + } + + return s0; + } + + function peg$parseFunctionStart() { + var s0, s1, s2, s3, s4, s5, s6; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 8) === peg$c6) { + s1 = peg$c6; + peg$currPos += 8; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c7); } + } + if (s1 !== peg$FAILED) { + s2 = peg$parse__(); + if (s2 !== peg$FAILED) { + s3 = peg$parseIdentifier(); + if (s3 === peg$FAILED) { + s3 = peg$c4; + } + if (s3 !== peg$FAILED) { + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + s5 = peg$parseParameterList(); + if (s5 === peg$FAILED) { + s5 = peg$c4; + } + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c8(s3, s5); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseIdentifier(); + if (s1 !== peg$FAILED) { + s2 = peg$parse_(); + if (s2 !== peg$FAILED) { + s3 = peg$parseParameterList(); + if (s3 !== peg$FAILED) { + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c9(s1, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } + + return s0; + } + + function peg$parsePath() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8; + + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parsePathStart(); + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + s3 = peg$parse__(); + if (s3 !== peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c11) { + s4 = peg$c11; + peg$currPos += 2; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c12); } + } + if (s4 !== peg$FAILED) { + s5 = peg$parse__(); + if (s5 !== peg$FAILED) { + s6 = peg$parseTypeExpression(); + if (s6 !== peg$FAILED) { + peg$reportedPos = s2; + s3 = peg$c13(s6); + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$c0; + } + } else { + peg$currPos = s2; + s2 = peg$c0; + } + } else { + peg$currPos = s2; + s2 = peg$c0; + } + } else { + peg$currPos = s2; + s2 = peg$c0; + } + if (s2 === peg$FAILED) { + s2 = peg$c4; + } + if (s2 !== peg$FAILED) { + s3 = peg$parse_(); + if (s3 !== peg$FAILED) { + s4 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 123) { + s5 = peg$c14; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c15); } + } + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parsePathsAndMethods(); + if (s7 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 125) { + s8 = peg$c16; + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c17); } + } + if (s8 !== peg$FAILED) { + peg$reportedPos = s4; + s5 = peg$c18(s7); + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$c0; + } + } else { + peg$currPos = s4; + s4 = peg$c0; + } + } else { + peg$currPos = s4; + s4 = peg$c0; + } + } else { + peg$currPos = s4; + s4 = peg$c0; + } + if (s4 === peg$FAILED) { + s4 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 59) { + s5 = peg$c19; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c20); } + } + if (s5 !== peg$FAILED) { + peg$reportedPos = s4; + s5 = peg$c21(); + } + s4 = s5; + } + if (s4 === peg$FAILED) { + s4 = peg$c4; + } + if (s4 !== peg$FAILED) { + s5 = peg$parse_(); + if (s5 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c22(s1, s2, s4); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c10); } + } + + return s0; + } + + function peg$parsePathStart() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 4) === peg$c23) { + s1 = peg$c23; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c24); } + } + if (s1 !== peg$FAILED) { + s2 = peg$parse__(); + if (s2 !== peg$FAILED) { + s3 = peg$parsePathTemplate(); + if (s3 === peg$FAILED) { + s3 = peg$c4; + } + if (s3 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c25(s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsePathTemplate(); + if (s1 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c26(s1); + } + s0 = s1; + } + + return s0; + } + + function peg$parsePathTemplate() { + var s0, s1, s2, s3, s4; + + peg$silentFails++; + s0 = peg$currPos; + s1 = []; + s2 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 47) { + s3 = peg$c28; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c29); } + } + if (s3 !== peg$FAILED) { + s4 = peg$parsePathKey(); + if (s4 === peg$FAILED) { + s4 = peg$c4; + } + if (s4 !== peg$FAILED) { + peg$reportedPos = s2; + s3 = peg$c30(s4); + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$c0; + } + } else { + peg$currPos = s2; + s2 = peg$c0; + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 47) { + s3 = peg$c28; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c29); } + } + if (s3 !== peg$FAILED) { + s4 = peg$parsePathKey(); + if (s4 === peg$FAILED) { + s4 = peg$c4; + } + if (s4 !== peg$FAILED) { + peg$reportedPos = s2; + s3 = peg$c30(s4); + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$c0; + } + } else { + peg$currPos = s2; + s2 = peg$c0; + } + } + } else { + s1 = peg$c0; + } + if (s1 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c31(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c27); } + } + + return s0; + } + + function peg$parsePathKey() { + var s0; + + s0 = peg$parseCaptureKey(); + if (s0 === peg$FAILED) { + s0 = peg$parseLiteralPathKey(); + } + + return s0; + } + + function peg$parseCaptureKey() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 123) { + s1 = peg$c14; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c15); } + } + if (s1 !== peg$FAILED) { + s2 = peg$parse_(); + if (s2 !== peg$FAILED) { + s3 = peg$parseIdentifier(); + if (s3 !== peg$FAILED) { + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + s5 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 61) { + s6 = peg$c32; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c33); } + } + if (s6 !== peg$FAILED) { + s7 = peg$parse_(); + if (s7 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 42) { + s8 = peg$c34; + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c35); } + } + if (s8 !== peg$FAILED) { + s9 = peg$parse_(); + if (s9 !== peg$FAILED) { + s6 = [s6, s7, s8, s9]; + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$c0; + } + } else { + peg$currPos = s5; + s5 = peg$c0; + } + } else { + peg$currPos = s5; + s5 = peg$c0; + } + } else { + peg$currPos = s5; + s5 = peg$c0; + } + if (s5 === peg$FAILED) { + s5 = peg$c4; + } + if (s5 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 125) { + s6 = peg$c16; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c17); } + } + if (s6 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c36(s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseLiteralPathKey() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = []; + if (peg$c37.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c38); } + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + if (peg$c37.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c38); } + } + } + } else { + s1 = peg$c0; + } + if (s1 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c39(s1); + } + s0 = s1; + + return s0; + } + + function peg$parsePathsAndMethods() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = []; + s2 = peg$parsePath(); + if (s2 === peg$FAILED) { + s2 = peg$parseMethod(); + if (s2 === peg$FAILED) { + s2 = peg$parseAnyBlock(); + } + } + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parsePath(); + if (s2 === peg$FAILED) { + s2 = peg$parseMethod(); + if (s2 === peg$FAILED) { + s2 = peg$parseAnyBlock(); + } + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parse_(); + if (s2 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c40(s1); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseSchema() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11; + + peg$silentFails++; + s0 = peg$currPos; + if (input.substr(peg$currPos, 4) === peg$c42) { + s1 = peg$c42; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c43); } + } + if (s1 !== peg$FAILED) { + s2 = peg$parse__(); + if (s2 !== peg$FAILED) { + s3 = peg$parseIdentifier(); + if (s3 === peg$FAILED) { + s3 = peg$c4; + } + if (s3 !== peg$FAILED) { + s4 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 60) { + s5 = peg$c44; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c45); } + } + if (s5 !== peg$FAILED) { + s6 = peg$parseIdentifierList(); + if (s6 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 62) { + s7 = peg$c46; + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c47); } + } + if (s7 !== peg$FAILED) { + peg$reportedPos = s4; + s5 = peg$c48(s6); + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$c0; + } + } else { + peg$currPos = s4; + s4 = peg$c0; + } + } else { + peg$currPos = s4; + s4 = peg$c0; + } + if (s4 === peg$FAILED) { + s4 = peg$c4; + } + if (s4 !== peg$FAILED) { + s5 = peg$currPos; + s6 = peg$parse__(); + if (s6 !== peg$FAILED) { + if (input.substr(peg$currPos, 7) === peg$c49) { + s7 = peg$c49; + peg$currPos += 7; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c50); } + } + if (s7 !== peg$FAILED) { + s8 = peg$parse__(); + if (s8 !== peg$FAILED) { + s9 = peg$parseTypeExpression(); + if (s9 !== peg$FAILED) { + s10 = peg$parse_(); + if (s10 !== peg$FAILED) { + peg$reportedPos = s5; + s6 = peg$c51(s9); + s5 = s6; + } else { + peg$currPos = s5; + s5 = peg$c0; + } + } else { + peg$currPos = s5; + s5 = peg$c0; + } + } else { + peg$currPos = s5; + s5 = peg$c0; + } + } else { + peg$currPos = s5; + s5 = peg$c0; + } + } else { + peg$currPos = s5; + s5 = peg$c0; + } + if (s5 === peg$FAILED) { + s5 = peg$c4; + } + if (s5 !== peg$FAILED) { + s6 = peg$currPos; + s7 = peg$parse_(); + if (s7 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 123) { + s8 = peg$c14; + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c15); } + } + if (s8 !== peg$FAILED) { + s9 = peg$parse_(); + if (s9 !== peg$FAILED) { + s10 = peg$parsePropertiesAndMethods(); + if (s10 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 125) { + s11 = peg$c16; + peg$currPos++; + } else { + s11 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c17); } + } + if (s11 !== peg$FAILED) { + peg$reportedPos = s6; + s7 = peg$c18(s10); + s6 = s7; + } else { + peg$currPos = s6; + s6 = peg$c0; + } + } else { + peg$currPos = s6; + s6 = peg$c0; + } + } else { + peg$currPos = s6; + s6 = peg$c0; + } + } else { + peg$currPos = s6; + s6 = peg$c0; + } + } else { + peg$currPos = s6; + s6 = peg$c0; + } + if (s6 === peg$FAILED) { + s6 = peg$currPos; + s7 = peg$parse_(); + if (s7 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 59) { + s8 = peg$c19; + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c20); } + } + if (s8 !== peg$FAILED) { + peg$reportedPos = s6; + s7 = peg$c52(); + s6 = s7; + } else { + peg$currPos = s6; + s6 = peg$c0; + } + } else { + peg$currPos = s6; + s6 = peg$c0; + } + } + if (s6 === peg$FAILED) { + s6 = peg$c4; + } + if (s6 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c53(s3, s4, s5, s6); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c41); } + } + + return s0; + } + + function peg$parsePropertiesAndMethods() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = []; + s2 = peg$parseProperty(); + if (s2 === peg$FAILED) { + s2 = peg$parseMethod(); + if (s2 === peg$FAILED) { + s2 = peg$parseAnyBlock(); + } + } + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseProperty(); + if (s2 === peg$FAILED) { + s2 = peg$parseMethod(); + if (s2 === peg$FAILED) { + s2 = peg$parseAnyBlock(); + } + } + } + if (s1 !== peg$FAILED) { + s2 = peg$parse_(); + if (s2 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c54(s1); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseProperty() { + var s0, s1, s2, s3, s4, s5, s6, s7; + + s0 = peg$currPos; + s1 = peg$parseIdentifier(); + if (s1 === peg$FAILED) { + s1 = peg$parseString(); + } + if (s1 !== peg$FAILED) { + s2 = peg$parse_(); + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 58) { + s3 = peg$c55; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c56); } + } + if (s3 !== peg$FAILED) { + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + s5 = peg$parseTypeExpression(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parsePropSep(); + if (s7 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c57(s1, s5); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parsePropSep() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 44) { + s1 = peg$c58; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c59); } + } + if (s1 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 59) { + s1 = peg$c19; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c20); } + } + } + if (s1 === peg$FAILED) { + s1 = peg$c4; + } + if (s1 !== peg$FAILED) { + s2 = peg$parse_(); + if (s2 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c60(s1); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseMethod() { + var s0, s1, s2, s3, s4, s5; + + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseIdentifier(); + if (s1 !== peg$FAILED) { + s2 = peg$parseParameterList(); + if (s2 !== peg$FAILED) { + s3 = peg$parse_(); + if (s3 !== peg$FAILED) { + s4 = peg$parseFunctionBody(); + if (s4 !== peg$FAILED) { + s5 = peg$parsePropSep(); + if (s5 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c62(s1, s2, s4, s5); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c61); } + } + + return s0; + } + + function peg$parseFunctionBody() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 123) { + s1 = peg$c14; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c15); } + } + if (s1 !== peg$FAILED) { + s2 = peg$parse_(); + if (s2 !== peg$FAILED) { + s3 = peg$currPos; + if (input.substr(peg$currPos, 6) === peg$c63) { + s4 = peg$c63; + peg$currPos += 6; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c64); } + } + if (s4 !== peg$FAILED) { + s5 = peg$parse__(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + if (s3 === peg$FAILED) { + s3 = peg$c4; + } + if (s3 !== peg$FAILED) { + s4 = peg$parseConditionalExpression(); + if (s4 !== peg$FAILED) { + s5 = peg$parse_(); + if (s5 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 59) { + s6 = peg$c19; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c20); } + } + if (s6 === peg$FAILED) { + s6 = peg$c4; + } + if (s6 !== peg$FAILED) { + s7 = peg$parse_(); + if (s7 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 125) { + s8 = peg$c16; + peg$currPos++; + } else { + s8 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c17); } + } + if (s8 !== peg$FAILED) { + s9 = peg$parse_(); + if (s9 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c65(s4); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 61) { + s1 = peg$c32; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c33); } + } + if (s1 !== peg$FAILED) { + s2 = peg$parse_(); + if (s2 !== peg$FAILED) { + s3 = peg$parseConditionalExpression(); + if (s3 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 59) { + s4 = peg$c19; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c20); } + } + if (s4 === peg$FAILED) { + s4 = peg$c4; + } + if (s4 !== peg$FAILED) { + s5 = peg$parse_(); + if (s5 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c66(s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } + + return s0; + } + + function peg$parseParameterList() { + var s0, s1, s2, s3, s4; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 40) { + s1 = peg$c67; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c68); } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseIdentifierList(); + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 41) { + s3 = peg$c69; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c70); } + } + if (s3 !== peg$FAILED) { + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c71(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseIdentifierList() { + var s0, s1, s2, s3, s4, s5, s6, s7; + + s0 = peg$currPos; + s1 = peg$parseIdentifier(); + if (s1 === peg$FAILED) { + s1 = peg$c4; + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 44) { + s5 = peg$c58; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c59); } + } + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseIdentifier(); + if (s7 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c13(s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 44) { + s5 = peg$c58; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c59); } + } + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseIdentifier(); + if (s7 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c13(s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parse_(); + if (s3 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c72(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseTypeExpression() { + var s0, s1, s2, s3, s4, s5, s6, s7; + + s0 = peg$currPos; + s1 = peg$parseSingleType(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 124) { + s5 = peg$c73; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c74); } + } + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseSingleType(); + if (s7 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c51(s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 124) { + s5 = peg$c73; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c74); } + } + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseSingleType(); + if (s7 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c51(s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parse_(); + if (s3 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c75(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseSingleType() { + var s0, s1, s2, s3, s4, s5, s6; + + s0 = peg$currPos; + s1 = peg$parseIdentifier(); + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c76) { + s3 = peg$c76; + peg$currPos += 2; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c77); } + } + if (s3 !== peg$FAILED) { + peg$reportedPos = s2; + s3 = peg$c78(); + } + s2 = s3; + if (s2 === peg$FAILED) { + s2 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 60) { + s3 = peg$c44; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c45); } + } + if (s3 !== peg$FAILED) { + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + s5 = peg$parseTypeList(); + if (s5 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 62) { + s6 = peg$c46; + peg$currPos++; + } else { + s6 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c47); } + } + if (s6 !== peg$FAILED) { + peg$reportedPos = s2; + s3 = peg$c79(s5); + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$c0; + } + } else { + peg$currPos = s2; + s2 = peg$c0; + } + } else { + peg$currPos = s2; + s2 = peg$c0; + } + } else { + peg$currPos = s2; + s2 = peg$c0; + } + } + if (s2 === peg$FAILED) { + s2 = peg$c4; + } + if (s2 !== peg$FAILED) { + s3 = peg$parse_(); + if (s3 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c80(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseTypeList() { + var s0, s1, s2, s3, s4, s5, s6, s7; + + s0 = peg$currPos; + s1 = peg$parseTypeExpression(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 44) { + s5 = peg$c58; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c59); } + } + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseTypeExpression(); + if (s7 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c51(s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 44) { + s5 = peg$c58; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c59); } + } + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseTypeExpression(); + if (s7 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c51(s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } + if (s2 !== peg$FAILED) { + s3 = peg$parse_(); + if (s3 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c81(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parsePrimaryExpression() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = peg$parseLiteral(); + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = peg$c82; + } else { + peg$currPos = s1; + s1 = peg$c0; + } + if (s1 !== peg$FAILED) { + s2 = peg$parseIdentifier(); + if (s2 !== peg$FAILED) { + s3 = peg$parse_(); + if (s3 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c83(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + if (s0 === peg$FAILED) { + s0 = peg$parseLiteral(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 40) { + s1 = peg$c67; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c68); } + } + if (s1 !== peg$FAILED) { + s2 = peg$parse_(); + if (s2 !== peg$FAILED) { + s3 = peg$parseConditionalExpression(); + if (s3 !== peg$FAILED) { + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 41) { + s5 = peg$c69; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c70); } + } + if (s5 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c84(s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } + } + + return s0; + } + + function peg$parseMemberExpression() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + + s0 = peg$currPos; + s1 = peg$parsePrimaryExpression(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 91) { + s5 = peg$c85; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c86); } + } + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseConditionalExpression(); + if (s7 !== peg$FAILED) { + s8 = peg$parse_(); + if (s8 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 93) { + s9 = peg$c87; + peg$currPos++; + } else { + s9 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c88); } + } + if (s9 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c89(s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + if (s3 === peg$FAILED) { + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 46) { + s5 = peg$c90; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c91); } + } + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseIdentifier(); + if (s7 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c89(s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 91) { + s5 = peg$c85; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c86); } + } + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseConditionalExpression(); + if (s7 !== peg$FAILED) { + s8 = peg$parse_(); + if (s8 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 93) { + s9 = peg$c87; + peg$currPos++; + } else { + s9 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c88); } + } + if (s9 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c89(s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + if (s3 === peg$FAILED) { + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 46) { + s5 = peg$c90; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c91); } + } + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseIdentifier(); + if (s7 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c89(s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } + } + if (s2 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c92(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseCallExpression() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$parseMemberExpression(); + if (s2 !== peg$FAILED) { + s3 = peg$parseArguments(); + if (s3 !== peg$FAILED) { + peg$reportedPos = s1; + s2 = peg$c93(s2, s3); + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$c0; + } + } else { + peg$currPos = s1; + s1 = peg$c0; + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + s5 = peg$parseArguments(); + if (s5 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c94(s5); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + if (s3 === peg$FAILED) { + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 91) { + s5 = peg$c85; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c86); } + } + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseConditionalExpression(); + if (s7 !== peg$FAILED) { + s8 = peg$parse_(); + if (s8 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 93) { + s9 = peg$c87; + peg$currPos++; + } else { + s9 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c88); } + } + if (s9 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c95(s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + if (s3 === peg$FAILED) { + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 46) { + s5 = peg$c90; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c91); } + } + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseIdentifier(); + if (s7 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c95(s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + s5 = peg$parseArguments(); + if (s5 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c94(s5); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + if (s3 === peg$FAILED) { + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 91) { + s5 = peg$c85; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c86); } + } + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseConditionalExpression(); + if (s7 !== peg$FAILED) { + s8 = peg$parse_(); + if (s8 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 93) { + s9 = peg$c87; + peg$currPos++; + } else { + s9 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c88); } + } + if (s9 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c95(s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + if (s3 === peg$FAILED) { + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 46) { + s5 = peg$c90; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c91); } + } + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseIdentifier(); + if (s7 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c95(s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } + } + } + if (s2 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c96(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + if (s0 === peg$FAILED) { + s0 = peg$parseMemberExpression(); + } + + return s0; + } + + function peg$parseArguments() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 40) { + s1 = peg$c67; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c68); } + } + if (s1 !== peg$FAILED) { + s2 = peg$parse_(); + if (s2 !== peg$FAILED) { + s3 = peg$parseArgumentList(); + if (s3 === peg$FAILED) { + s3 = peg$c4; + } + if (s3 !== peg$FAILED) { + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 41) { + s5 = peg$c69; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c70); } + } + if (s5 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c97(s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseArgumentList() { + var s0, s1, s2, s3, s4, s5, s6, s7; + + s0 = peg$currPos; + s1 = peg$parseConditionalExpression(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 44) { + s5 = peg$c58; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c59); } + } + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseConditionalExpression(); + if (s7 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c65(s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 44) { + s5 = peg$c58; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c59); } + } + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseConditionalExpression(); + if (s7 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c65(s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } + if (s2 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c98(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseUnaryExpression() { + var s0, s1, s2; + + s0 = peg$parseCallExpression(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseUnaryOperator(); + if (s1 !== peg$FAILED) { + s2 = peg$parseUnaryExpression(); + if (s2 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c99(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } + + return s0; + } + + function peg$parseUnaryOperator() { + var s0, s1; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 43) { + s1 = peg$c100; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c101); } + } + if (s1 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c102(); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 45) { + s1 = peg$c103; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c104); } + } + if (s1 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c105(); + } + s0 = s1; + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 33) { + s0 = peg$c106; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c107); } + } + } + } + + return s0; + } + + function peg$parseMultiplicativeExpression() { + var s0, s1, s2, s3, s4, s5, s6, s7; + + s0 = peg$currPos; + s1 = peg$parseUnaryExpression(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + s5 = peg$parseMultiplicativeOperator(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseUnaryExpression(); + if (s7 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c108(s5, s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + s5 = peg$parseMultiplicativeOperator(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseUnaryExpression(); + if (s7 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c108(s5, s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } + if (s2 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c109(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseMultiplicativeOperator() { + var s0; + + if (input.charCodeAt(peg$currPos) === 42) { + s0 = peg$c34; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c35); } + } + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 47) { + s0 = peg$c28; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c29); } + } + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 37) { + s0 = peg$c110; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c111); } + } + } + } + + return s0; + } + + function peg$parseAdditiveExpression() { + var s0, s1, s2, s3, s4, s5, s6, s7; + + s0 = peg$currPos; + s1 = peg$parseMultiplicativeExpression(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + s5 = peg$parseAdditiveOperator(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseMultiplicativeExpression(); + if (s7 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c108(s5, s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + s5 = peg$parseAdditiveOperator(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseMultiplicativeExpression(); + if (s7 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c108(s5, s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } + if (s2 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c109(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseAdditiveOperator() { + var s0; + + if (input.charCodeAt(peg$currPos) === 43) { + s0 = peg$c100; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c101); } + } + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 45) { + s0 = peg$c103; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c104); } + } + } + + return s0; + } + + function peg$parseRelationalExpression() { + var s0, s1, s2, s3, s4, s5, s6, s7; + + s0 = peg$currPos; + s1 = peg$parseAdditiveExpression(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + s5 = peg$parseRelationalOperator(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseAdditiveExpression(); + if (s7 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c108(s5, s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + s5 = peg$parseRelationalOperator(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseAdditiveExpression(); + if (s7 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c108(s5, s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } + if (s2 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c109(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseRelationalOperator() { + var s0; + + if (input.substr(peg$currPos, 2) === peg$c112) { + s0 = peg$c112; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c113); } + } + if (s0 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c114) { + s0 = peg$c114; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c115); } + } + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 60) { + s0 = peg$c44; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c45); } + } + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 62) { + s0 = peg$c46; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c47); } + } + } + } + } + + return s0; + } + + function peg$parseEqualityExpression() { + var s0, s1, s2, s3, s4, s5, s6, s7; + + s0 = peg$currPos; + s1 = peg$parseRelationalExpression(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + s5 = peg$parseEqualityOperator(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseRelationalExpression(); + if (s7 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c108(s5, s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + s5 = peg$parseEqualityOperator(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseRelationalExpression(); + if (s7 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c108(s5, s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } + if (s2 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c109(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseEqualityOperator() { + var s0, s1; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 3) === peg$c116) { + s1 = peg$c116; + peg$currPos += 3; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c117); } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c118) { + s1 = peg$c118; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c119); } + } + } + if (s1 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c120(); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 61) { + s1 = peg$c32; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c33); } + } + if (s1 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c121(); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.substr(peg$currPos, 3) === peg$c122) { + s1 = peg$c122; + peg$currPos += 3; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c123); } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c124) { + s1 = peg$c124; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c125); } + } + } + if (s1 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c126(); + } + s0 = s1; + } + } + + return s0; + } + + function peg$parseLogicalANDExpression() { + var s0, s1, s2, s3, s4, s5, s6, s7; + + s0 = peg$currPos; + s1 = peg$parseEqualityExpression(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + s5 = peg$parseLogicalANDOperator(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseEqualityExpression(); + if (s7 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c108(s5, s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + s5 = peg$parseLogicalANDOperator(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseEqualityExpression(); + if (s7 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c108(s5, s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } + if (s2 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c109(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseLogicalANDOperator() { + var s0, s1; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c127) { + s1 = peg$c127; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c128); } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 3) === peg$c129) { + s1 = peg$c129; + peg$currPos += 3; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c130); } + } + } + if (s1 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c131(); + } + s0 = s1; + + return s0; + } + + function peg$parseLogicalORExpression() { + var s0, s1, s2, s3, s4, s5, s6, s7; + + s0 = peg$currPos; + s1 = peg$parseLogicalANDExpression(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + s5 = peg$parseLogicalOROperator(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseLogicalANDExpression(); + if (s7 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c108(s5, s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + s5 = peg$parseLogicalOROperator(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + s7 = peg$parseLogicalANDExpression(); + if (s7 !== peg$FAILED) { + peg$reportedPos = s3; + s4 = peg$c108(s5, s7); + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } + if (s2 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c109(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseLogicalOROperator() { + var s0, s1; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c132) { + s1 = peg$c132; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c133); } + } + if (s1 === peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c134) { + s1 = peg$c134; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c135); } + } + } + if (s1 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c136(); + } + s0 = s1; + + return s0; + } + + function peg$parseConditionalExpression() { + var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; + + s0 = peg$currPos; + s1 = peg$parseLogicalORExpression(); + if (s1 !== peg$FAILED) { + s2 = peg$parse_(); + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 63) { + s3 = peg$c137; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c138); } + } + if (s3 !== peg$FAILED) { + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + s5 = peg$parseConditionalExpression(); + if (s5 !== peg$FAILED) { + s6 = peg$parse_(); + if (s6 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 58) { + s7 = peg$c55; + peg$currPos++; + } else { + s7 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c56); } + } + if (s7 !== peg$FAILED) { + s8 = peg$parse_(); + if (s8 !== peg$FAILED) { + s9 = peg$parseConditionalExpression(); + if (s9 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c139(s1, s5, s9); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + if (s0 === peg$FAILED) { + s0 = peg$parseLogicalORExpression(); + } + + return s0; + } + + function peg$parseLiteral() { + var s0; + + s0 = peg$parseNull(); + if (s0 === peg$FAILED) { + s0 = peg$parseBooleanLiteral(); + if (s0 === peg$FAILED) { + s0 = peg$parseNumericLiteral(); + if (s0 === peg$FAILED) { + s0 = peg$parseStringLiteral(); + if (s0 === peg$FAILED) { + s0 = peg$parseArrayLiteral(); + if (s0 === peg$FAILED) { + s0 = peg$parseRegExp(); + } + } + } + } + } + + return s0; + } + + function peg$parseNull() { + var s0, s1; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 4) === peg$c140) { + s1 = peg$c140; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c141); } + } + if (s1 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c142(); + } + s0 = s1; + + return s0; + } + + function peg$parseArrayLiteral() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 91) { + s1 = peg$c85; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c86); } + } + if (s1 !== peg$FAILED) { + s2 = peg$parse_(); + if (s2 !== peg$FAILED) { + s3 = peg$parseArgumentList(); + if (s3 === peg$FAILED) { + s3 = peg$c4; + } + if (s3 !== peg$FAILED) { + s4 = peg$parse_(); + if (s4 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 93) { + s5 = peg$c87; + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c88); } + } + if (s5 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c143(s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseBooleanLiteral() { + var s0, s1; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 4) === peg$c144) { + s1 = peg$c144; + peg$currPos += 4; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c145); } + } + if (s1 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c146(); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.substr(peg$currPos, 5) === peg$c147) { + s1 = peg$c147; + peg$currPos += 5; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c148); } + } + if (s1 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c149(); + } + s0 = s1; + } + + return s0; + } + + function peg$parseNumericLiteral() { + var s0, s1, s2; + + peg$silentFails++; + s0 = peg$currPos; + if (peg$c151.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c152); } + } + if (s1 === peg$FAILED) { + s1 = peg$c4; + } + if (s1 !== peg$FAILED) { + s2 = peg$parseHexIntegerLiteral(); + if (s2 === peg$FAILED) { + s2 = peg$parseDecimalLiteral(); + } + if (s2 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c153(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c150); } + } + + return s0; + } + + function peg$parseDecimalLiteral() { + var s0, s1, s2, s3, s4, s5, s6; + + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$parseDecimalIntegerLiteral(); + if (s3 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 46) { + s4 = peg$c90; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c91); } + } + if (s4 !== peg$FAILED) { + s5 = peg$parseDecimalDigits(); + if (s5 === peg$FAILED) { + s5 = peg$c4; + } + if (s5 !== peg$FAILED) { + s6 = peg$parseExponentPart(); + if (s6 === peg$FAILED) { + s6 = peg$c4; + } + if (s6 !== peg$FAILED) { + s3 = [s3, s4, s5, s6]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$c0; + } + } else { + peg$currPos = s2; + s2 = peg$c0; + } + } else { + peg$currPos = s2; + s2 = peg$c0; + } + } else { + peg$currPos = s2; + s2 = peg$c0; + } + if (s2 !== peg$FAILED) { + s2 = input.substring(s1, peg$currPos); + } + s1 = s2; + if (s1 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c154(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 46) { + s3 = peg$c90; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c91); } + } + if (s3 !== peg$FAILED) { + s4 = peg$parseDecimalDigits(); + if (s4 !== peg$FAILED) { + s5 = peg$parseExponentPart(); + if (s5 === peg$FAILED) { + s5 = peg$c4; + } + if (s5 !== peg$FAILED) { + s3 = [s3, s4, s5]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$c0; + } + } else { + peg$currPos = s2; + s2 = peg$c0; + } + } else { + peg$currPos = s2; + s2 = peg$c0; + } + if (s2 !== peg$FAILED) { + s2 = input.substring(s1, peg$currPos); + } + s1 = s2; + if (s1 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c155(s1); + } + s0 = s1; + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$currPos; + s2 = peg$currPos; + s3 = peg$parseDecimalIntegerLiteral(); + if (s3 !== peg$FAILED) { + s4 = peg$parseExponentPart(); + if (s4 === peg$FAILED) { + s4 = peg$c4; + } + if (s4 !== peg$FAILED) { + s3 = [s3, s4]; + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$c0; + } + } else { + peg$currPos = s2; + s2 = peg$c0; + } + if (s2 !== peg$FAILED) { + s2 = input.substring(s1, peg$currPos); + } + s1 = s2; + if (s1 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c155(s1); + } + s0 = s1; + } + } + + return s0; + } + + function peg$parseDecimalIntegerLiteral() { + var s0, s1, s2; + + if (input.charCodeAt(peg$currPos) === 48) { + s0 = peg$c156; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c157); } + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseNonZeroDigit(); + if (s1 !== peg$FAILED) { + s2 = peg$parseDecimalDigits(); + if (s2 === peg$FAILED) { + s2 = peg$c4; + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } + + return s0; + } + + function peg$parseDecimalDigits() { + var s0, s1; + + s0 = []; + s1 = peg$parseDecimalDigit(); + if (s1 !== peg$FAILED) { + while (s1 !== peg$FAILED) { + s0.push(s1); + s1 = peg$parseDecimalDigit(); + } + } else { + s0 = peg$c0; + } + + return s0; + } + + function peg$parseDecimalDigit() { + var s0; + + if (peg$c158.test(input.charAt(peg$currPos))) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c159); } + } + + return s0; + } + + function peg$parseNonZeroDigit() { + var s0; + + if (peg$c160.test(input.charAt(peg$currPos))) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c161); } + } + + return s0; + } + + function peg$parseExponentPart() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = peg$parseExponentIndicator(); + if (s1 !== peg$FAILED) { + s2 = peg$parseSignedInteger(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseExponentIndicator() { + var s0; + + if (peg$c162.test(input.charAt(peg$currPos))) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c163); } + } + + return s0; + } + + function peg$parseSignedInteger() { + var s0, s1, s2; + + s0 = peg$currPos; + if (peg$c164.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c165); } + } + if (s1 === peg$FAILED) { + s1 = peg$c4; + } + if (s1 !== peg$FAILED) { + s2 = peg$parseDecimalDigits(); + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseHexIntegerLiteral() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 48) { + s1 = peg$c156; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c157); } + } + if (s1 !== peg$FAILED) { + if (peg$c166.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c167); } + } + if (s2 !== peg$FAILED) { + s3 = peg$currPos; + s4 = []; + s5 = peg$parseHexDigit(); + if (s5 !== peg$FAILED) { + while (s5 !== peg$FAILED) { + s4.push(s5); + s5 = peg$parseHexDigit(); + } + } else { + s4 = peg$c0; + } + if (s4 !== peg$FAILED) { + s4 = input.substring(s3, peg$currPos); + } + s3 = s4; + if (s3 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c168(s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseHexDigit() { + var s0; + + if (peg$c169.test(input.charAt(peg$currPos))) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c170); } + } + + return s0; + } + + function peg$parseRegExp() { + var s0, s1, s2, s3, s4, s5; + + peg$silentFails++; + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 47) { + s1 = peg$c28; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c29); } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseRegExpCharacters(); + if (s2 === peg$FAILED) { + s2 = peg$c4; + } + if (s2 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 47) { + s3 = peg$c28; + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c29); } + } + if (s3 !== peg$FAILED) { + s4 = []; + if (peg$c172.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c173); } + } + while (s5 !== peg$FAILED) { + s4.push(s5); + if (peg$c172.test(input.charAt(peg$currPos))) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c173); } + } + } + if (s4 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c174(s2, s4); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c171); } + } + + return s0; + } + + function peg$parseRegExpCharacters() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = []; + if (peg$c175.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c176); } + } + if (s2 === peg$FAILED) { + s2 = peg$parseRegExpEscaped(); + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + if (peg$c175.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c176); } + } + if (s2 === peg$FAILED) { + s2 = peg$parseRegExpEscaped(); + } + } + } else { + s1 = peg$c0; + } + if (s1 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c177(s1); + } + s0 = s1; + + return s0; + } + + function peg$parseRegExpEscaped() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 92) { + s1 = peg$c178; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c179); } + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c180); } + } + if (s2 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c181(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseStringLiteral() { + var s0, s1; + + peg$silentFails++; + s0 = peg$currPos; + s1 = peg$parseString(); + if (s1 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c183(s1); + } + s0 = s1; + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c182); } + } + + return s0; + } + + function peg$parseString() { + var s0, s1, s2, s3, s4; + + s0 = peg$currPos; + s1 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 34) { + s2 = peg$c184; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c185); } + } + if (s2 !== peg$FAILED) { + s3 = peg$parseDoubleStringCharacters(); + if (s3 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 34) { + s4 = peg$c184; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c185); } + } + if (s4 !== peg$FAILED) { + s2 = [s2, s3, s4]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$c0; + } + } else { + peg$currPos = s1; + s1 = peg$c0; + } + } else { + peg$currPos = s1; + s1 = peg$c0; + } + if (s1 === peg$FAILED) { + s1 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 39) { + s2 = peg$c186; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c187); } + } + if (s2 !== peg$FAILED) { + s3 = peg$parseSingleStringCharacters(); + if (s3 !== peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 39) { + s4 = peg$c186; + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c187); } + } + if (s4 !== peg$FAILED) { + s2 = [s2, s3, s4]; + s1 = s2; + } else { + peg$currPos = s1; + s1 = peg$c0; + } + } else { + peg$currPos = s1; + s1 = peg$c0; + } + } else { + peg$currPos = s1; + s1 = peg$c0; + } + } + if (s1 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c188(s1); + } + s0 = s1; + + return s0; + } + + function peg$parseDoubleStringCharacters() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = []; + s2 = peg$parseDoubleStringCharacter(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseDoubleStringCharacter(); + } + if (s1 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c177(s1); + } + s0 = s1; + + return s0; + } + + function peg$parseSingleStringCharacters() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = []; + s2 = peg$parseSingleStringCharacter(); + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseSingleStringCharacter(); + } + if (s1 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c177(s1); + } + s0 = s1; + + return s0; + } + + function peg$parseDoubleStringCharacter() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 34) { + s2 = peg$c184; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c185); } + } + if (s2 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 92) { + s2 = peg$c178; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c179); } + } + if (s2 === peg$FAILED) { + s2 = peg$parseNewLine(); + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = peg$c82; + } else { + peg$currPos = s1; + s1 = peg$c0; + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c180); } + } + if (s2 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c189(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 92) { + s1 = peg$c178; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c179); } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseEscapeSequence(); + if (s2 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c190(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + if (s0 === peg$FAILED) { + s0 = peg$parseLineContinuation(); + } + } + + return s0; + } + + function peg$parseSingleStringCharacter() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + if (input.charCodeAt(peg$currPos) === 39) { + s2 = peg$c186; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c187); } + } + if (s2 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 92) { + s2 = peg$c178; + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c179); } + } + if (s2 === peg$FAILED) { + s2 = peg$parseNewLine(); + } + } + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = peg$c82; + } else { + peg$currPos = s1; + s1 = peg$c0; + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c180); } + } + if (s2 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c189(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 92) { + s1 = peg$c178; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c179); } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseEscapeSequence(); + if (s2 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c190(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + if (s0 === peg$FAILED) { + s0 = peg$parseLineContinuation(); + } + } + + return s0; + } + + function peg$parseLineContinuation() { + var s0, s1, s2; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 92) { + s1 = peg$c178; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c179); } + } + if (s1 !== peg$FAILED) { + s2 = peg$parseNewLine(); + if (s2 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c191(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseEscapeSequence() { + var s0, s1, s2, s3; + + s0 = peg$parseCharacterEscapeSequence(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 48) { + s1 = peg$c156; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c157); } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + peg$silentFails++; + s3 = peg$parseDecimalDigit(); + peg$silentFails--; + if (s3 === peg$FAILED) { + s2 = peg$c82; + } else { + peg$currPos = s2; + s2 = peg$c0; + } + if (s2 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c192(); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + if (s0 === peg$FAILED) { + s0 = peg$parseHexEscapeSequence(); + if (s0 === peg$FAILED) { + s0 = peg$parseUnicodeEscapeSequence(); + } + } + } + + return s0; + } + + function peg$parseCharacterEscapeSequence() { + var s0; + + s0 = peg$parseSingleEscapeCharacter(); + if (s0 === peg$FAILED) { + s0 = peg$parseNonEscapeCharacter(); + } + + return s0; + } + + function peg$parseSingleEscapeCharacter() { + var s0, s1; + + s0 = peg$currPos; + if (peg$c193.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c194); } + } + if (s1 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c195(s1); + } + s0 = s1; + + return s0; + } + + function peg$parseNonEscapeCharacter() { + var s0, s1, s2; + + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = peg$parseEscapeCharacter(); + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = peg$c82; + } else { + peg$currPos = s1; + s1 = peg$c0; + } + if (s1 === peg$FAILED) { + s1 = peg$parseNewLine(); + } + if (s1 !== peg$FAILED) { + if (input.length > peg$currPos) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c180); } + } + if (s2 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c196(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseEscapeCharacter() { + var s0; + + s0 = peg$parseSingleEscapeCharacter(); + if (s0 === peg$FAILED) { + s0 = peg$parseDecimalDigit(); + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 120) { + s0 = peg$c197; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c198); } + } + if (s0 === peg$FAILED) { + if (input.charCodeAt(peg$currPos) === 117) { + s0 = peg$c199; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c200); } + } + } + } + } + + return s0; + } + + function peg$parseHexEscapeSequence() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 120) { + s1 = peg$c197; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c198); } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + s3 = peg$currPos; + s4 = peg$parseHexDigit(); + if (s4 !== peg$FAILED) { + s5 = peg$parseHexDigit(); + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + if (s3 !== peg$FAILED) { + s3 = input.substring(s2, peg$currPos); + } + s2 = s3; + if (s2 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c201(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseUnicodeEscapeSequence() { + var s0, s1, s2, s3, s4, s5, s6, s7; + + s0 = peg$currPos; + if (input.charCodeAt(peg$currPos) === 117) { + s1 = peg$c199; + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c200); } + } + if (s1 !== peg$FAILED) { + s2 = peg$currPos; + s3 = peg$currPos; + s4 = peg$parseHexDigit(); + if (s4 !== peg$FAILED) { + s5 = peg$parseHexDigit(); + if (s5 !== peg$FAILED) { + s6 = peg$parseHexDigit(); + if (s6 !== peg$FAILED) { + s7 = peg$parseHexDigit(); + if (s7 !== peg$FAILED) { + s4 = [s4, s5, s6, s7]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + if (s3 !== peg$FAILED) { + s3 = input.substring(s2, peg$currPos); + } + s2 = s3; + if (s2 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c201(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseIdentifier() { + var s0, s1, s2, s3; + + peg$silentFails++; + s0 = peg$currPos; + if (peg$c203.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c204); } + } + if (s1 !== peg$FAILED) { + s2 = []; + if (peg$c205.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c206); } + } + while (s3 !== peg$FAILED) { + s2.push(s3); + if (peg$c205.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c206); } + } + } + if (s2 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c207(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c202); } + } + + return s0; + } + + function peg$parse__() { + var s0, s1; + + s0 = []; + s1 = peg$parseWhitespace(); + if (s1 === peg$FAILED) { + s1 = peg$parseComment(); + } + if (s1 !== peg$FAILED) { + while (s1 !== peg$FAILED) { + s0.push(s1); + s1 = peg$parseWhitespace(); + if (s1 === peg$FAILED) { + s1 = peg$parseComment(); + } + } + } else { + s0 = peg$c0; + } + + return s0; + } + + function peg$parse_() { + var s0, s1; + + s0 = []; + s1 = peg$parseWhitespace(); + if (s1 === peg$FAILED) { + s1 = peg$parseComment(); + } + while (s1 !== peg$FAILED) { + s0.push(s1); + s1 = peg$parseWhitespace(); + if (s1 === peg$FAILED) { + s1 = peg$parseComment(); + } + } + + return s0; + } + + function peg$parseWhitespace() { + var s0, s1; + + peg$silentFails++; + s0 = []; + if (peg$c209.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c210); } + } + if (s1 !== peg$FAILED) { + while (s1 !== peg$FAILED) { + s0.push(s1); + if (peg$c209.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c210); } + } + } + } else { + s0 = peg$c0; + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c208); } + } + + return s0; + } + + function peg$parseComment() { + var s0, s1; + + peg$silentFails++; + s0 = peg$parseMultiLineComment(); + if (s0 === peg$FAILED) { + s0 = peg$parseSingleLineComment(); + } + peg$silentFails--; + if (s0 === peg$FAILED) { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c211); } + } + + return s0; + } + + function peg$parseMultiLineComment() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c212) { + s1 = peg$c212; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c213); } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + if (input.substr(peg$currPos, 2) === peg$c214) { + s5 = peg$c214; + peg$currPos += 2; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c215); } + } + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = peg$c82; + } else { + peg$currPos = s4; + s4 = peg$c0; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c180); } + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + if (input.substr(peg$currPos, 2) === peg$c214) { + s5 = peg$c214; + peg$currPos += 2; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c215); } + } + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = peg$c82; + } else { + peg$currPos = s4; + s4 = peg$c0; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c180); } + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } + if (s2 !== peg$FAILED) { + if (input.substr(peg$currPos, 2) === peg$c214) { + s3 = peg$c214; + peg$currPos += 2; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c215); } + } + if (s3 !== peg$FAILED) { + s1 = [s1, s2, s3]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseSingleLineComment() { + var s0, s1, s2, s3, s4, s5; + + s0 = peg$currPos; + if (input.substr(peg$currPos, 2) === peg$c216) { + s1 = peg$c216; + peg$currPos += 2; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c217); } + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseNewLine(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = peg$c82; + } else { + peg$currPos = s4; + s4 = peg$c0; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c180); } + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + s4 = peg$currPos; + peg$silentFails++; + s5 = peg$parseNewLine(); + peg$silentFails--; + if (s5 === peg$FAILED) { + s4 = peg$c82; + } else { + peg$currPos = s4; + s4 = peg$c0; + } + if (s4 !== peg$FAILED) { + if (input.length > peg$currPos) { + s5 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s5 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c180); } + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } else { + peg$currPos = s3; + s3 = peg$c0; + } + } + if (s2 !== peg$FAILED) { + s1 = [s1, s2]; + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseAnyBlock() { + var s0, s1, s2, s3, s4; + + s0 = peg$currPos; + s1 = []; + s2 = peg$currPos; + s3 = peg$currPos; + peg$silentFails++; + if (peg$c218.test(input.charAt(peg$currPos))) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c219); } + } + peg$silentFails--; + if (s4 === peg$FAILED) { + s3 = peg$c82; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + if (s3 !== peg$FAILED) { + if (input.length > peg$currPos) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c180); } + } + if (s4 !== peg$FAILED) { + peg$reportedPos = s2; + s3 = peg$c196(s4); + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$c0; + } + } else { + peg$currPos = s2; + s2 = peg$c0; + } + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$currPos; + s3 = peg$currPos; + peg$silentFails++; + if (peg$c218.test(input.charAt(peg$currPos))) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c219); } + } + peg$silentFails--; + if (s4 === peg$FAILED) { + s3 = peg$c82; + } else { + peg$currPos = s3; + s3 = peg$c0; + } + if (s3 !== peg$FAILED) { + if (input.length > peg$currPos) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c180); } + } + if (s4 !== peg$FAILED) { + peg$reportedPos = s2; + s3 = peg$c196(s4); + s2 = s3; + } else { + peg$currPos = s2; + s2 = peg$c0; + } + } else { + peg$currPos = s2; + s2 = peg$c0; + } + } + } else { + s1 = peg$c0; + } + if (s1 !== peg$FAILED) { + if (peg$c218.test(input.charAt(peg$currPos))) { + s2 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s2 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c219); } + } + if (s2 !== peg$FAILED) { + s3 = peg$parse_(); + if (s3 !== peg$FAILED) { + peg$reportedPos = s0; + s1 = peg$c220(s1); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + } else { + peg$currPos = s0; + s0 = peg$c0; + } + + return s0; + } + + function peg$parseNewLine() { + var s0; + + if (peg$c221.test(input.charAt(peg$currPos))) { + s0 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c222); } + } + + return s0; + } + + + "use strict"; + + var ast = require('./ast'); + var util = require('./util'); + var logger = require('./logger'); + var error = logger.error; + var warn = logger.warn; + + logger.setContext(function() { + return { + line: line(), + column: column() + }; + }); + + // Return a left-associative binary structure + // consisting of head (exp), and tail (op, exp)*. + function leftAssociative(head, tail) { + var result = head; + for (var i = 0; i < tail.length; i++) { + result = ast.op(tail[i].op, [result, tail[i].exp]); + } + return result; + } + + var symbols = new ast.Symbols(); + + var currentPath = new ast.PathTemplate(); + + function ensureLowerCase(s, m) { + if (s instanceof Array) { + s = s.map(function(id) { + return ensureLowerCase(id, m); + }); + return s; + } + var canonical = s[0].toLowerCase() + s.slice(1); + if (s != canonical) { + warn(m + " should begin with a lowercase letter: ('" + s + "' should be '" + canonical + "')."); + } + return s; + } + + function ensureUpperCase(s, m) { + if (s instanceof Array) { + s = s.map(function(id) { + return ensureUpperCase(id, m); + }); + return s; + } + var canonical = s[0].toUpperCase() + s.slice(1); + if (s != canonical) { + warn(m + " should begin with an uppercase letter: ('" + s + "' should be '" + canonical + "')."); + } + return s; + } + + + peg$result = peg$startRuleFunction(); + + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail({ type: "end", description: "end of input" }); + } + + throw peg$buildException(null, peg$maxFailExpected, peg$maxFailPos); + } + } + + return { + SyntaxError: SyntaxError, + parse: parse + }; +})(); +},{"./ast":1,"./logger":3,"./util":7}],7:[function(require,module,exports){ +"use strict"; +function extend(dest) { + var srcs = []; + for (var _i = 1; _i < arguments.length; _i++) { + srcs[_i - 1] = arguments[_i]; + } + var i; + var source; + var prop; + if (dest === undefined) { + dest = {}; + } + for (i = 0; i < srcs.length; i++) { + source = srcs[i]; + for (prop in source) { + if (source.hasOwnProperty(prop)) { + dest[prop] = source[prop]; + } + } + } + return dest; +} +exports.extend = extend; +function copyArray(arg) { + return Array.prototype.slice.call(arg); +} +exports.copyArray = copyArray; +var baseTypes = ['number', 'string', 'boolean', 'array', 'function', 'date', + 'regexp', 'arguments', 'undefined', 'null']; +function internalType(value) { + return Object.prototype.toString.call(value).match(/\[object (.*)\]/)[1].toLowerCase(); +} +function isType(value, type) { + return typeOf(value) === type; +} +exports.isType = isType; +// Return one of the baseTypes as a string +function typeOf(value) { + if (value === undefined) { + return 'undefined'; + } + if (value === null) { + return 'null'; + } + var type = internalType(value); + if (!arrayIncludes(baseTypes, type)) { + type = typeof value; + } + return type; +} +exports.typeOf = typeOf; +function isThenable(obj) { + return typeOf(obj) === 'object' && 'then' in obj && typeof (obj.then) === 'function'; +} +exports.isThenable = isThenable; +// Converts a synchronous function to one allowing Promises +// as arguments and returning a Promise value. +// +// fn(U, V, ...): T => fn(U | Promise, V | Promise, ...): Promise +function lift(fn) { + return function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i - 0] = arguments[_i]; + } + return Promise.all(args) + .then(function (values) { + return fn.apply(undefined, values); + }); + }; +} +exports.lift = lift; +// Converts an asynchronous function to one allowing Promises +// as arguments. +// +// fn(U, V, ...): Promise => fn(U | Promise, V | Promise, ...): Promise +exports.liftArgs = lift; +exports.getProp = lift(function (obj, prop) { return obj[prop]; }); +function ensureExtension(fileName, extension) { + if (fileName.indexOf('.') === -1) { + return fileName + '.' + extension; + } + return fileName; +} +exports.ensureExtension = ensureExtension; +function replaceExtension(fileName, extension) { + return fileName.replace(/\.[^\.]*$/, '.' + extension); +} +exports.replaceExtension = replaceExtension; +function prettyJSON(o) { + return JSON.stringify(o, null, 2); +} +exports.prettyJSON = prettyJSON; +function deepExtend(target, source) { + for (var prop in source) { + if (!source.hasOwnProperty(prop)) { + continue; + } + if (target[prop] !== undefined) { + throw new Error("Property overwrite: " + prop); + } + if (isType(source[prop], 'object')) { + target[prop] = {}; + deepExtend(target[prop], source[prop]); + } + else { + target[prop] = source[prop]; + } + } +} +function deepLookup(o, path) { + var result = o; + for (var i = 0; i < path.length; i++) { + if (result === undefined) { + return undefined; + } + result = result[path[i]]; + } + return result; +} +exports.deepLookup = deepLookup; +// Like JSON.stringify - but for single-quoted strings instead of double-quoted ones. +// This just makes the compiled rules much easier to read. +// Quote all control characters, slash, single quotes, and non-ascii printables. +var quotableCharacters = /[\u0000-\u001f\\\'\u007f-\uffff]/g; +var specialQuotes = { + '\'': '\\\'', + '\b': '\\b', + '\t': '\\t', + '\n': '\\n', + '\f': '\\f', + '\r': '\\r' +}; +function quoteString(s) { + s = s.replace(quotableCharacters, function (c) { + if (specialQuotes[c]) { + return specialQuotes[c]; + } + return '\\u' + ('0000' + c.charCodeAt(0).toString(16)).slice(-4); + }); + return "'" + s + "'"; +} +exports.quoteString = quoteString; +function arrayIncludes(a, e) { + return a.indexOf(e) !== -1; +} +exports.arrayIncludes = arrayIncludes; +// Like Python list.extend +function extendArray(target, src) { + if (target === undefined) { + target = []; + } + Array.prototype.push.apply(target, src); + return target; +} +exports.extendArray = extendArray; +function or(target, src) { + if (target === undefined) { + return false; + } + return target || src; +} +exports.or = or; +function ensureObjectPath(obj, parts) { + for (var i = 0; i < parts.length; i++) { + var name = parts[i]; + if (!(name in obj)) { + obj[name] = {}; + } + obj = obj[name]; + } + return obj; +} +exports.ensureObjectPath = ensureObjectPath; +// Remove all empty, '{}', children and undefined - returns true iff obj is empty. +function pruneEmptyChildren(obj) { + if (obj === undefined) { + return true; + } + if (obj.constructor !== Object) { + return false; + } + var hasChildren = false; + for (var prop in obj) { + if (!obj.hasOwnProperty(prop)) { + continue; + } + if (pruneEmptyChildren(obj[prop])) { + delete obj[prop]; + } + else { + hasChildren = true; + } + } + return !hasChildren; +} +exports.pruneEmptyChildren = pruneEmptyChildren; +function deletePropName(obj, name) { + if (obj.constructor !== Object) { + return; + } + for (var prop in obj) { + if (!obj.hasOwnProperty(prop)) { + continue; + } + if (prop === name) { + delete obj[prop]; + } + else { + deletePropName(obj[prop], name); + } + } +} +exports.deletePropName = deletePropName; +function formatColumns(indent, lines) { + var result = []; + var columnSize = []; + for (var i = 0; i < lines.length; i++) { + var line = lines[i]; + for (var j = 0; j < line.length; j++) { + if (columnSize[j] === undefined) { + columnSize[j] = 0; + } + columnSize[j] = Math.max(columnSize[j], line[j].length); + } + } + var prefix = repeatString(' ', indent); + var s; + for (var i = 0; i < lines.length; i++) { + var line = lines[i]; + var sep = ""; + s = ""; + for (var j = 0; j < line.length; j++) { + if (j === 0) { + s = prefix; + } + if (j === line.length - 1) { + s += sep + line[j]; + } + else { + s += sep + fillString(line[j], columnSize[j]); + } + sep = " "; + } + result.push(s); + } + return result; +} +exports.formatColumns = formatColumns; +function repeatString(s, n) { + return new Array(n + 1).join(s); +} +function fillString(s, n) { + var padding = n - s.length; + if (padding > 0) { + s += repeatString(' ', padding); + } + return s; +} + + +},{}],8:[function(require,module,exports){ +// shim for using process in browser +var process = module.exports = {}; + +// cached from whatever global is present so that test runners that stub it +// don't break things. But we need to wrap it in a try catch in case it is +// wrapped in strict mode code which doesn't define any globals. It's inside a +// function because try/catches deoptimize in certain engines. + +var cachedSetTimeout; +var cachedClearTimeout; + +(function () { + try { + cachedSetTimeout = setTimeout; + } catch (e) { + cachedSetTimeout = function () { + throw new Error('setTimeout is not defined'); + } + } + try { + cachedClearTimeout = clearTimeout; + } catch (e) { + cachedClearTimeout = function () { + throw new Error('clearTimeout is not defined'); + } + } +} ()) +function runTimeout(fun) { + if (cachedSetTimeout === setTimeout) { + return setTimeout(fun, 0); + } else { + return cachedSetTimeout.call(null, fun, 0); + } +} +function runClearTimeout(marker) { + if (cachedClearTimeout === clearTimeout) { + clearTimeout(marker); + } else { + cachedClearTimeout.call(null, marker); + } +} +var queue = []; +var draining = false; +var currentQueue; +var queueIndex = -1; + +function cleanUpNextTick() { + if (!draining || !currentQueue) { + return; + } + draining = false; + if (currentQueue.length) { + queue = currentQueue.concat(queue); + } else { + queueIndex = -1; + } + if (queue.length) { + drainQueue(); + } +} + +function drainQueue() { + if (draining) { + return; + } + var timeout = runTimeout(cleanUpNextTick); + draining = true; + + var len = queue.length; + while(len) { + currentQueue = queue; + queue = []; + while (++queueIndex < len) { + if (currentQueue) { + currentQueue[queueIndex].run(); + } + } + queueIndex = -1; + len = queue.length; + } + currentQueue = null; + draining = false; + runClearTimeout(timeout); +} + +process.nextTick = function (fun) { + var args = new Array(arguments.length - 1); + if (arguments.length > 1) { + for (var i = 1; i < arguments.length; i++) { + args[i - 1] = arguments[i]; + } + } + queue.push(new Item(fun, args)); + if (queue.length === 1 && !draining) { + runTimeout(drainQueue); + } +}; + +// v8 likes predictible objects +function Item(fun, array) { + this.fun = fun; + this.array = array; +} +Item.prototype.run = function () { + this.fun.apply(null, this.array); +}; +process.title = 'browser'; +process.browser = true; +process.env = {}; +process.argv = []; +process.version = ''; // empty string to avoid regexp issues +process.versions = {}; + +function noop() {} + +process.on = noop; +process.addListener = noop; +process.once = noop; +process.off = noop; +process.removeListener = noop; +process.removeAllListeners = noop; +process.emit = noop; + +process.binding = function (name) { + throw new Error('process.binding is not supported'); +}; + +process.cwd = function () { return '/' }; +process.chdir = function (dir) { + throw new Error('process.chdir is not supported'); +}; +process.umask = function() { return 0; }; + +},{}],9:[function(require,module,exports){ +(function (process,global){ +/*! + * @overview es6-promise - a tiny implementation of Promises/A+. + * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald) + * @license Licensed under MIT license + * See https://raw.githubusercontent.com/jakearchibald/es6-promise/master/LICENSE + * @version 3.2.1 + */ + +(function() { + "use strict"; + function lib$es6$promise$utils$$objectOrFunction(x) { + return typeof x === 'function' || (typeof x === 'object' && x !== null); + } + + function lib$es6$promise$utils$$isFunction(x) { + return typeof x === 'function'; + } + + function lib$es6$promise$utils$$isMaybeThenable(x) { + return typeof x === 'object' && x !== null; + } + + var lib$es6$promise$utils$$_isArray; + if (!Array.isArray) { + lib$es6$promise$utils$$_isArray = function (x) { + return Object.prototype.toString.call(x) === '[object Array]'; + }; + } else { + lib$es6$promise$utils$$_isArray = Array.isArray; + } + + var lib$es6$promise$utils$$isArray = lib$es6$promise$utils$$_isArray; + var lib$es6$promise$asap$$len = 0; + var lib$es6$promise$asap$$vertxNext; + var lib$es6$promise$asap$$customSchedulerFn; + + var lib$es6$promise$asap$$asap = function asap(callback, arg) { + lib$es6$promise$asap$$queue[lib$es6$promise$asap$$len] = callback; + lib$es6$promise$asap$$queue[lib$es6$promise$asap$$len + 1] = arg; + lib$es6$promise$asap$$len += 2; + if (lib$es6$promise$asap$$len === 2) { + // If len is 2, that means that we need to schedule an async flush. + // If additional callbacks are queued before the queue is flushed, they + // will be processed by this flush that we are scheduling. + if (lib$es6$promise$asap$$customSchedulerFn) { + lib$es6$promise$asap$$customSchedulerFn(lib$es6$promise$asap$$flush); + } else { + lib$es6$promise$asap$$scheduleFlush(); + } + } + } + + function lib$es6$promise$asap$$setScheduler(scheduleFn) { + lib$es6$promise$asap$$customSchedulerFn = scheduleFn; + } + + function lib$es6$promise$asap$$setAsap(asapFn) { + lib$es6$promise$asap$$asap = asapFn; + } + + var lib$es6$promise$asap$$browserWindow = (typeof window !== 'undefined') ? window : undefined; + var lib$es6$promise$asap$$browserGlobal = lib$es6$promise$asap$$browserWindow || {}; + var lib$es6$promise$asap$$BrowserMutationObserver = lib$es6$promise$asap$$browserGlobal.MutationObserver || lib$es6$promise$asap$$browserGlobal.WebKitMutationObserver; + var lib$es6$promise$asap$$isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]'; + + // test for web worker but not in IE10 + var lib$es6$promise$asap$$isWorker = typeof Uint8ClampedArray !== 'undefined' && + typeof importScripts !== 'undefined' && + typeof MessageChannel !== 'undefined'; + + // node + function lib$es6$promise$asap$$useNextTick() { + // node version 0.10.x displays a deprecation warning when nextTick is used recursively + // see https://github.com/cujojs/when/issues/410 for details + return function() { + process.nextTick(lib$es6$promise$asap$$flush); + }; + } + + // vertx + function lib$es6$promise$asap$$useVertxTimer() { + return function() { + lib$es6$promise$asap$$vertxNext(lib$es6$promise$asap$$flush); + }; + } + + function lib$es6$promise$asap$$useMutationObserver() { + var iterations = 0; + var observer = new lib$es6$promise$asap$$BrowserMutationObserver(lib$es6$promise$asap$$flush); + var node = document.createTextNode(''); + observer.observe(node, { characterData: true }); + + return function() { + node.data = (iterations = ++iterations % 2); + }; + } + + // web worker + function lib$es6$promise$asap$$useMessageChannel() { + var channel = new MessageChannel(); + channel.port1.onmessage = lib$es6$promise$asap$$flush; + return function () { + channel.port2.postMessage(0); + }; + } + + function lib$es6$promise$asap$$useSetTimeout() { + return function() { + setTimeout(lib$es6$promise$asap$$flush, 1); + }; + } + + var lib$es6$promise$asap$$queue = new Array(1000); + function lib$es6$promise$asap$$flush() { + for (var i = 0; i < lib$es6$promise$asap$$len; i+=2) { + var callback = lib$es6$promise$asap$$queue[i]; + var arg = lib$es6$promise$asap$$queue[i+1]; + + callback(arg); + + lib$es6$promise$asap$$queue[i] = undefined; + lib$es6$promise$asap$$queue[i+1] = undefined; + } + + lib$es6$promise$asap$$len = 0; + } + + function lib$es6$promise$asap$$attemptVertx() { + try { + var r = require; + var vertx = r('vertx'); + lib$es6$promise$asap$$vertxNext = vertx.runOnLoop || vertx.runOnContext; + return lib$es6$promise$asap$$useVertxTimer(); + } catch(e) { + return lib$es6$promise$asap$$useSetTimeout(); + } + } + + var lib$es6$promise$asap$$scheduleFlush; + // Decide what async method to use to triggering processing of queued callbacks: + if (lib$es6$promise$asap$$isNode) { + lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useNextTick(); + } else if (lib$es6$promise$asap$$BrowserMutationObserver) { + lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useMutationObserver(); + } else if (lib$es6$promise$asap$$isWorker) { + lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useMessageChannel(); + } else if (lib$es6$promise$asap$$browserWindow === undefined && typeof require === 'function') { + lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$attemptVertx(); + } else { + lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useSetTimeout(); + } + function lib$es6$promise$then$$then(onFulfillment, onRejection) { + var parent = this; + + var child = new this.constructor(lib$es6$promise$$internal$$noop); + + if (child[lib$es6$promise$$internal$$PROMISE_ID] === undefined) { + lib$es6$promise$$internal$$makePromise(child); + } + + var state = parent._state; + + if (state) { + var callback = arguments[state - 1]; + lib$es6$promise$asap$$asap(function(){ + lib$es6$promise$$internal$$invokeCallback(state, child, callback, parent._result); + }); + } else { + lib$es6$promise$$internal$$subscribe(parent, child, onFulfillment, onRejection); + } + + return child; + } + var lib$es6$promise$then$$default = lib$es6$promise$then$$then; + function lib$es6$promise$promise$resolve$$resolve(object) { + /*jshint validthis:true */ + var Constructor = this; + + if (object && typeof object === 'object' && object.constructor === Constructor) { + return object; + } + + var promise = new Constructor(lib$es6$promise$$internal$$noop); + lib$es6$promise$$internal$$resolve(promise, object); + return promise; + } + var lib$es6$promise$promise$resolve$$default = lib$es6$promise$promise$resolve$$resolve; + var lib$es6$promise$$internal$$PROMISE_ID = Math.random().toString(36).substring(16); + + function lib$es6$promise$$internal$$noop() {} + + var lib$es6$promise$$internal$$PENDING = void 0; + var lib$es6$promise$$internal$$FULFILLED = 1; + var lib$es6$promise$$internal$$REJECTED = 2; + + var lib$es6$promise$$internal$$GET_THEN_ERROR = new lib$es6$promise$$internal$$ErrorObject(); + + function lib$es6$promise$$internal$$selfFulfillment() { + return new TypeError("You cannot resolve a promise with itself"); + } + + function lib$es6$promise$$internal$$cannotReturnOwn() { + return new TypeError('A promises callback cannot return that same promise.'); + } + + function lib$es6$promise$$internal$$getThen(promise) { + try { + return promise.then; + } catch(error) { + lib$es6$promise$$internal$$GET_THEN_ERROR.error = error; + return lib$es6$promise$$internal$$GET_THEN_ERROR; + } + } + + function lib$es6$promise$$internal$$tryThen(then, value, fulfillmentHandler, rejectionHandler) { + try { + then.call(value, fulfillmentHandler, rejectionHandler); + } catch(e) { + return e; + } + } + + function lib$es6$promise$$internal$$handleForeignThenable(promise, thenable, then) { + lib$es6$promise$asap$$asap(function(promise) { + var sealed = false; + var error = lib$es6$promise$$internal$$tryThen(then, thenable, function(value) { + if (sealed) { return; } + sealed = true; + if (thenable !== value) { + lib$es6$promise$$internal$$resolve(promise, value); + } else { + lib$es6$promise$$internal$$fulfill(promise, value); + } + }, function(reason) { + if (sealed) { return; } + sealed = true; + + lib$es6$promise$$internal$$reject(promise, reason); + }, 'Settle: ' + (promise._label || ' unknown promise')); + + if (!sealed && error) { + sealed = true; + lib$es6$promise$$internal$$reject(promise, error); + } + }, promise); + } + + function lib$es6$promise$$internal$$handleOwnThenable(promise, thenable) { + if (thenable._state === lib$es6$promise$$internal$$FULFILLED) { + lib$es6$promise$$internal$$fulfill(promise, thenable._result); + } else if (thenable._state === lib$es6$promise$$internal$$REJECTED) { + lib$es6$promise$$internal$$reject(promise, thenable._result); + } else { + lib$es6$promise$$internal$$subscribe(thenable, undefined, function(value) { + lib$es6$promise$$internal$$resolve(promise, value); + }, function(reason) { + lib$es6$promise$$internal$$reject(promise, reason); + }); + } + } + + function lib$es6$promise$$internal$$handleMaybeThenable(promise, maybeThenable, then) { + if (maybeThenable.constructor === promise.constructor && + then === lib$es6$promise$then$$default && + constructor.resolve === lib$es6$promise$promise$resolve$$default) { + lib$es6$promise$$internal$$handleOwnThenable(promise, maybeThenable); + } else { + if (then === lib$es6$promise$$internal$$GET_THEN_ERROR) { + lib$es6$promise$$internal$$reject(promise, lib$es6$promise$$internal$$GET_THEN_ERROR.error); + } else if (then === undefined) { + lib$es6$promise$$internal$$fulfill(promise, maybeThenable); + } else if (lib$es6$promise$utils$$isFunction(then)) { + lib$es6$promise$$internal$$handleForeignThenable(promise, maybeThenable, then); + } else { + lib$es6$promise$$internal$$fulfill(promise, maybeThenable); + } + } + } + + function lib$es6$promise$$internal$$resolve(promise, value) { + if (promise === value) { + lib$es6$promise$$internal$$reject(promise, lib$es6$promise$$internal$$selfFulfillment()); + } else if (lib$es6$promise$utils$$objectOrFunction(value)) { + lib$es6$promise$$internal$$handleMaybeThenable(promise, value, lib$es6$promise$$internal$$getThen(value)); + } else { + lib$es6$promise$$internal$$fulfill(promise, value); + } + } + + function lib$es6$promise$$internal$$publishRejection(promise) { + if (promise._onerror) { + promise._onerror(promise._result); + } + + lib$es6$promise$$internal$$publish(promise); + } + + function lib$es6$promise$$internal$$fulfill(promise, value) { + if (promise._state !== lib$es6$promise$$internal$$PENDING) { return; } + + promise._result = value; + promise._state = lib$es6$promise$$internal$$FULFILLED; + + if (promise._subscribers.length !== 0) { + lib$es6$promise$asap$$asap(lib$es6$promise$$internal$$publish, promise); + } + } + + function lib$es6$promise$$internal$$reject(promise, reason) { + if (promise._state !== lib$es6$promise$$internal$$PENDING) { return; } + promise._state = lib$es6$promise$$internal$$REJECTED; + promise._result = reason; + + lib$es6$promise$asap$$asap(lib$es6$promise$$internal$$publishRejection, promise); + } + + function lib$es6$promise$$internal$$subscribe(parent, child, onFulfillment, onRejection) { + var subscribers = parent._subscribers; + var length = subscribers.length; + + parent._onerror = null; + + subscribers[length] = child; + subscribers[length + lib$es6$promise$$internal$$FULFILLED] = onFulfillment; + subscribers[length + lib$es6$promise$$internal$$REJECTED] = onRejection; + + if (length === 0 && parent._state) { + lib$es6$promise$asap$$asap(lib$es6$promise$$internal$$publish, parent); + } + } + + function lib$es6$promise$$internal$$publish(promise) { + var subscribers = promise._subscribers; + var settled = promise._state; + + if (subscribers.length === 0) { return; } + + var child, callback, detail = promise._result; + + for (var i = 0; i < subscribers.length; i += 3) { + child = subscribers[i]; + callback = subscribers[i + settled]; + + if (child) { + lib$es6$promise$$internal$$invokeCallback(settled, child, callback, detail); + } else { + callback(detail); + } + } + + promise._subscribers.length = 0; + } + + function lib$es6$promise$$internal$$ErrorObject() { + this.error = null; + } + + var lib$es6$promise$$internal$$TRY_CATCH_ERROR = new lib$es6$promise$$internal$$ErrorObject(); + + function lib$es6$promise$$internal$$tryCatch(callback, detail) { + try { + return callback(detail); + } catch(e) { + lib$es6$promise$$internal$$TRY_CATCH_ERROR.error = e; + return lib$es6$promise$$internal$$TRY_CATCH_ERROR; + } + } + + function lib$es6$promise$$internal$$invokeCallback(settled, promise, callback, detail) { + var hasCallback = lib$es6$promise$utils$$isFunction(callback), + value, error, succeeded, failed; + + if (hasCallback) { + value = lib$es6$promise$$internal$$tryCatch(callback, detail); + + if (value === lib$es6$promise$$internal$$TRY_CATCH_ERROR) { + failed = true; + error = value.error; + value = null; + } else { + succeeded = true; + } + + if (promise === value) { + lib$es6$promise$$internal$$reject(promise, lib$es6$promise$$internal$$cannotReturnOwn()); + return; + } + + } else { + value = detail; + succeeded = true; + } + + if (promise._state !== lib$es6$promise$$internal$$PENDING) { + // noop + } else if (hasCallback && succeeded) { + lib$es6$promise$$internal$$resolve(promise, value); + } else if (failed) { + lib$es6$promise$$internal$$reject(promise, error); + } else if (settled === lib$es6$promise$$internal$$FULFILLED) { + lib$es6$promise$$internal$$fulfill(promise, value); + } else if (settled === lib$es6$promise$$internal$$REJECTED) { + lib$es6$promise$$internal$$reject(promise, value); + } + } + + function lib$es6$promise$$internal$$initializePromise(promise, resolver) { + try { + resolver(function resolvePromise(value){ + lib$es6$promise$$internal$$resolve(promise, value); + }, function rejectPromise(reason) { + lib$es6$promise$$internal$$reject(promise, reason); + }); + } catch(e) { + lib$es6$promise$$internal$$reject(promise, e); + } + } + + var lib$es6$promise$$internal$$id = 0; + function lib$es6$promise$$internal$$nextId() { + return lib$es6$promise$$internal$$id++; + } + + function lib$es6$promise$$internal$$makePromise(promise) { + promise[lib$es6$promise$$internal$$PROMISE_ID] = lib$es6$promise$$internal$$id++; + promise._state = undefined; + promise._result = undefined; + promise._subscribers = []; + } + + function lib$es6$promise$promise$all$$all(entries) { + return new lib$es6$promise$enumerator$$default(this, entries).promise; + } + var lib$es6$promise$promise$all$$default = lib$es6$promise$promise$all$$all; + function lib$es6$promise$promise$race$$race(entries) { + /*jshint validthis:true */ + var Constructor = this; + + if (!lib$es6$promise$utils$$isArray(entries)) { + return new Constructor(function(resolve, reject) { + reject(new TypeError('You must pass an array to race.')); + }); + } else { + return new Constructor(function(resolve, reject) { + var length = entries.length; + for (var i = 0; i < length; i++) { + Constructor.resolve(entries[i]).then(resolve, reject); + } + }); + } + } + var lib$es6$promise$promise$race$$default = lib$es6$promise$promise$race$$race; + function lib$es6$promise$promise$reject$$reject(reason) { + /*jshint validthis:true */ + var Constructor = this; + var promise = new Constructor(lib$es6$promise$$internal$$noop); + lib$es6$promise$$internal$$reject(promise, reason); + return promise; + } + var lib$es6$promise$promise$reject$$default = lib$es6$promise$promise$reject$$reject; + + + function lib$es6$promise$promise$$needsResolver() { + throw new TypeError('You must pass a resolver function as the first argument to the promise constructor'); + } + + function lib$es6$promise$promise$$needsNew() { + throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function."); + } + + var lib$es6$promise$promise$$default = lib$es6$promise$promise$$Promise; + /** + Promise objects represent the eventual result of an asynchronous operation. The + primary way of interacting with a promise is through its `then` method, which + registers callbacks to receive either a promise's eventual value or the reason + why the promise cannot be fulfilled. + + Terminology + ----------- + + - `promise` is an object or function with a `then` method whose behavior conforms to this specification. + - `thenable` is an object or function that defines a `then` method. + - `value` is any legal JavaScript value (including undefined, a thenable, or a promise). + - `exception` is a value that is thrown using the throw statement. + - `reason` is a value that indicates why a promise was rejected. + - `settled` the final resting state of a promise, fulfilled or rejected. + + A promise can be in one of three states: pending, fulfilled, or rejected. + + Promises that are fulfilled have a fulfillment value and are in the fulfilled + state. Promises that are rejected have a rejection reason and are in the + rejected state. A fulfillment value is never a thenable. + + Promises can also be said to *resolve* a value. If this value is also a + promise, then the original promise's settled state will match the value's + settled state. So a promise that *resolves* a promise that rejects will + itself reject, and a promise that *resolves* a promise that fulfills will + itself fulfill. + + + Basic Usage: + ------------ + + ```js + var promise = new Promise(function(resolve, reject) { + // on success + resolve(value); + + // on failure + reject(reason); + }); + + promise.then(function(value) { + // on fulfillment + }, function(reason) { + // on rejection + }); + ``` + + Advanced Usage: + --------------- + + Promises shine when abstracting away asynchronous interactions such as + `XMLHttpRequest`s. + + ```js + function getJSON(url) { + return new Promise(function(resolve, reject){ + var xhr = new XMLHttpRequest(); + + xhr.open('GET', url); + xhr.onreadystatechange = handler; + xhr.responseType = 'json'; + xhr.setRequestHeader('Accept', 'application/json'); + xhr.send(); + + function handler() { + if (this.readyState === this.DONE) { + if (this.status === 200) { + resolve(this.response); + } else { + reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']')); + } + } + }; + }); + } + + getJSON('/posts.json').then(function(json) { + // on fulfillment + }, function(reason) { + // on rejection + }); + ``` + + Unlike callbacks, promises are great composable primitives. + + ```js + Promise.all([ + getJSON('/posts'), + getJSON('/comments') + ]).then(function(values){ + values[0] // => postsJSON + values[1] // => commentsJSON + + return values; + }); + ``` + + @class Promise + @param {function} resolver + Useful for tooling. + @constructor + */ + function lib$es6$promise$promise$$Promise(resolver) { + this[lib$es6$promise$$internal$$PROMISE_ID] = lib$es6$promise$$internal$$nextId(); + this._result = this._state = undefined; + this._subscribers = []; + + if (lib$es6$promise$$internal$$noop !== resolver) { + typeof resolver !== 'function' && lib$es6$promise$promise$$needsResolver(); + this instanceof lib$es6$promise$promise$$Promise ? lib$es6$promise$$internal$$initializePromise(this, resolver) : lib$es6$promise$promise$$needsNew(); + } + } + + lib$es6$promise$promise$$Promise.all = lib$es6$promise$promise$all$$default; + lib$es6$promise$promise$$Promise.race = lib$es6$promise$promise$race$$default; + lib$es6$promise$promise$$Promise.resolve = lib$es6$promise$promise$resolve$$default; + lib$es6$promise$promise$$Promise.reject = lib$es6$promise$promise$reject$$default; + lib$es6$promise$promise$$Promise._setScheduler = lib$es6$promise$asap$$setScheduler; + lib$es6$promise$promise$$Promise._setAsap = lib$es6$promise$asap$$setAsap; + lib$es6$promise$promise$$Promise._asap = lib$es6$promise$asap$$asap; + + lib$es6$promise$promise$$Promise.prototype = { + constructor: lib$es6$promise$promise$$Promise, + + /** + The primary way of interacting with a promise is through its `then` method, + which registers callbacks to receive either a promise's eventual value or the + reason why the promise cannot be fulfilled. + + ```js + findUser().then(function(user){ + // user is available + }, function(reason){ + // user is unavailable, and you are given the reason why + }); + ``` + + Chaining + -------- + + The return value of `then` is itself a promise. This second, 'downstream' + promise is resolved with the return value of the first promise's fulfillment + or rejection handler, or rejected if the handler throws an exception. + + ```js + findUser().then(function (user) { + return user.name; + }, function (reason) { + return 'default name'; + }).then(function (userName) { + // If `findUser` fulfilled, `userName` will be the user's name, otherwise it + // will be `'default name'` + }); + + findUser().then(function (user) { + throw new Error('Found user, but still unhappy'); + }, function (reason) { + throw new Error('`findUser` rejected and we're unhappy'); + }).then(function (value) { + // never reached + }, function (reason) { + // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'. + // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'. + }); + ``` + If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream. + + ```js + findUser().then(function (user) { + throw new PedagogicalException('Upstream error'); + }).then(function (value) { + // never reached + }).then(function (value) { + // never reached + }, function (reason) { + // The `PedgagocialException` is propagated all the way down to here + }); + ``` + + Assimilation + ------------ + + Sometimes the value you want to propagate to a downstream promise can only be + retrieved asynchronously. This can be achieved by returning a promise in the + fulfillment or rejection handler. The downstream promise will then be pending + until the returned promise is settled. This is called *assimilation*. + + ```js + findUser().then(function (user) { + return findCommentsByAuthor(user); + }).then(function (comments) { + // The user's comments are now available + }); + ``` + + If the assimliated promise rejects, then the downstream promise will also reject. + + ```js + findUser().then(function (user) { + return findCommentsByAuthor(user); + }).then(function (comments) { + // If `findCommentsByAuthor` fulfills, we'll have the value here + }, function (reason) { + // If `findCommentsByAuthor` rejects, we'll have the reason here + }); + ``` + + Simple Example + -------------- + + Synchronous Example + + ```javascript + var result; + + try { + result = findResult(); + // success + } catch(reason) { + // failure + } + ``` + + Errback Example + + ```js + findResult(function(result, err){ + if (err) { + // failure + } else { + // success + } + }); + ``` + + Promise Example; + + ```javascript + findResult().then(function(result){ + // success + }, function(reason){ + // failure + }); + ``` + + Advanced Example + -------------- + + Synchronous Example + + ```javascript + var author, books; + + try { + author = findAuthor(); + books = findBooksByAuthor(author); + // success + } catch(reason) { + // failure + } + ``` + + Errback Example + + ```js + + function foundBooks(books) { + + } + + function failure(reason) { + + } + + findAuthor(function(author, err){ + if (err) { + failure(err); + // failure + } else { + try { + findBoooksByAuthor(author, function(books, err) { + if (err) { + failure(err); + } else { + try { + foundBooks(books); + } catch(reason) { + failure(reason); + } + } + }); + } catch(error) { + failure(err); + } + // success + } + }); + ``` + + Promise Example; + + ```javascript + findAuthor(). + then(findBooksByAuthor). + then(function(books){ + // found books + }).catch(function(reason){ + // something went wrong + }); + ``` + + @method then + @param {Function} onFulfilled + @param {Function} onRejected + Useful for tooling. + @return {Promise} + */ + then: lib$es6$promise$then$$default, + + /** + `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same + as the catch block of a try/catch statement. + + ```js + function findAuthor(){ + throw new Error('couldn't find that author'); + } + + // synchronous + try { + findAuthor(); + } catch(reason) { + // something went wrong + } + + // async with promises + findAuthor().catch(function(reason){ + // something went wrong + }); + ``` + + @method catch + @param {Function} onRejection + Useful for tooling. + @return {Promise} + */ + 'catch': function(onRejection) { + return this.then(null, onRejection); + } + }; + var lib$es6$promise$enumerator$$default = lib$es6$promise$enumerator$$Enumerator; + function lib$es6$promise$enumerator$$Enumerator(Constructor, input) { + this._instanceConstructor = Constructor; + this.promise = new Constructor(lib$es6$promise$$internal$$noop); + + if (!this.promise[lib$es6$promise$$internal$$PROMISE_ID]) { + lib$es6$promise$$internal$$makePromise(this.promise); + } + + if (lib$es6$promise$utils$$isArray(input)) { + this._input = input; + this.length = input.length; + this._remaining = input.length; + + this._result = new Array(this.length); + + if (this.length === 0) { + lib$es6$promise$$internal$$fulfill(this.promise, this._result); + } else { + this.length = this.length || 0; + this._enumerate(); + if (this._remaining === 0) { + lib$es6$promise$$internal$$fulfill(this.promise, this._result); + } + } + } else { + lib$es6$promise$$internal$$reject(this.promise, lib$es6$promise$enumerator$$validationError()); + } + } + + function lib$es6$promise$enumerator$$validationError() { + return new Error('Array Methods must be provided an Array'); + } + + lib$es6$promise$enumerator$$Enumerator.prototype._enumerate = function() { + var length = this.length; + var input = this._input; + + for (var i = 0; this._state === lib$es6$promise$$internal$$PENDING && i < length; i++) { + this._eachEntry(input[i], i); + } + }; + + lib$es6$promise$enumerator$$Enumerator.prototype._eachEntry = function(entry, i) { + var c = this._instanceConstructor; + var resolve = c.resolve; + + if (resolve === lib$es6$promise$promise$resolve$$default) { + var then = lib$es6$promise$$internal$$getThen(entry); + + if (then === lib$es6$promise$then$$default && + entry._state !== lib$es6$promise$$internal$$PENDING) { + this._settledAt(entry._state, i, entry._result); + } else if (typeof then !== 'function') { + this._remaining--; + this._result[i] = entry; + } else if (c === lib$es6$promise$promise$$default) { + var promise = new c(lib$es6$promise$$internal$$noop); + lib$es6$promise$$internal$$handleMaybeThenable(promise, entry, then); + this._willSettleAt(promise, i); + } else { + this._willSettleAt(new c(function(resolve) { resolve(entry); }), i); + } + } else { + this._willSettleAt(resolve(entry), i); + } + }; + + lib$es6$promise$enumerator$$Enumerator.prototype._settledAt = function(state, i, value) { + var promise = this.promise; + + if (promise._state === lib$es6$promise$$internal$$PENDING) { + this._remaining--; + + if (state === lib$es6$promise$$internal$$REJECTED) { + lib$es6$promise$$internal$$reject(promise, value); + } else { + this._result[i] = value; + } + } + + if (this._remaining === 0) { + lib$es6$promise$$internal$$fulfill(promise, this._result); + } + }; + + lib$es6$promise$enumerator$$Enumerator.prototype._willSettleAt = function(promise, i) { + var enumerator = this; + + lib$es6$promise$$internal$$subscribe(promise, undefined, function(value) { + enumerator._settledAt(lib$es6$promise$$internal$$FULFILLED, i, value); + }, function(reason) { + enumerator._settledAt(lib$es6$promise$$internal$$REJECTED, i, reason); + }); + }; + function lib$es6$promise$polyfill$$polyfill() { + var local; + + if (typeof global !== 'undefined') { + local = global; + } else if (typeof self !== 'undefined') { + local = self; + } else { + try { + local = Function('return this')(); + } catch (e) { + throw new Error('polyfill failed because global object is unavailable in this environment'); + } + } + + var P = local.Promise; + + if (P && Object.prototype.toString.call(P.resolve()) === '[object Promise]' && !P.cast) { + return; + } + + local.Promise = lib$es6$promise$promise$$default; + } + var lib$es6$promise$polyfill$$default = lib$es6$promise$polyfill$$polyfill; + + var lib$es6$promise$umd$$ES6Promise = { + 'Promise': lib$es6$promise$promise$$default, + 'polyfill': lib$es6$promise$polyfill$$default + }; + + /* global define:true module:true window: true */ + if (typeof define === 'function' && define['amd']) { + define(function() { return lib$es6$promise$umd$$ES6Promise; }); + } else if (typeof module !== 'undefined' && module['exports']) { + module['exports'] = lib$es6$promise$umd$$ES6Promise; + } else if (typeof this !== 'undefined') { + this['ES6Promise'] = lib$es6$promise$umd$$ES6Promise; + } + + lib$es6$promise$polyfill$$default(); +}).call(this); + + +}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) + +},{"_process":8}]},{},[2]) +//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["node_modules/browserify/node_modules/browser-pack/_prelude.js","/source/ast.ts","/source/bolt.ts","/source/logger.ts","/source/parse-util.ts","/source/rules-generator.ts","lib/rules-parser.js","/source/util.ts","node_modules/browserify/node_modules/process/browser.js","node_modules/es6-promise/dist/es6-promise.js"],"names":[],"mappings":"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A;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACviLA,gBAAuB,IAAY;IAAE,cAAiB;SAAjB,WAAiB,CAAjB,sBAAiB,CAAjB,IAAiB;QAAjB,6BAAiB;;IACpD,IAAI,CAAS,CAAC;IACd,IAAI,MAAW,CAAC;IAChB,IAAI,IAAY,CAAC;IAEjB,EAAE,CAAC,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC;QACvB,IAAI,GAAG,EAAE,CAAC;IACZ,CAAC;IACD,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACjC,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QACjB,GAAG,CAAC,CAAC,IAAI,IAAI,MAAM,CAAC,CAAC,CAAC;YACpB,EAAE,CAAC,CAAC,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBAChC,IAAI,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;YAC5B,CAAC;QACH,CAAC;IACH,CAAC;IAED,MAAM,CAAC,IAAI,CAAC;AACd,CAAC;AAlBe,cAAM,SAkBrB,CAAA;AAED,mBAA0B,GAAmB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AM,CAAC;AAChB,CAAC;AAnCe,qBAAa,gBAmC5B,CAAA;AAED,sBAAsB,CAAS,EAAE,CAAS;IACxC,MAAM,CAAC,IAAI,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClC,CAAC;AAED,oBAAoB,CAAS,EAAE,CAAS;IACtC,IAAI,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3B,EAAE,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC;QAChB,CAAC,IAAI,YAAY,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IAClC,CAAC;IACD,MAAM,CAAC,CAAC,CAAC;AACX,CAAC;;;;ACxRD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACpIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/*\n * AST builders for Firebase Rules Language.\n *\n * Copyright 2015 Google Inc. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport * as util from './util';\nimport * as logger from './logger';\n\nvar errors = {\n  typeMismatch: \"Unexpected type: \",\n  duplicatePathPart: \"A path component name is duplicated: \",\n};\n\nexport type Object = { [prop: string]: any };\n\nexport interface Exp {\n  type: string;\n  valueType: string;\n}\n\nexport interface ExpValue extends Exp {\n  value: any;\n}\n\nexport interface RegExpValue extends ExpValue {\n  modifiers: string;\n}\n\nexport interface ExpNull extends Exp {\n}\n\nexport interface ExpOp extends Exp {\n  op: string;\n  args: Exp[];\n}\n\nexport interface ExpVariable extends Exp {\n  name: string;\n}\n\nexport interface ExpLiteral extends Exp {\n  name: string;\n}\n\n// base[accessor]\nexport interface ExpReference extends Exp {\n  base: Exp;\n  accessor: Exp;\n}\n\nexport interface ExpCall extends Exp {\n  ref: ExpReference | ExpVariable;\n  args: Exp[];\n}\n\nexport interface Params { [name: string]: Exp; };\n\nexport type BuiltinFunction = (args: Exp[], params: Params) => Exp;\n\nexport interface ExpBuiltin extends Exp {\n  fn: BuiltinFunction;\n}\n\nexport type ExpType = ExpSimpleType | ExpUnionType | ExpGenericType;\nexport interface TypeParams { [name: string]: ExpType; };\n\n// Simple Type (reference)\nexport interface ExpSimpleType extends Exp {\n  name: string;\n}\n\n// Union Type: Type1 | Type2 | ...\nexport interface ExpUnionType extends Exp {\n  types: ExpType[];\n}\n\n// Generic Type (reference): Type<Type1, Type2, ...>\nexport interface ExpGenericType extends Exp {\n  name: string;\n  params: ExpType[];\n}\n\nexport interface Method {\n  params: string[];\n  body: Exp;\n}\n\nexport class PathPart {\n  label: string;\n  variable: string;\n\n  // \"label\", undefined - static path part\n  // \"$label\", X - variable path part\n  // X, !undefined - variable path part\n  constructor(label: string, variable?: string) {\n    if (label[0] === '$' && variable === undefined) {\n      variable = label;\n    }\n    if (variable && label[0] !== '$') {\n      label = '$' + label;\n    }\n    this.label = label;\n    this.variable = <string> variable;\n  }\n}\n\nexport class PathTemplate {\n  parts: PathPart[];\n\n  constructor(parts = <(string | PathPart)[]> []) {\n    this.parts = <PathPart[]> parts.map((part) => {\n      if (util.isType(part, 'string')) {\n        return new PathPart(<string> part);\n      } else {\n        return <PathPart> part;\n      }\n    });\n  }\n\n  copy() {\n    let result = new PathTemplate();\n    result.push(this);\n    return result;\n  }\n\n  getLabels(): string[] {\n    return this.parts.map((part) => part.label);\n  }\n\n  // Mapping from variables to JSON labels\n  getScope(): Params {\n    let result = <Params> {};\n    this.parts.forEach((part) => {\n      if (part.variable) {\n        if (result[part.variable]) {\n          throw new Error(errors.duplicatePathPart + part.variable);\n        }\n        result[part.variable] = literal(part.label);\n      }\n    });\n    return result;\n  }\n\n  push(temp: PathTemplate) {\n    util.extendArray(this.parts, temp.parts);\n  }\n\n  pop(temp: PathTemplate) {\n    temp.parts.forEach((part) => {\n      this.parts.pop();\n    });\n  }\n\n  length(): number {\n    return this.parts.length;\n  }\n\n  getPart(i: number): PathPart {\n    if (i > this.parts.length || i < -this.parts.length) {\n      let l = this.parts.length;\n      throw new Error(\"Path reference out of bounds: \" + i +\n                      \" [\" + -l + \" .. \" + l + \"]\");\n    }\n    if (i < 0) {\n      return this.parts[this.parts.length + i];\n    }\n    return this.parts[i];\n  }\n}\n\nexport interface Path {\n  template: PathTemplate;\n  isType: ExpType;\n  methods: { [name: string]: Method };\n};\n\nexport class Schema {\n  derivedFrom: ExpType;\n  properties: TypeParams;\n  methods: { [name: string]: Method };\n\n  // Generic parameters - if a Generic schema\n  params?: string[];\n  getValidator?: (params: Exp[]) => Object;\n\n  static isGeneric(schema: Schema): boolean {\n    return schema.params !== undefined && schema.params.length > 0;\n  }\n};\n\nexport var string: (v: string) => ExpValue = valueGen('String');\nexport var boolean: (v: boolean) => ExpValue = valueGen('Boolean');\nexport var number: (v: number) => ExpValue = valueGen('Number');\nexport var array: (v: Array<any>) => ExpValue = valueGen('Array');\n\nexport var neg = opGen('neg', 1);\nexport var not = opGen('!', 1);\nexport var mult = opGen('*');\nexport var div = opGen('/');\nexport var mod = opGen('%');\nexport var add = opGen('+');\nexport var sub = opGen('-');\nexport var eq = opGen('==');\nexport var lt = opGen('<');\nexport var lte = opGen('<=');\nexport var gt = opGen('>');\nexport var gte = opGen('>=');\nexport var ne = opGen('!=');\nexport var and = opGen('&&');\nexport var or = opGen('||');\nexport var ternary = opGen('?:', 3);\nexport var value = opGen('value', 1);\n\nexport function variable(name: string): ExpVariable {\n  return { type: 'var', valueType: 'Any', name: name };\n}\n\nexport function literal(name: string): ExpLiteral {\n  return { type: 'literal', valueType: 'Any', name: name };\n}\n\nexport function nullType(): ExpNull {\n  return { type: 'Null', valueType: 'Null' };\n}\n\nexport function reference(base: Exp, prop: Exp): ExpReference {\n  return {\n    type: 'ref',\n    valueType: 'Any',\n    base: base,\n    accessor: prop\n  };\n}\n\nlet reIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_]*$/;\n\nexport function isIdentifierStringExp(exp: Exp) {\n  return exp.type === 'String' && reIdentifier.test((<ExpValue> exp).value);\n}\n\n// Shallow copy of an expression (so it can be modified and preserve\n// immutability of the original expression).\nexport function copyExp(exp: Exp): Exp {\n  exp = <Exp> util.extend({}, exp);\n  switch (exp.type) {\n  case 'op':\n  case 'call':\n    let opExp = <ExpOp> exp;\n    opExp.args = util.copyArray(opExp.args);\n    return opExp;\n\n  case 'union':\n    let unionExp = <ExpUnionType> exp;\n    unionExp.types = util.copyArray(unionExp.types);\n    return unionExp;\n\n  case 'generic':\n    let genericExp = <ExpGenericType> exp;\n    genericExp.params = util.copyArray(genericExp.params);\n    return genericExp;\n\n  default:\n     return exp;\n  }\n}\n\n// Make a (shallow) copy of the base expression, setting (or removing) it's\n// valueType.\n//\n// valueType is a string indicating the type of evaluating an expression (e.g.\n// 'Snapshot') - used to know when type coercion is needed in the context\n// of parent expressions.\nexport function cast(base: Exp, valueType: string): Exp {\n  var result = copyExp(base);\n  result.valueType = valueType;\n  return result;\n}\n\nexport function call(ref: ExpReference | ExpVariable, args: Exp[]= []): ExpCall {\n  return { type: 'call', valueType: 'Any', ref: ref, args: args };\n}\n\n// Return empty string if not a function.\nexport function getFunctionName(exp: ExpCall): string {\n  if (exp.ref.type === 'ref') {\n    return '';\n  }\n  return (<ExpVariable> exp.ref).name;\n}\n\n// Return empty string if not a (simple) method call -- ref.fn()\nexport function getMethodName(exp: ExpCall): string {\n  if (exp.ref.type === 'var') {\n    return (<ExpVariable> exp.ref).name;\n  }\n  if (exp.ref.type !== 'ref') {\n    return '';\n  }\n  return getPropName(<ExpReference> exp.ref);\n}\n\nexport function getPropName(ref: ExpReference): string {\n  if (ref.accessor.type !== 'String') {\n    return '';\n  }\n  return (<ExpValue> ref.accessor).value;\n}\n\n// TODO: Type of function signature does not fail this declaration?\nexport function builtin(fn: BuiltinFunction): ExpBuiltin {\n  return { type: 'builtin', valueType: 'Any', fn: fn };\n}\n\nexport function snapshotVariable(name: string): ExpVariable {\n  return <ExpVariable> cast(variable(name), 'Snapshot');\n}\n\nexport function snapshotParent(base: Exp): Exp {\n  if (base.valueType !== 'Snapshot') {\n    throw new Error(errors.typeMismatch + \"expected Snapshot\");\n  }\n  return cast(call(reference(cast(base, 'Any'), string('parent'))),\n              'Snapshot');\n}\n\nexport function ensureValue(exp: Exp): Exp {\n  if (exp.valueType === 'Snapshot') {\n    return snapshotValue(exp);\n  }\n  return exp;\n}\n\n// ref.val()\nexport function snapshotValue(exp: Exp): ExpCall {\n  return call(reference(cast(exp, 'Any'), string('val')));\n}\n\n// Ensure expression is a boolean (when used in a boolean context).\nexport function ensureBoolean(exp: Exp): Exp {\n  exp = ensureValue(exp);\n  if (isCall(exp, 'val')) {\n    exp = eq(exp, boolean(true));\n  }\n  return exp;\n}\n\nexport function isCall(exp: Exp, methodName: string): boolean {\n  return exp.type === 'call' && (<ExpCall> exp).ref.type === 'ref' &&\n    (<ExpReference> (<ExpCall> exp).ref).accessor.type === 'String' &&\n    (<ExpValue> (<ExpReference> (<ExpCall> exp).ref).accessor).value === methodName;\n}\n\n// Return value generating function for a given Type.\nfunction valueGen(typeName: string): ((val: any) => ExpValue) {\n  return function(val): ExpValue {\n    return {\n      type: typeName,      // Exp type identifying a constant value of this Type.\n      valueType: typeName, // The type of the result of evaluating this expression.\n      value: val           // The (constant) value itself.\n    };\n  };\n}\n\nexport function regexp(pattern: string, modifiers = \"\"): RegExpValue {\n  switch (modifiers) {\n  case \"\":\n  case \"i\":\n    break;\n  default:\n    throw new Error(\"Unsupported RegExp modifier: \" + modifiers);\n  }\n  return {\n    type: 'RegExp',\n    valueType: 'RegExp',\n    value: pattern,\n    modifiers: modifiers\n  };\n}\n\nfunction cmpValues(v1: Exp, v2: ExpValue): boolean {\n  if (v1.type !== v2.type) {\n    return false;\n  }\n  return (<ExpValue> v1).value === v2.value;\n}\n\nfunction isOp(opType: string, exp: Exp): boolean {\n  return exp.type === 'op' && (<ExpOp> exp).op === opType;\n}\n\n// Return a generating function to make an operator exp node.\nfunction opGen(opType: string, arity: number = 2): ((...args: Exp[]) => ExpOp) {\n  return function(...args): ExpOp {\n    if (args.length !== arity) {\n      throw new Error(\"Operator has \" + args.length +\n                      \" arguments (expecting \" + arity + \").\");\n    }\n    return op(opType, args);\n  };\n}\n\nexport var andArray = leftAssociateGen('&&', boolean(true), boolean(false));\nexport var orArray = leftAssociateGen('||', boolean(false), boolean(true));\n\n// Create an expression builder function which operates on arrays of values.\n// Returns new expression like v1 op v2 op v3 ...\n//\n// - Any identityValue's in array input are ignored.\n// - If zeroValue is found - just return zeroValue.\n//\n// Our function re-orders top-level op in array elements to the resulting\n// expression is left-associating.  E.g.:\n//\n//    [a && b, c && d] => (((a && b) && c) && d)\n//    (NOT (a && b) && (c && d))\nfunction leftAssociateGen(opType: string, identityValue: ExpValue, zeroValue: ExpValue) {\n  return function(a: Exp[]): Exp {\n    var i: number;\n\n    function reducer(result: Exp, current: Exp) {\n      if (result === undefined) {\n        return current;\n      }\n      return op(opType, [result, current]);\n    }\n\n    // First flatten all top-level op values to one flat array.\n    var flat = <Exp[]>[];\n    for (i = 0; i < a.length; i++) {\n      flatten(opType, a[i], flat);\n    }\n\n    var result = <Exp[]>[];\n    for (i = 0; i < flat.length; i++) {\n      // Remove identifyValues from array.\n      if (cmpValues(flat[i], identityValue)) {\n        continue;\n      }\n      // Just return zeroValue if found\n      if (cmpValues(flat[i], zeroValue)) {\n        return zeroValue;\n      }\n      result.push(flat[i]);\n    }\n\n    if (result.length === 0) {\n      return identityValue;\n    }\n\n    // Return left-associative expression of opType.\n    return result.reduce(reducer);\n  };\n}\n\n// Flatten the top level tree of op into a single flat array of expressions.\nexport function flatten(opType: string, exp: Exp, flat?: Exp[]): Exp[] {\n  var i: number;\n\n  if (flat === undefined) {\n    flat = [];\n  }\n\n  if (!isOp(opType, exp)) {\n    flat.push(exp);\n    return flat;\n  }\n\n  for (i = 0; i < (<ExpOp> exp).args.length; i++) {\n    flatten(opType, (<ExpOp> exp).args[i], flat);\n  }\n\n  return flat;\n}\n\nexport function op(opType: string, args: Exp[]): ExpOp {\n  return {\n    type: 'op',     // This is (multi-argument) operator.\n    valueType: 'Any',\n    op: opType,     // The operator (string, e.g. '+').\n    args: args      // Arguments to the operator Array<exp>\n  };\n}\n\n// Warning: NOT an expression type!\nexport function method(params: string[], body: Exp): Method {\n  return {\n    params: params,\n    body: body\n  };\n}\n\nexport function typeType(typeName: string): ExpSimpleType {\n  return { type: \"type\", valueType: \"type\", name: typeName };\n}\n\nexport function unionType(types: ExpType[]): ExpUnionType {\n  return { type: \"union\", valueType: \"type\", types: types };\n}\n\nexport function genericType(typeName: string, params: ExpType[]): ExpGenericType {\n  return { type: \"generic\", valueType: \"type\", name: typeName, params: params };\n}\n\nexport class Symbols {\n  functions: { [name: string]: Method };\n  paths: Path[];\n  schema: { [name: string]: Schema };\n\n  constructor() {\n    this.functions = {};\n    this.paths = [];\n    this.schema = {};\n  }\n\n  register<T>(map: {[name: string]: T}, typeName: string, name: string, object: T): T {\n    if (map[name]) {\n      logger.error(\"Duplicated \" + typeName + \" definition: \" + name + \".\");\n    } else {\n      map[name] = object;\n    }\n    return map[name];\n  }\n\n  registerFunction(name: string, params: string[], body: Exp): Method {\n    return this.register<Method>(this.functions, 'functions', name,\n                                 method(params, body));\n  }\n\n  registerPath(template: PathTemplate, isType: ExpType | void, methods: { [name: string]: Method; } = {}): Path {\n    isType = isType || typeType('Any');\n    var p: Path = {\n      template: template.copy(),\n      isType: <ExpType> isType,\n      methods: methods\n    };\n    this.paths.push(p);\n    return p;\n  }\n\n  registerSchema(name: string,\n                 derivedFrom?: ExpType,\n                 properties = <TypeParams> {},\n                 methods = <{ [name: string]: Method }> {},\n                 params = <string[]> [])\n  : Schema {\n    derivedFrom = derivedFrom || typeType(Object.keys(properties).length > 0 ? 'Object' : 'Any');\n\n    var s: Schema = {\n      derivedFrom: <ExpType> derivedFrom,\n      properties: properties,\n      methods: methods,\n      params: params,\n    };\n    return this.register<Schema>(this.schema, 'schema', name, s);\n  }\n\n  isDerivedFrom(type: ExpType, ancestor: string): boolean {\n    if (ancestor === 'Any') {\n      return true;\n    }\n\n    switch (type.type) {\n    case 'type':\n    case 'generic':\n      let simpleType = <ExpSimpleType> type;\n      if (simpleType.name === ancestor) {\n        return true;\n      }\n      if (simpleType.name === 'Any') {\n        return false;\n      }\n      let schema = this.schema[simpleType.name];\n      if (!schema) {\n        return false;\n      }\n      return this.isDerivedFrom(schema.derivedFrom, ancestor);\n\n    case 'union':\n      return (<ExpUnionType> type).types\n        .map((subType) => this.isDerivedFrom(subType, ancestor))\n        .reduce(util.or);\n\n    default:\n      throw new Error(\"Unknown type: \" + type.type);\n      }\n  }\n}\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence\ninterface OpPriority {\n  rep?: string;\n  p: number;\n}\n\nvar JS_OPS: { [op: string]: OpPriority; } = {\n  'value': { rep: \"\", p: 18 },\n\n  'neg': { rep: \"-\", p: 15},\n  '!': { p: 15},\n  '*': { p: 14},\n  '/': { p: 14},\n  '%': { p: 14},\n  '+': { p: 13 },\n  '-': { p: 13 },\n  '<': { p: 11 },\n  '<=': { p: 11 },\n  '>': { p: 11 },\n  '>=': { p: 11 },\n  'in': { p: 11 },\n  '==': { p: 10 },\n  \"!=\": { p: 10 },\n  '&&': { p: 6 },\n  '||': { p: 5 },\n  '?:': { p: 4 },\n  ',': { p: 0},\n};\n\n// From an AST, decode as an expression (string).\nexport function decodeExpression(exp: Exp, outerPrecedence?: number): string {\n  if (outerPrecedence === undefined) {\n    outerPrecedence = 0;\n  }\n  var innerPrecedence = precedenceOf(exp);\n  var result = '';\n\n  switch (exp.type) {\n  case 'Boolean':\n  case 'Number':\n    result = JSON.stringify((<ExpValue> exp).value);\n    break;\n\n  case 'String':\n    result = util.quoteString((<ExpValue> exp).value);\n    break;\n\n  // RegExp assumed to be in pre-quoted format.\n  case 'RegExp':\n    let regexp = <RegExpValue> exp;\n    result = '/' + regexp.value + '/';\n    if (regexp.modifiers !== '') {\n      result += regexp.modifiers;\n    }\n    break;\n\n  case 'Array':\n    result = '[' + decodeArray((<ExpValue> exp).value) + ']';\n    break;\n\n  case 'Null':\n    result = 'null';\n    break;\n\n  case 'var':\n  case 'literal':\n    result = (<ExpVariable> exp).name;\n    break;\n\n  case 'ref':\n    let expRef = <ExpReference> exp;\n    if (isIdentifierStringExp(expRef.accessor)) {\n      result = decodeExpression(expRef.base, innerPrecedence) + '.' + (<ExpValue> expRef.accessor).value;\n    } else {\n      result = decodeExpression(expRef.base, innerPrecedence) +\n        '[' + decodeExpression(expRef.accessor) + ']';\n    }\n    break;\n\n  case 'call':\n    let expCall = <ExpCall> exp;\n    result = decodeExpression(expCall.ref) + '(' + decodeArray(expCall.args) + ')';\n    break;\n\n  case 'builtin':\n    result = decodeExpression(exp);\n    break;\n\n  case 'op':\n    let expOp = <ExpOp> exp;\n    var rep = JS_OPS[expOp.op].rep === undefined ? expOp.op : JS_OPS[expOp.op].rep;\n    if (expOp.args.length === 1) {\n      result = rep + decodeExpression(expOp.args[0], innerPrecedence);\n    } else if (expOp.args.length === 2) {\n      result =\n        decodeExpression(expOp.args[0], innerPrecedence) +\n        ' ' + rep + ' ' +\n        // All ops are left associative - so nudge the innerPrecendence\n        // down on the right hand side to force () for right-associating\n        // operations.\n        decodeExpression(expOp.args[1], innerPrecedence + 1);\n    } else if (expOp.args.length === 3) {\n      result =\n        decodeExpression(expOp.args[0], innerPrecedence) + ' ? ' +\n        decodeExpression(expOp.args[1], innerPrecedence) + ' : ' +\n        decodeExpression(expOp.args[2], innerPrecedence);\n    }\n    break;\n\n  case 'type':\n    result = (<ExpSimpleType> exp).name;\n    break;\n\n  case 'union':\n    result = (<ExpUnionType> exp).types.map(decodeExpression).join(' | ');\n    break;\n\n  case 'generic':\n    let genericType = <ExpGenericType> exp;\n    return genericType.name + '<' + decodeArray(genericType.params) + '>';\n\n  default:\n    result = \"***UNKNOWN TYPE*** (\" + exp.type + \")\";\n    break;\n  }\n\n  if (innerPrecedence < outerPrecedence) {\n    result = '(' + result + ')';\n  }\n\n  return result;\n}\n\nfunction decodeArray(args: Exp[]): string {\n  return args.map(decodeExpression).join(', ');\n}\n\nfunction precedenceOf(exp: Exp): number {\n  let result: number;\n\n  switch (exp.type) {\n  case 'op':\n    result = JS_OPS[(<ExpOp> exp).op].p;\n    break;\n\n  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence\n  // lists call as 17 and ref as 18 - but how could they be anything other than left to right?\n  // http://www.scriptingmaster.com/javascript/operator-precedence.asp - agrees.\n  case 'call':\n    result = 18;\n    break;\n  case 'ref':\n    result = 18;\n    break;\n  default:\n    result = 19;\n    break;\n  }\n\n  return result;\n}\n","/*\n * Copyright 2015 Google Inc. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// TODO(koss): After node 0.10 leaves LTS - remove polyfilled Promise library.\nif (typeof Promise === 'undefined') {\n  require('es6-promise').polyfill();\n}\n\nlet parser = require('./rules-parser');\nimport * as generator from './rules-generator';\nimport * as astImport from './ast';\n\nexport let FILE_EXTENSION = 'bolt';\n\nexport let ast = astImport;\nexport let parse = parser.parse;\nexport let Generator = generator.Generator;\nexport let decodeExpression = ast.decodeExpression;\nexport let generate = generator.generate;\n","/*\n * Copyright 2015 Google Inc. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nlet lastError: string | undefined;\nlet lastMessage: string | undefined;\nlet errorCount: number;\nlet silenceOutput: boolean;\n\nlet getContext = () => (<ErrorContext> {});\n\nreset();\n\nexport function reset() {\n  lastError = undefined;\n  lastMessage = undefined;\n  errorCount = 0;\n  silenceOutput = false;\n}\n\nexport function silent(f = true) {\n  silenceOutput = f;\n}\n\nexport interface ErrorContext {\n  line?: number;\n  column?: number;\n}\n\nexport function setContext(fn: () => ErrorContext) {\n  getContext = fn;\n}\n\nexport function error(s: string) {\n  let err = errorString(s);\n  // De-dup identical messages\n  if (err  === lastMessage) {\n    return;\n  }\n  lastMessage = err;\n  lastError = lastMessage;\n  if (!silenceOutput) {\n    console.error(lastError);\n  }\n  errorCount += 1;\n}\n\nexport function warn(s: string) {\n  let err = errorString(s);\n  // De-dup identical messages\n  if (err === lastMessage) {\n    return;\n  }\n  lastMessage = err;\n  if (!silenceOutput) {\n    console.warn(lastMessage);\n  }\n}\n\nexport function getLastMessage(): string | undefined {\n  return lastMessage;\n}\n\nfunction errorString(s: string) {\n  let ctx = getContext();\n  if (ctx.line !== undefined && ctx.column !== undefined) {\n    return 'bolt:' + ctx.line + ':' + ctx.column + ': ' + s;\n  } else {\n    return 'bolt: ' + s;\n  }\n}\n\nexport function hasErrors(): boolean {\n  return errorCount > 0;\n}\n\nexport function errorSummary(): string {\n  if (errorCount === 1) {\n    return <string> lastError;\n  }\n\n  if (errorCount !== 0) {\n    return \"Fatal errors: \" + errorCount;\n  }\n  return \"\";\n}\n","/*\n * Copyright 2015 Google Inc. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nlet parser = require('./rules-parser');\nimport * as ast from './ast';\n\nexport function parseExpression(expression: string): ast.Exp {\n  var result = parser.parse('function f() {return ' + expression + ';}');\n  return result.functions.f.body;\n}\n","/*\n * Copyright 2015 Google Inc. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport * as util from './util';\nimport * as ast from './ast';\nimport {warn, error} from './logger';\nlet parser = require('./rules-parser');\nimport {parseExpression} from './parse-util';\n\nvar errors = {\n  badIndex: \"The index function must return a String or an array of Strings.\",\n  noPaths: \"Must have at least one path expression.\",\n  nonObject: \"Type contains properties and must extend 'Object'.\",\n  missingSchema: \"Missing definition for type.\",\n  recursive: \"Recursive function call.\",\n  mismatchParams: \"Incorrect number of function arguments.\",\n  generateFailed: \"Could not generate JSON: \",\n  noSuchType: \"No type definition for: \",\n  badSchemaMethod: \"Unsupported method name in type statement: \",\n  badPathMethod: \"Unsupported method name in path statement: \",\n  badWriteAlias: \"Cannot have both a write() method and a write-aliasing method: \",\n  coercion: \"Cannot convert value: \",\n  undefinedFunction: \"Undefined function: \",\n  application: \"Bolt application error: \",\n  invalidGeneric: \"Invalid generic schema usage: \",\n  invalidMapKey: \"Map<Key, T> - Key must derive from String type.\",\n  invalidWildChildren: \"Types can have at most one $wild property and cannot mix with other properties.\",\n  invalidPropertyName: \"Property names cannot contain any of: . $ # [ ] / or control characters: \",\n};\n\nlet INVALID_KEY_REGEX = /[\\[\\].#$\\/\\u0000-\\u001F\\u007F]/;\n\n/*\n   A Validator is a JSON heriarchical structure. The \"leaves\" are \"dot-properties\"\n   (see below). The intermediate nodes in the tree are \"prop\" or \"$prop\"\n   properties.\n\n   A Validator is mutated to have different forms based on the the phase of\n   generation.\n\n   In the first phase, they are Exp[]. Later the Exp[] are ANDed together and\n   combined into expression text (and returned as the final JSON-rules that\n   Firebase uses.\n\n   Note: TS does not allow for special properties to have distinct\n   types from the 'index' property given for the interface.  :-(\n\n   '.read': ast.Exp[] | string;\n   '.write': ast.Exp[] | string;\n   '.validate': ast.Exp[] | string;\n   '.indexOn': string[];\n   '.scope': { [variable: string]: string }\n*/\nexport type ValidatorValue = ast.Exp | ast.Exp[] | string | string[] | Validator;\nexport interface Validator {\n  [name: string]: ValidatorValue;\n};\n\nvar builtinSchemaNames = ['Any', 'Null', 'String', 'Number', 'Boolean', 'Object'];\n// Method names allowed in Bolt files.\nvar valueMethods = ['length', 'includes', 'startsWith', 'beginsWith', 'endsWith',\n                    'replace', 'toLowerCase', 'toUpperCase', 'test', 'contains',\n                    'matches'];\n// TODO: Make sure users don't call internal methods...make private to impl.\nvar snapshotMethods = ['parent', 'child', 'hasChildren', 'val', 'isString', 'isNumber',\n                       'isBoolean'].concat(valueMethods);\n\nvar writeAliases = <{ [method: string]: ast.Exp }> {\n  'create': parseExpression('prior(this) == null'),\n  'update': parseExpression('prior(this) != null && this != null'),\n  'delete': parseExpression('prior(this) != null && this == null')\n};\n\n// Usage:\n//   json = bolt.generate(bolt-text)\nexport function generate(symbols: string | ast.Symbols): Validator {\n  if (typeof symbols === 'string') {\n    symbols = parser.parse(symbols);\n  }\n  var gen = new Generator(<ast.Symbols> symbols);\n  return gen.generateRules();\n}\n\n// Symbols contains:\n//   functions: {}\n//   schema: {}\n//   paths: {}\nexport class Generator {\n  symbols: ast.Symbols;\n  validators: { [schemaName: string]: Validator; };\n  rules: Validator;\n  errorCount: number;\n  runSilently: boolean;\n  allowUndefinedFunctions: boolean;\n  globals: ast.Params;\n  thisIs: string;\n  keyIndex: number;\n\n  constructor(symbols: ast.Symbols) {\n    this.symbols = symbols;\n    this.validators = {};\n    this.rules = {};\n    this.errorCount = 0;\n    this.runSilently = false;\n    this.allowUndefinedFunctions = false;\n    this.keyIndex = 0;\n\n    // TODO: globals should be part of this.symbols (nested scopes)\n    this.globals = {\n      \"root\": ast.call(ast.variable('@root')),\n    };\n\n    this.registerBuiltinSchema();\n  }\n\n  // Return Firebase compatible Rules JSON for a the given symbols definitions.\n  generateRules(): Validator {\n    this.errorCount = 0;\n    var paths = this.symbols.paths;\n    var schema = this.symbols.schema;\n    var name: string;\n\n    paths.forEach((path) => {\n      this.validateMethods(errors.badPathMethod, path.methods,\n                           ['validate', 'read', 'write', 'index']);\n    });\n\n    for (name in schema) {\n      if (!util.arrayIncludes(builtinSchemaNames, name)) {\n        this.validateMethods(errors.badSchemaMethod, schema[name].methods,\n                             ['validate', 'read', 'write']);\n      }\n    }\n\n    if (paths.length === 0) {\n      this.fatal(errors.noPaths);\n    }\n\n    paths.forEach((path) => this.updateRules(path));\n    this.convertExpressions(this.rules);\n\n    if (this.errorCount !== 0) {\n      throw new Error(errors.generateFailed + this.errorCount + \" errors.\");\n    }\n\n    util.deletePropName(this.rules, '.scope');\n    util.pruneEmptyChildren(this.rules);\n\n    return {\n      rules: this.rules\n    };\n  }\n\n  validateMethods(m: string, methods: { [name: string]: ast.Method }, allowed: string[]) {\n    if (util.arrayIncludes(allowed, 'write')) {\n      allowed = allowed.concat(Object.keys(writeAliases));\n    }\n    for (var method in methods) {\n      if (!util.arrayIncludes(allowed, method)) {\n        warn(m + util.quoteString(method) +\n             \" (allowed: \" + allowed.map(util.quoteString).join(', ') + \")\");\n      }\n    }\n    if ('write' in methods) {\n      Object.keys(writeAliases).forEach((alias) => {\n        if (alias in methods) {\n          this.fatal(errors.badWriteAlias + alias);\n        }\n      });\n    }\n  }\n\n  registerBuiltinSchema() {\n    var self = this;\n    var thisVar = ast.variable('this');\n\n    function registerAsCall(name: string, methodName: string): void {\n      self.symbols.registerSchema(name, ast.typeType('Any'), undefined, {\n        validate: ast.method(['this'], ast.call(ast.reference(ast.cast(thisVar, 'Any'),\n                                                              ast.string(methodName))))\n      });\n    }\n\n    this.symbols.registerSchema('Any', ast.typeType('Any'), undefined, {\n      validate: ast.method(['this'], ast.boolean(true))\n    });\n\n    registerAsCall('Object', 'hasChildren');\n\n    // Because of the way firebase treats Null values, there is no way to\n    // write a validation rule, that will EVER be called with this == null\n    // (firebase allows values to be deleted no matter their validation rules).\n    // So, comparing this == null will always return false -> that is what\n    // we do here, which will be optimized away if ORed with other validations.\n    this.symbols.registerSchema('Null', ast.typeType('Any'), undefined, {\n      validate: ast.method(['this'], ast.boolean(false))\n    });\n\n    self.symbols.registerSchema('String', ast.typeType('Any'), undefined, {\n      validate: ast.method(['this'],\n                           ast.call(ast.reference(ast.cast(thisVar, 'Any'), ast.string('isString')))),\n      includes: ast.method(['this', 's'],\n                           ast.call(ast.reference(ast.value(thisVar), ast.string('contains')),\n                                    [ ast.value(ast.variable('s')) ])),\n      startsWith: ast.method(['this', 's'],\n                             ast.call(ast.reference(ast.value(thisVar), ast.string('beginsWith')),\n                                      [ ast.value(ast.variable('s')) ])),\n      endsWith: ast.method(['this', 's'],\n                           ast.call(ast.reference(ast.value(thisVar), ast.string('endsWith')),\n                                    [ ast.value(ast.variable('s')) ])),\n      replace: ast.method(['this', 's', 'r'],\n                          ast.call(ast.reference(ast.value(thisVar), ast.string('replace')),\n                                   [ ast.value(ast.variable('s')), ast.value(ast.variable('r')) ])),\n      test: ast.method(['this', 'r'],\n                       ast.call(ast.reference(ast.value(thisVar), ast.string('matches')),\n                                [ ast.call(ast.variable('@RegExp'), [ast.variable('r')]) ])),\n    });\n\n    registerAsCall('Number', 'isNumber');\n    registerAsCall('Boolean', 'isBoolean');\n\n    this.symbols.registerFunction('@RegExp', ['r'],\n                                  ast.builtin(this.ensureType.bind(this, 'RegExp')));\n\n    let map = this.symbols.registerSchema('Map', ast.typeType('Any'), undefined, undefined,\n                                          ['Key', 'Value']);\n    map.getValidator = this.getMapValidator.bind(this);\n  }\n\n  // type Map<Key, Value> => {\n  //   $key: {\n  //     '.validate': $key instanceof Key and this instanceof Value;\n  //   '.validate': 'newData.hasChildren()'\n  // }\n  // Key must derive from String\n  getMapValidator(params: ast.Exp[]): Validator {\n    let keyType = <ast.ExpSimpleType> params[0];\n    let valueType = <ast.ExpType> params[1];\n    if (keyType.type !== 'type' || !this.symbols.isDerivedFrom(keyType, 'String')) {\n      throw new Error(errors.invalidMapKey + \"  (\" + ast.decodeExpression(keyType) + \" does not)\");\n    }\n\n    let validator = <Validator> {};\n    let index = this.uniqueKey();\n    validator[index] = <Validator> {};\n    extendValidator(validator, this.ensureValidator(ast.typeType('Object')));\n\n    // First validate the key (omit terminal String type validation).\n    while (keyType.name !== 'String') {\n      let schema = this.symbols.schema[keyType.name];\n      if (schema.methods['validate']) {\n        let exp = this.partialEval(schema.methods['validate'].body, {'this': ast.literal(index)});\n        extendValidator(<Validator> validator[index], <Validator> {'.validate': [exp]});\n      }\n      keyType = <ast.ExpSimpleType> schema.derivedFrom;\n    }\n\n    extendValidator(<Validator> validator[index], this.ensureValidator(valueType));\n    return validator;\n  }\n\n  uniqueKey(): string {\n    this.keyIndex += 1;\n    return '$key' + this.keyIndex;\n  }\n\n  // Collection schema has exactly one $wildchild property\n  isCollectionSchema(schema: ast.Schema): boolean {\n    let props = Object.keys(schema.properties);\n    let result = props.length === 1 && props[0][0] === '$';\n    return result;\n  }\n\n  // Ensure we have a definition for a validator for the given schema.\n  ensureValidator(type: ast.ExpType): Validator {\n    var key = ast.decodeExpression(type);\n    if (!this.validators[key]) {\n      this.validators[key] = {'.validate': ast.literal('***TYPE RECURSION***') };\n      this.validators[key] = this.createValidator(type);\n    }\n    return this.validators[key];\n  }\n\n  createValidator(type: ast.ExpType): Validator {\n    switch (type.type) {\n    case 'type':\n      return this.createValidatorFromSchemaName((<ast.ExpSimpleType> type).name);\n\n    case 'union':\n      let union = <Validator> {};\n      (<ast.ExpUnionType> type).types.forEach((typePart: ast.ExpType) => {\n        // Make a copy\n        var singleType = extendValidator({}, this.ensureValidator(typePart));\n        mapValidator(singleType, ast.andArray);\n        extendValidator(union, singleType);\n      });\n      mapValidator(union, ast.orArray);\n      return union;\n\n    case 'generic':\n      let genericType = <ast.ExpGenericType> type;\n      return this.createValidatorFromGeneric(genericType.name, genericType.params);\n\n    default:\n      throw new Error(errors.application + \"invalid internal type: \" + type.type);\n    }\n  }\n\n  createValidatorFromGeneric(schemaName: string, params: ast.ExpType[]): Validator {\n    var schema = this.symbols.schema[schemaName];\n\n    if (schema === undefined || !ast.Schema.isGeneric(schema)) {\n      throw new Error(errors.noSuchType + schemaName + \" (generic)\");\n    }\n\n    let schemaParams = <string[]> schema.params;\n\n    if (params.length !== schemaParams.length) {\n      throw new Error(errors.invalidGeneric + \" expected <\" + schemaParams.join(', ') + \">\");\n    }\n\n    // Call custom validator, if given.\n    if (schema.getValidator) {\n      return schema.getValidator(params);\n    }\n\n    let bindings = <ast.TypeParams> {};\n    for (let i = 0; i < params.length; i++) {\n      bindings[schemaParams[i]] = params[i];\n    }\n\n    // Expand generics and generate validator from schema.\n    schema = this.replaceGenericsInSchema(schema, bindings);\n    return this.createValidatorFromSchema(schema);\n  }\n\n  replaceGenericsInSchema(schema: ast.Schema, bindings: ast.TypeParams): ast.Schema {\n    var expandedSchema = <ast.Schema> {\n      derivedFrom: <ast.ExpType> this.replaceGenericsInExp(schema.derivedFrom, bindings),\n      properties: { },\n      methods: {},\n    };\n    let props = Object.keys(schema.properties);\n    props.forEach((prop) => {\n      expandedSchema.properties[prop] =\n        <ast.ExpType> this.replaceGenericsInExp(schema.properties[prop], bindings);\n    });\n\n    let methods = Object.keys(schema.methods);\n    methods.forEach((methodName) => {\n      expandedSchema.methods[methodName] = this.replaceGenericsInMethod(schema.methods[methodName],\n                                                                       bindings);\n    });\n    return expandedSchema;\n  }\n\n  replaceGenericsInExp(exp: ast.Exp, bindings: ast.TypeParams): ast.Exp {\n    var self = this;\n\n    function replaceGenericsInArray(exps: ast.Exp[]): ast.Exp[] {\n      return exps.map(function(expPart) {\n        return self.replaceGenericsInExp(expPart, bindings);\n      });\n    }\n\n    switch (exp.type) {\n    case 'op':\n    case 'call':\n      let opType = <ast.ExpOp> ast.copyExp(exp);\n      opType.args = replaceGenericsInArray(opType.args);\n      return opType;\n\n    case 'type':\n      let simpleType = <ast.ExpSimpleType> exp;\n      return bindings[simpleType.name] || simpleType;\n\n    case 'union':\n      let unionType = <ast.ExpUnionType> exp;\n      return ast.unionType(<ast.ExpType[]> replaceGenericsInArray(unionType.types));\n\n    case 'generic':\n      let genericType = <ast.ExpGenericType> exp;\n      return ast.genericType(genericType.name,\n                             <ast.ExpType[]> replaceGenericsInArray(genericType.params));\n\n    default:\n      return exp;\n    }\n  }\n\n  replaceGenericsInMethod(method: ast.Method, bindings: ast.TypeParams): ast.Method {\n    var expandedMethod = <ast.Method> {\n      params: method.params,\n      body: method.body\n    };\n\n    expandedMethod.body = this.replaceGenericsInExp(method.body, bindings);\n    return expandedMethod;\n  }\n\n  createValidatorFromSchemaName(schemaName: string): Validator {\n    var schema = this.symbols.schema[schemaName];\n\n    if (!schema) {\n      throw new Error(errors.noSuchType + schemaName);\n    }\n\n    if (ast.Schema.isGeneric(schema)) {\n      throw new Error(errors.noSuchType + schemaName + \" used as non-generic type.\");\n    }\n\n    return this.createValidatorFromSchema(schema);\n  }\n\n  createValidatorFromSchema(schema: ast.Schema): Validator {\n    var hasProps = Object.keys(schema.properties).length > 0 &&\n      !this.isCollectionSchema(schema);\n\n    if (hasProps && !this.symbols.isDerivedFrom(schema.derivedFrom, 'Object')) {\n      this.fatal(errors.nonObject + \" (is \" + ast.decodeExpression(schema.derivedFrom) + \")\");\n      return {};\n    }\n\n    let validator = <Validator> {};\n\n    if (!(schema.derivedFrom.type === 'type' &&\n          (<ast.ExpSimpleType> schema.derivedFrom).name === 'Any')) {\n      extendValidator(validator, this.ensureValidator(schema.derivedFrom));\n    }\n\n    let requiredProperties = <string[]> [];\n    let wildProperties = 0;\n    Object.keys(schema.properties).forEach((propName) => {\n      if (propName[0] === '$') {\n        wildProperties += 1;\n        if (INVALID_KEY_REGEX.test(propName.slice(1))) {\n          this.fatal(errors.invalidPropertyName + propName);\n        }\n      } else {\n        if (INVALID_KEY_REGEX.test(propName)) {\n          this.fatal(errors.invalidPropertyName + propName);\n        }\n      }\n      if (!validator[propName]) {\n        validator[propName] = {};\n      }\n      var propType = schema.properties[propName];\n      if (propName[0] !== '$' && !this.isNullableType(propType)) {\n        requiredProperties.push(propName);\n      }\n      extendValidator(<Validator> validator[propName], this.ensureValidator(propType));\n    });\n\n    if (wildProperties > 1 || wildProperties === 1 && requiredProperties.length > 0) {\n      this.fatal(errors.invalidWildChildren);\n    }\n\n    if (requiredProperties.length > 0) {\n      // this.hasChildren(requiredProperties)\n      extendValidator(validator,\n                      {'.validate': [hasChildrenExp(requiredProperties)]});\n    }\n\n    // Disallow $other properties by default\n    if (hasProps) {\n      validator['$other'] = {};\n      extendValidator(<Validator> validator['$other'],\n                      <Validator> {'.validate': ast.boolean(false)});\n    }\n\n    this.extendValidationMethods(validator, schema.methods);\n\n    return validator;\n  }\n\n  isNullableType(type: ast.ExpType): boolean {\n    let result = this.symbols.isDerivedFrom(type, 'Null') ||\n      this.symbols.isDerivedFrom(type, 'Map');\n    return result;\n  }\n\n  // Update rules based on the given path expression.\n  updateRules(path: ast.Path) {\n    var i: number;\n    var location = <Validator> util.ensureObjectPath(this.rules, path.template.getLabels());\n    var exp: ast.ExpValue;\n\n    extendValidator(location, this.ensureValidator(path.isType));\n    location['.scope'] = path.template.getScope();\n\n    this.extendValidationMethods(location, path.methods);\n\n    // Write indices\n    if (path.methods['index']) {\n      switch (path.methods['index'].body.type) {\n      case 'String':\n        exp = ast.array([path.methods['index'].body]);\n        break;\n      case 'Array':\n        exp = <ast.ExpValue> path.methods['index'].body;\n        break;\n      default:\n        this.fatal(errors.badIndex);\n        return;\n      }\n      var indices = <string[]> [];\n      for (i = 0; i < exp.value.length; i++) {\n        if (exp.value[i].type !== 'String') {\n          this.fatal(errors.badIndex + \" (not \" + exp.value[i].type + \")\");\n        } else {\n          indices.push(exp.value[i].value);\n        }\n      }\n      // TODO: Error check not over-writing index rules.\n      location['.indexOn'] = indices;\n    }\n  }\n\n  extendValidationMethods(validator: Validator, methods: { [method: string]: ast.Method }) {\n    let writeMethods = <ast.Exp[]> [];\n    ['create', 'update', 'delete'].forEach((method) => {\n      if (method in methods) {\n        writeMethods.push(ast.andArray([writeAliases[method], methods[method].body]));\n      }\n    });\n    if (writeMethods.length !== 0) {\n      extendValidator(validator, <Validator> { '.write': ast.orArray(writeMethods) });\n    }\n\n    ['validate', 'read', 'write'].forEach((method) => {\n      if (method in methods) {\n        var methodValidator = <Validator> {};\n        methodValidator['.' + method] = methods[method].body;\n        extendValidator(validator, methodValidator);\n      }\n    });\n  }\n\n  // Return union validator (||) over each schema\n  unionValidators(schema: string[]): Validator {\n    var union = <Validator> {};\n    schema.forEach(function(typeName: string) {\n      // First and the validator terms for a single type\n      // Todo extend to unions and generics\n      var singleType = extendValidator({}, this.ensureValidator(typeName));\n      mapValidator(singleType, ast.andArray);\n      extendValidator(union, singleType);\n    }.bind(this));\n    mapValidator(union, ast.orArray);\n    return union;\n  }\n\n  // Convert expressions to text, and at the same time, apply pruning operations\n  // to remove no-op rules.\n  convertExpressions(validator: Validator) {\n    var methodThisIs = <{[prop: string]: string}> { '.validate': 'newData',\n                                                    '.read': 'data',\n                                                    '.write': 'newData' };\n\n    function hasWildcardSibling(path: ast.PathTemplate): boolean {\n      let parts = path.getLabels();\n      let childPart = parts.pop();\n      let parent = util.deepLookup(validator, parts);\n      if (parent === undefined) {\n        return false;\n      }\n      for (let prop of Object.keys(parent)) {\n        if (prop === childPart) {\n          continue;\n        }\n        if (prop[0] === '$') {\n          return true;\n        }\n      }\n      return false;\n    }\n\n    mapValidator(validator, (value: ast.Exp[],\n                             prop: string,\n                             scope: ast.Params,\n                             path: ast.PathTemplate) => {\n      if (prop in methodThisIs) {\n        let result = this.getExpressionText(ast.andArray(collapseHasChildren(value)),\n                                            methodThisIs[prop],\n                                            scope,\n                                            path);\n        // Remove no-op .read or .write rule if no sibling wildcard props.\n        if ((prop === '.read' || prop === '.write') && result === 'false') {\n          if (!hasWildcardSibling(path)) {\n            return undefined;\n          }\n        }\n\n        // Remove no-op .validate rule if no sibling wildcard props.\n        if (prop === '.validate' && result === 'true') {\n          if (!hasWildcardSibling(path)) {\n            return undefined;\n          }\n        }\n\n        return result;\n      }\n      return value;\n    });\n  }\n\n  getExpressionText(exp: ast.Exp, thisIs: string, scope: ast.Params, path: ast.PathTemplate): string {\n    if (!('type' in exp)) {\n      throw new Error(errors.application + \"Not an expression: \" + util.prettyJSON(exp));\n    }\n    // First evaluate w/o binding of this to specific location.\n    this.allowUndefinedFunctions = true;\n    scope = <ast.Params> util.extend({},\n                                     scope,\n                                     { 'this': ast.cast(ast.call(ast.variable('@getThis')),\n                                                        'Snapshot') });\n    exp = this.partialEval(exp, scope);\n    // Now re-evaluate the flattened expression.\n    this.allowUndefinedFunctions = false;\n    this.thisIs = thisIs;\n    this.symbols.registerFunction('@getThis', [],\n                                  ast.builtin(this.getThis.bind(this)));\n    this.symbols.registerFunction('@root', [],\n                                  ast.builtin(this.getRootReference.bind(this, path)));\n    this.symbols.registerFunction('prior', ['exp'],\n                                  ast.builtin(this.prior.bind(this)));\n    this.symbols.registerFunction('key', [],\n                                  ast.builtin(this.getKey.bind(\n                                    this,\n                                    path.length() === 0 ? '' : path.getPart(-1).label)));\n\n    exp = this.partialEval(exp);\n\n    delete this.symbols.functions['@getThis'];\n    delete this.symbols.functions['@root'];\n    delete this.symbols.functions['prior'];\n    delete this.symbols.functions['key'];\n\n    // Top level expressions should never be to a snapshot reference - should\n    // always evaluate to a boolean.\n    exp = ast.ensureBoolean(exp);\n    return ast.decodeExpression(exp);\n  }\n\n  /*\n   *  Wrapper for partialEval debugging.\n   */\n\n  partialEval(exp: ast.Exp,\n              params = <ast.Params> {},\n              functionCalls: { [name: string]: boolean } = {})\n  : ast.Exp {\n    // Wrap real call for debugging.\n    let result = this.partialEvalReal(exp, params, functionCalls);\n    // console.log(ast.decodeExpression(exp) + \" => \" + ast.decodeExpression(result));\n    return result;\n  }\n\n  // Partial evaluation of expressions - copy of expression tree (immutable).\n  //\n  // - Expand inline function calls.\n  // - Replace local and global variables with their values.\n  // - Expand snapshot references using child('ref').\n  // - Coerce snapshot references to values as needed.\n  partialEvalReal(exp: ast.Exp,\n              params = <ast.Params> {},\n              functionCalls = <{ [name: string]: boolean }> {})\n  : ast.Exp {\n    var self = this;\n\n    function subExpression(exp2: ast.Exp): ast.Exp {\n      return self.partialEval(exp2, params, functionCalls);\n    }\n\n    function valueExpression(exp2: ast.Exp): ast.Exp {\n      return ast.ensureValue(subExpression(exp2));\n    }\n\n    function booleanExpression(exp2: ast.Exp): ast.Exp {\n      return ast.ensureBoolean(subExpression(exp2));\n    }\n\n    function lookupVar(exp2: ast.ExpVariable) {\n      // TODO: Unbound variable access should be an error.\n      return params[exp2.name] || self.globals[exp2.name] || exp2;\n    }\n\n    // Convert ref[prop] => ref.child(prop)\n    function snapshotChild(ref: ast.ExpReference): ast.Exp {\n      return ast.cast(ast.call(ast.reference(ref.base, ast.string('child')),\n                               [ref.accessor]),\n                      'Snapshot');\n    }\n\n    switch (exp.type) {\n    case 'op':\n      let expOp = <ast.ExpOp> ast.copyExp(exp);\n      // Ensure arguments are boolean (or values) where needed.\n      if (expOp.op === 'value') {\n        expOp.args[0] = valueExpression(expOp.args[0]);\n      } else if (expOp.op === '||' || expOp.op === '&&' || expOp.op === '!') {\n        for (let i = 0; i < expOp.args.length; i++) {\n          expOp.args[i] = booleanExpression(expOp.args[i]);\n        }\n      } else if (expOp.op === '?:') {\n        expOp.args[0] = booleanExpression(expOp.args[0]);\n        expOp.args[1] = valueExpression(expOp.args[1]);\n        expOp.args[2] = valueExpression(expOp.args[2]);\n      } else {\n        for (let i = 0; i < expOp.args.length; i++) {\n          expOp.args[i] = valueExpression(expOp.args[i]);\n        }\n      }\n      return expOp;\n\n    case 'var':\n      return lookupVar(<ast.ExpVariable> exp);\n\n    case 'ref':\n      let expRef = <ast.ExpReference> ast.copyExp(exp);\n      expRef.base = subExpression(expRef.base);\n\n      // var[ref] => var[ref]\n      if (expRef.base.valueType !== 'Snapshot') {\n        expRef.accessor = subExpression(expRef.accessor);\n        return expRef;\n      }\n\n      let propName = ast.getPropName(expRef);\n\n      // snapshot.prop (static string property)\n      if (propName !== '') {\n        // snapshot.valueMethod => snapshot.val().valueMethod\n        if (util.arrayIncludes(valueMethods, propName)) {\n          expRef.base = valueExpression(expRef.base);\n          return expRef;\n        }\n\n        // snapshot.ssMethod => snapshot.ssMethod\n        if (util.arrayIncludes(snapshotMethods, propName)) {\n          return expRef;\n        }\n      }\n\n      // snapshot[exp] => snapshot.child(exp) or\n      // snapshot[ref] => snapshot.child(ref.val())\n      expRef.accessor = valueExpression(expRef.accessor);\n      return snapshotChild(expRef);\n\n    case 'call':\n      let expCall = <ast.ExpCall> ast.copyExp(exp);\n      expCall.ref = <ast.ExpVariable | ast.ExpReference> subExpression(expCall.ref);\n      var callee = this.lookupFunction(expCall.ref);\n\n      // Expand the function call inline\n      if (callee) {\n        var fn = callee.fn;\n\n        if (callee.self) {\n          expCall.args.unshift(ast.ensureValue(callee.self));\n        }\n\n        if (fn.params.length !== expCall.args.length) {\n          this.fatal(errors.mismatchParams + \" ( \" +\n                     callee.methodName + \" expects \" + fn.params.length +\n                     \" but actually passed \" + expCall.args.length + \")\");\n          return exp;\n        }\n\n        if (fn.body.type === 'builtin') {\n          return (<ast.ExpBuiltin> fn.body).fn(expCall.args, params);\n        }\n\n        let innerParams = <ast.Params> {};\n\n        for (let i = 0; i < fn.params.length; i++) {\n          innerParams[fn.params[i]] = subExpression(expCall.args[i]);\n        }\n        if (functionCalls[callee.methodName]) {\n          throw new Error(errors.recursive + \" (\" + callee.methodName + \")\");\n        }\n        functionCalls[callee.methodName] = true;\n        let result = this.partialEval(fn.body, innerParams, functionCalls);\n        functionCalls[callee.methodName] = false;\n        return result;\n      }\n\n      // Can't expand function - but just expand the arguments.\n      if (!this.allowUndefinedFunctions) {\n        var funcName = ast.getMethodName(expCall);\n        if (funcName !== '' && !(funcName in this.symbols.schema['String'].methods ||\n              util.arrayIncludes(snapshotMethods, funcName))) {\n          this.fatal(errors.undefinedFunction + ast.decodeExpression(expCall.ref));\n        }\n      }\n\n      for (let i = 0; i < expCall.args.length; i++) {\n        expCall.args[i] = subExpression(expCall.args[i]);\n      }\n\n      // Hack for snapshot.parent().val()\n      // Todo - build table-based method signatures.\n      if (ast.getMethodName(expCall) === 'parent') {\n        expCall = <ast.ExpCall> ast.cast(expCall, 'Snapshot');\n      }\n\n      return expCall;\n\n    // Expression types (like literals) than need no expansion.\n    default:\n      return exp;\n    }\n  }\n\n  // Builtin function - convert all 'this' to 'data' (from 'newData').\n  // Args are function arguments, and params are the local (function) scope variables.\n  prior(args: ast.Exp[], params: ast.Params): ast.Exp {\n    var lastThisIs = this.thisIs;\n    this.thisIs = 'data';\n    var exp = this.partialEval(args[0], params);\n    this.thisIs = lastThisIs;\n    return exp;\n  }\n\n  // Builtin function - current value of 'this'\n  getThis(args: ast.Exp[], params: ast.Params): ast.Exp {\n    return ast.snapshotVariable(this.thisIs);\n  }\n\n  // Builtin function - ensure type of argument\n  ensureType(type: string, args: ast.Exp[], params: ast.Params) {\n    if (args.length !== 1) {\n      throw new Error(errors.application + \"ensureType arguments.\");\n    }\n    var exp = <ast.ExpValue> this.partialEval(args[0], params);\n    if (exp.type !== type) {\n      throw new Error(errors.coercion + ast.decodeExpression(exp) + \" => \" + type);\n    }\n    return exp;\n  }\n\n  // Builtin function - return the parent key of 'this'.\n  getKey(key: string, args: ast.Exp[], params: ast.Params) {\n    if (args.length !== 0) {\n      throw new Error(errors.mismatchParams + \"(found \" + args.length + \" but expected 1)\");\n    }\n\n    return key[0] === '$' ? ast.literal(key) : ast.string(key);\n  }\n\n  // Builtin function - return the reference to the root\n  // When in read mode - use 'root'\n  // When in write/validate - use path to root via newData.parent()...\n  getRootReference(path: ast.PathTemplate, args: ast.Exp[], params: ast.Params) {\n    if (args.length !== 0) {\n      throw new Error(errors.application + \"@root arguments.\");\n    }\n\n    // 'data' case\n    if (this.thisIs === 'data') {\n      return ast.snapshotVariable('root');\n    }\n\n    // TODO(koss): Remove this special case if JSON supports newRoot instead.\n    // 'newData' case - traverse to root via parent()'s.\n    let result: ast.Exp = ast.snapshotVariable('newData');\n    for (let i = 0; i < path.length(); i++) {\n      result = ast.snapshotParent(result);\n    }\n    return result;\n  }\n\n  // Lookup globally defined function.\n  lookupFunction(ref: ast.ExpVariable | ast.ExpReference): {\n    self?: ast.Exp,\n    fn: ast.Method,\n    methodName: string\n  } | undefined {\n    // Function call.\n    if (ref.type === 'var') {\n      let refVar = <ast.ExpVariable> ref;\n      var fn = this.symbols.functions[refVar.name];\n      if (!fn) {\n        return undefined;\n      }\n      return { self: undefined, fn: fn, methodName: refVar.name};\n    }\n\n    // Method call.\n    if (ref.type === 'ref') {\n      let refRef = <ast.ExpReference> ref;\n      // TODO: Require static type validation before calling String methods.\n      if ((<ast.ExpOp> refRef.base).op !== 'value' &&\n          <string> (<ast.ExpValue> refRef.accessor).value in this.symbols.schema['String'].methods) {\n        let methodName = <string> (<ast.ExpValue> refRef.accessor).value;\n        return { self: refRef.base,\n                 fn: this.symbols.schema['String'].methods[methodName],\n                 methodName: 'String.' + methodName\n               };\n      }\n    }\n    return undefined;\n  }\n\n  fatal(s: string) {\n    error(s);\n    this.errorCount += 1;\n  }\n};\n\n// Merge all .X terms into target.\nexport function extendValidator(target: Validator, src: Validator): Validator {\n  if (src === undefined) {\n    throw new Error(errors.application + \"Illegal validation source.\");\n  }\n  for (var prop in src) {\n    if (!src.hasOwnProperty(prop)) {\n      continue;\n    }\n    if (prop[0] === '.') {\n      if (target[prop] === undefined) {\n        target[prop] = [];\n      }\n      if (util.isType(src[prop], 'array')) {\n        util.extendArray(<any[]> target[prop], <any[]> src[prop]);\n      } else {\n        (<ast.Exp[]> target[prop]).push(<ast.Exp> src[prop]);\n      }\n    } else {\n      if (!target[prop]) {\n        target[prop] = {};\n      }\n      extendValidator(<Validator> target[prop], <Validator> src[prop]);\n    }\n  }\n\n  return target;\n}\n\n// Call fn(value, prop, path) on all '.props' and assiging the value back into the\n// validator.\nexport function mapValidator(v: Validator,\n                             fn: (val: ValidatorValue,\n                                  prop: string,\n                                  scope: ast.Params,\n                                  path: ast.PathTemplate) => ValidatorValue | undefined,\n                             scope?: ast.Params,\n                             path?: ast.PathTemplate) {\n  if (!scope) {\n    scope = <ast.Params> {};\n  }\n  if (!path) {\n    path = new ast.PathTemplate();\n  }\n  if ('.scope' in v) {\n    scope = <ast.Params> v['.scope'];\n  }\n  for (var prop in v) {\n    if (!v.hasOwnProperty(prop)) {\n      continue;\n    }\n    if (prop[0] === '.') {\n      let value = fn(v[prop], prop, scope, path);\n      if (value !== undefined) {\n        v[prop] = value;\n      } else {\n        delete v[prop];\n      }\n    } else if (!util.isType(v[prop], 'object')) {\n      continue;\n    } else {\n      let child = new ast.PathTemplate([prop]);\n      path.push(child);\n      mapValidator(<Validator> v[prop], fn, scope, path);\n      path.pop(child);\n    }\n  }\n}\n\n// Collapse all hasChildren calls into one (combining their arguments).\n// E.g. [newData.hasChildren(), newData.hasChildren(['x']), newData.hasChildren(['y'])] =>\n//      newData.hasChildren(['x', 'y'])\nfunction collapseHasChildren(exps: ast.Exp[]): ast.Exp[] {\n  var hasHasChildren: boolean = false;\n  var combined = <string[]> [];\n  var result = <ast.Exp[]> [];\n  exps.forEach(function(exp) {\n    if (exp.type !== 'call') {\n      result.push(exp);\n      return;\n    }\n\n    let expCall = <ast.ExpCall> exp;\n    if (ast.getMethodName(expCall) !== 'hasChildren') {\n      result.push(exp);\n      return;\n    }\n\n    if (expCall.args.length === 0) {\n      hasHasChildren = true;\n      return;\n    }\n\n    // Expect one argument of Array type.\n    if (expCall.args.length !== 1 || expCall.args[0].type !== 'Array') {\n      throw new Error(errors.application + \"Invalid argument to hasChildren(): \" +\n                      expCall.args[0].type);\n    }\n    let args = (<ast.ExpValue> expCall.args[0]).value;\n\n    args.forEach(function(arg: ast.ExpValue) {\n      hasHasChildren = true;\n      if (arg.type !== 'String') {\n        throw new Error(errors.application + \"Expect string argument to hasChildren(), not: \" +\n                        arg.type);\n      }\n      combined.push(arg.value);\n    });\n  });\n\n  if (hasHasChildren) {\n    result.unshift(hasChildrenExp(combined));\n  }\n  return result;\n}\n\n// Generate this.hasChildren([props, ...]) or this.hasChildren()\nfunction hasChildrenExp(props: string[]): ast.Exp {\n  var args = props.length === 0 ? [] : [ast.array(props.map(ast.string))];\n  return ast.call(ast.reference(ast.cast(ast.variable('this'), 'Any'), ast.string('hasChildren')),\n                  args);\n}\n","module.exports = (function() {\n  /*\n   * Generated by PEG.js 0.8.0.\n   *\n   * http://pegjs.majda.cz/\n   */\n\n  function peg$subclass(child, parent) {\n    function ctor() { this.constructor = child; }\n    ctor.prototype = parent.prototype;\n    child.prototype = new ctor();\n  }\n\n  function SyntaxError(message, expected, found, offset, line, column) {\n    this.message  = message;\n    this.expected = expected;\n    this.found    = found;\n    this.offset   = offset;\n    this.line     = line;\n    this.column   = column;\n\n    this.name     = \"SyntaxError\";\n  }\n\n  peg$subclass(SyntaxError, Error);\n\n  function parse(input) {\n    var options = arguments.length > 1 ? arguments[1] : {},\n\n        peg$FAILED = {},\n\n        peg$startRuleFunctions = { start: peg$parsestart },\n        peg$startRuleFunction  = peg$parsestart,\n\n        peg$c0 = peg$FAILED,\n        peg$c1 = function() {\n          if (logger.hasErrors()) {\n            throw(new Error(logger.errorSummary()));\n          }\n          return symbols;\n        },\n        peg$c2 = [],\n        peg$c3 = { type: \"other\", description: \"function definition\" },\n        peg$c4 = null,\n        peg$c5 = function(func, body) {\n          if (func.name === null) {\n            error(\"Missing function name.\");\n            return;\n          }\n          if (func.params === null) {\n            error(\"Function \" + func.name + \" missing parameters.\");\n            return;\n          }\n          if (body === null) {\n            error(\"Function \" + func.name + \" missing or invalid function body.\");\n            return;\n          }\n          symbols.registerFunction(ensureLowerCase(func.name, \"Function names\"), func.params, body);\n        },\n        peg$c6 = \"function\",\n        peg$c7 = { type: \"literal\", value: \"function\", description: \"\\\"function\\\"\" },\n        peg$c8 = function(name, params) { return {name: name, params: params}; },\n        peg$c9 = function(name, params) {return {name: name, params: params}; },\n        peg$c10 = { type: \"other\", description: \"path statement\" },\n        peg$c11 = \"is\",\n        peg$c12 = { type: \"literal\", value: \"is\", description: \"\\\"is\\\"\" },\n        peg$c13 = function(id) { return id; },\n        peg$c14 = \"{\",\n        peg$c15 = { type: \"literal\", value: \"{\", description: \"\\\"{\\\"\" },\n        peg$c16 = \"}\",\n        peg$c17 = { type: \"literal\", value: \"}\", description: \"\\\"}\\\"\" },\n        peg$c18 = function(all) { return all; },\n        peg$c19 = \";\",\n        peg$c20 = { type: \"literal\", value: \";\", description: \"\\\";\\\"\" },\n        peg$c21 = function() { return {}; },\n        peg$c22 = function(path, isType, methods) {\n            if (path === null) {\n              return;\n            }\n            if (methods === null) {\n              error(\"Missing body of path statement.\");\n              return;\n            }\n            symbols.registerPath(currentPath, isType, methods);\n            currentPath.pop(path);\n          },\n        peg$c23 = \"path\",\n        peg$c24 = { type: \"literal\", value: \"path\", description: \"\\\"path\\\"\" },\n        peg$c25 = function(path) {\n            if (path === null) {\n              error(\"Missing Path Template in path statement.\");\n              return path;\n            }\n            currentPath.push(path);\n            return path;\n          },\n        peg$c26 = function(path) {\n            currentPath.push(path); return path;\n          },\n        peg$c27 = { type: \"other\", description: \"path template\" },\n        peg$c28 = \"/\",\n        peg$c29 = { type: \"literal\", value: \"/\", description: \"\\\"/\\\"\" },\n        peg$c30 = function(part) { return part; },\n        peg$c31 = function(parts) {\n          var hasError = false;\n          if (parts.length === 1 && parts[0] === null) {\n            parts = [];\n          }\n          parts = parts.map(function(part) {\n            if (part === null) {\n              hasError = true;\n              return '';\n            }\n            return part;\n          });\n          if (hasError) {\n            error((parts[parts.length - 1] === ''\n                   ? \"Paths may not end in a slash (/) character\"\n                   : \"Paths may not contain an empty part\") + \": /\" + parts.map(function(part) { return part.label; }).join('/'));\n          }\n          return new ast.PathTemplate(parts);\n        },\n        peg$c32 = \"=\",\n        peg$c33 = { type: \"literal\", value: \"=\", description: \"\\\"=\\\"\" },\n        peg$c34 = \"*\",\n        peg$c35 = { type: \"literal\", value: \"*\", description: \"\\\"*\\\"\" },\n        peg$c36 = function(id) {\n          return new ast.PathPart(id, id);\n        },\n        peg$c37 = /^[^ \\/;]/,\n        peg$c38 = { type: \"class\", value: \"[^ \\\\/;]\", description: \"[^ \\\\/;]\" },\n        peg$c39 = function(chars) {\n          var result = chars.join('');\n          if (chars[0] === '$') {\n            warn(\"Use of \" + result + \" to capture a path segment is deprecated; \" +\n                 \"use {\" + result + \"} or {\" + result.slice(1) + \"}, instead.\");\n          }\n          return new ast.PathPart(result);\n        },\n        peg$c40 = function(all) {\n          var result = {};\n          for (var i = 0; i < all.length; i++) {\n            var method = all[i];\n            // Skip embedded path statements.\n            if (method === undefined) {\n              continue;\n            }\n            if (typeof method == 'string') {\n              error(\"Invalid path or method: '\" + method + \"'.\");\n              continue;\n            }\n            if (method.name in result) {\n              error(\"Duplicate method name: \" + method.name);\n            }\n            result[method.name] = ast.method(method.params, method.body);\n          }\n          return result;\n        },\n        peg$c41 = { type: \"other\", description: \"type statement\" },\n        peg$c42 = \"type\",\n        peg$c43 = { type: \"literal\", value: \"type\", description: \"\\\"type\\\"\" },\n        peg$c44 = \"<\",\n        peg$c45 = { type: \"literal\", value: \"<\", description: \"\\\"<\\\"\" },\n        peg$c46 = \">\",\n        peg$c47 = { type: \"literal\", value: \">\", description: \"\\\">\\\"\" },\n        peg$c48 = function(list) { return ensureUpperCase(list, \"Type names\"); },\n        peg$c49 = \"extends\",\n        peg$c50 = { type: \"literal\", value: \"extends\", description: \"\\\"extends\\\"\" },\n        peg$c51 = function(type) { return type; },\n        peg$c52 = function() { return {properties: {}, methods: {}}; },\n        peg$c53 = function(type, params, ext, body) {\n            if (params === null) {\n              params = [];\n            }\n            if (type === null) {\n              error(\"Missing type name.\");\n              return;\n            }\n            if (body === null) {\n              error(\"Missing or invalid type statement body.\");\n              return;\n            }\n            symbols.registerSchema(ensureUpperCase(type, \"Type names\"),\n                                   ext, body.properties, body.methods, params);\n        },\n        peg$c54 = function(all) {\n          var result = {\n             properties: {},\n             methods: {}\n          };\n\n          function addPart(part) {\n            // TODO: Make sure methods and properties don't shadow each other.\n            if (typeof part === 'string') {\n              error(\"Invalid property or method: '\" + part + \"'.\");\n              return;\n            }\n            if ('type' in part) {\n              if (result.properties[part.name]) {\n                error(\"Duplicate property name: \" + part.name);\n              }\n              result.properties[part.name] = part.type;\n            } else {\n              if (result.methods[part.name]) {\n                error(\"Duplicate method name: \" + part.name);\n              }\n              result.methods[part.name] = ast.method(part.params, part.body);\n            }\n          }\n\n          for (var i = 0; i < all.length; i++) {\n            addPart(all[i]);\n          }\n\n          return result;\n        },\n        peg$c55 = \":\",\n        peg$c56 = { type: \"literal\", value: \":\", description: \"\\\":\\\"\" },\n        peg$c57 = function(name, type) {\n          return {\n            name:  name,\n            type: type\n          };\n        },\n        peg$c58 = \",\",\n        peg$c59 = { type: \"literal\", value: \",\", description: \"\\\",\\\"\" },\n        peg$c60 = function(sep) { return sep; },\n        peg$c61 = { type: \"other\", description: \"method\" },\n        peg$c62 = function(name, params, body, sep) {\n          if (sep !== null) {\n            warn(\"Extra separator (\" + sep + \") not needed.\");\n          }\n          return {\n            name:  ensureLowerCase(name, \"Method names\"),\n            params: params,\n            body:  body\n          };\n        },\n        peg$c63 = \"return\",\n        peg$c64 = { type: \"literal\", value: \"return\", description: \"\\\"return\\\"\" },\n        peg$c65 = function(exp) { return exp; },\n        peg$c66 = function(exp) {\n            warn(\"Use of fn(x) = exp; format is deprecated; use fn(x) { exp }, instead.\")\n            return exp;\n          },\n        peg$c67 = \"(\",\n        peg$c68 = { type: \"literal\", value: \"(\", description: \"\\\"(\\\"\" },\n        peg$c69 = \")\",\n        peg$c70 = { type: \"literal\", value: \")\", description: \"\\\")\\\"\" },\n        peg$c71 = function(list) { return ensureLowerCase(list, \"Function arguments\"); },\n        peg$c72 = function(head, tail) {\n          if (!head) {\n            return [];\n          }\n          tail.unshift(head);\n          return tail;\n        },\n        peg$c73 = \"|\",\n        peg$c74 = { type: \"literal\", value: \"|\", description: \"\\\"|\\\"\" },\n        peg$c75 = function(head, tail) {\n          if (tail.length == 0) {\n            return head;\n          }\n          tail.unshift(head);\n          return ast.unionType(tail);\n        },\n        peg$c76 = \"[]\",\n        peg$c77 = { type: \"literal\", value: \"[]\", description: \"\\\"[]\\\"\" },\n        peg$c78 = function() {return {isMap: true}; },\n        peg$c79 = function(types) {return {types: types};},\n        peg$c80 = function(type, opt) {\n          type = ensureUpperCase(type, \"Type names\");\n          if (!opt) {\n            return ast.typeType(type);\n          }\n          if (opt.isMap) {\n            return ast.genericType('Map', [ast.typeType('String'),\n                                           ast.typeType(type)]);\n          }\n          return ast.genericType(type, opt.types);\n        },\n        peg$c81 = function(head, tail) {\n          var result = [head];\n          util.extendArray(result, tail);\n          return result;\n        },\n        peg$c82 = void 0,\n        peg$c83 = function(name) { return ast.variable(name); },\n        peg$c84 = function(expression) { return expression; },\n        peg$c85 = \"[\",\n        peg$c86 = { type: \"literal\", value: \"[\", description: \"\\\"[\\\"\" },\n        peg$c87 = \"]\",\n        peg$c88 = { type: \"literal\", value: \"]\", description: \"\\\"]\\\"\" },\n        peg$c89 = function(name) { return name; },\n        peg$c90 = \".\",\n        peg$c91 = { type: \"literal\", value: \".\", description: \"\\\".\\\"\" },\n        peg$c92 = function(base, accessors) {\n              var result = base;\n              for (var i = 0; i < accessors.length; i++) {\n                var exp = typeof accessors[i] == 'string' ? ast.string(accessors[i]) : accessors[i];\n                result = ast.reference(result, exp);\n              }\n              return result;\n            },\n        peg$c93 = function(ref, args) {\n                return ast.call(ref, args);\n              },\n        peg$c94 = function(args) { return args },\n        peg$c95 = function(name) { return name },\n        peg$c96 = function(base, argumentsOrAccessors) {\n              var result = base;\n              for (var i = 0; i < argumentsOrAccessors.length; i++) {\n                var part = argumentsOrAccessors[i];\n                if (typeof part == 'string') {\n                  result = ast.reference(result, ast.string(part));\n                } else if (util.isType(part, 'array')) {\n                  result = ast.call(result, part);\n                } else {\n                  result = ast.reference(result, part);\n                }\n              }\n              return result;\n            },\n        peg$c97 = function(args) {\n          return args !== null ? args : [];\n        },\n        peg$c98 = function(head, tail) {\n          tail.unshift(head);\n          return tail;\n        },\n        peg$c99 = function(op, expression) {\n              if (op == \"noop\") {\n                return expression;\n              }\n              return ast.op(op, [expression]);\n            },\n        peg$c100 = \"+\",\n        peg$c101 = { type: \"literal\", value: \"+\", description: \"\\\"+\\\"\" },\n        peg$c102 = function() { return \"noop\"; },\n        peg$c103 = \"-\",\n        peg$c104 = { type: \"literal\", value: \"-\", description: \"\\\"-\\\"\" },\n        peg$c105 = function() { return \"neg\"; },\n        peg$c106 = \"!\",\n        peg$c107 = { type: \"literal\", value: \"!\", description: \"\\\"!\\\"\" },\n        peg$c108 = function(op, exp) { return {op: op, exp: exp}; },\n        peg$c109 = function(head, tail) {\n              return leftAssociative(head, tail);\n            },\n        peg$c110 = \"%\",\n        peg$c111 = { type: \"literal\", value: \"%\", description: \"\\\"%\\\"\" },\n        peg$c112 = \"<=\",\n        peg$c113 = { type: \"literal\", value: \"<=\", description: \"\\\"<=\\\"\" },\n        peg$c114 = \">=\",\n        peg$c115 = { type: \"literal\", value: \">=\", description: \"\\\">=\\\"\" },\n        peg$c116 = \"===\",\n        peg$c117 = { type: \"literal\", value: \"===\", description: \"\\\"===\\\"\" },\n        peg$c118 = \"==\",\n        peg$c119 = { type: \"literal\", value: \"==\", description: \"\\\"==\\\"\" },\n        peg$c120 = function() { return \"==\"; },\n        peg$c121 = function() { error(\"Equality operator should be written as ==, not =.\");  return \"==\"; },\n        peg$c122 = \"!==\",\n        peg$c123 = { type: \"literal\", value: \"!==\", description: \"\\\"!==\\\"\" },\n        peg$c124 = \"!=\",\n        peg$c125 = { type: \"literal\", value: \"!=\", description: \"\\\"!=\\\"\" },\n        peg$c126 = function() { return \"!=\"; },\n        peg$c127 = \"&&\",\n        peg$c128 = { type: \"literal\", value: \"&&\", description: \"\\\"&&\\\"\" },\n        peg$c129 = \"and\",\n        peg$c130 = { type: \"literal\", value: \"and\", description: \"\\\"and\\\"\" },\n        peg$c131 = function() { return \"&&\"; },\n        peg$c132 = \"||\",\n        peg$c133 = { type: \"literal\", value: \"||\", description: \"\\\"||\\\"\" },\n        peg$c134 = \"or\",\n        peg$c135 = { type: \"literal\", value: \"or\", description: \"\\\"or\\\"\" },\n        peg$c136 = function() { return \"||\"; },\n        peg$c137 = \"?\",\n        peg$c138 = { type: \"literal\", value: \"?\", description: \"\\\"?\\\"\" },\n        peg$c139 = function(condition, trueExpression, falseExpression) {\n              return ast.op('?:', [condition, trueExpression, falseExpression]);\n            },\n        peg$c140 = \"null\",\n        peg$c141 = { type: \"literal\", value: \"null\", description: \"\\\"null\\\"\" },\n        peg$c142 = function() { return ast.nullType() },\n        peg$c143 = function(elements) { return ast.array(elements); },\n        peg$c144 = \"true\",\n        peg$c145 = { type: \"literal\", value: \"true\", description: \"\\\"true\\\"\" },\n        peg$c146 = function() { return ast.boolean(true); },\n        peg$c147 = \"false\",\n        peg$c148 = { type: \"literal\", value: \"false\", description: \"\\\"false\\\"\" },\n        peg$c149 = function() { return ast.boolean(false); },\n        peg$c150 = { type: \"other\", description: \"number\" },\n        peg$c151 = /^[+\\-]/,\n        peg$c152 = { type: \"class\", value: \"[+\\\\-]\", description: \"[+\\\\-]\" },\n        peg$c153 = function(unary, literal) {\n              if (unary == '-') {\n                 return ast.number(-literal);\n              }\n              return ast.number(literal);\n            },\n        peg$c154 = function(parts) {\n              return parseFloat(parts);\n            },\n        peg$c155 = function(parts) { return parseFloat(parts); },\n        peg$c156 = \"0\",\n        peg$c157 = { type: \"literal\", value: \"0\", description: \"\\\"0\\\"\" },\n        peg$c158 = /^[0-9]/,\n        peg$c159 = { type: \"class\", value: \"[0-9]\", description: \"[0-9]\" },\n        peg$c160 = /^[1-9]/,\n        peg$c161 = { type: \"class\", value: \"[1-9]\", description: \"[1-9]\" },\n        peg$c162 = /^[eE]/,\n        peg$c163 = { type: \"class\", value: \"[eE]\", description: \"[eE]\" },\n        peg$c164 = /^[\\-+]/,\n        peg$c165 = { type: \"class\", value: \"[\\\\-+]\", description: \"[\\\\-+]\" },\n        peg$c166 = /^[xX]/,\n        peg$c167 = { type: \"class\", value: \"[xX]\", description: \"[xX]\" },\n        peg$c168 = function(digits) { return parseInt(digits, 16); },\n        peg$c169 = /^[0-9a-fA-F]/,\n        peg$c170 = { type: \"class\", value: \"[0-9a-fA-F]\", description: \"[0-9a-fA-F]\" },\n        peg$c171 = { type: \"other\", description: \"regexp\" },\n        peg$c172 = /^[a-z]/,\n        peg$c173 = { type: \"class\", value: \"[a-z]\", description: \"[a-z]\" },\n        peg$c174 = function(pattern, modifiers) {\n          if (modifiers) {\n            return ast.regexp(pattern, modifiers.join(\"\"));\n          }\n          return ast.regexp(pattern);\n        },\n        peg$c175 = /^[^\\\\\\/]/,\n        peg$c176 = { type: \"class\", value: \"[^\\\\\\\\\\\\/]\", description: \"[^\\\\\\\\\\\\/]\" },\n        peg$c177 = function(chars) { return chars.join(\"\"); },\n        peg$c178 = \"\\\\\",\n        peg$c179 = { type: \"literal\", value: \"\\\\\", description: \"\\\"\\\\\\\\\\\"\" },\n        peg$c180 = { type: \"any\", description: \"any character\" },\n        peg$c181 = function(char_) { return \"\\\\\" + char_; },\n        peg$c182 = { type: \"other\", description: \"string\" },\n        peg$c183 = function(s) { return ast.string(s); },\n        peg$c184 = \"\\\"\",\n        peg$c185 = { type: \"literal\", value: \"\\\"\", description: \"\\\"\\\\\\\"\\\"\" },\n        peg$c186 = \"'\",\n        peg$c187 = { type: \"literal\", value: \"'\", description: \"\\\"'\\\"\" },\n        peg$c188 = function(parts) {\n            return parts[1];\n          },\n        peg$c189 = function(char_) { return char_;     },\n        peg$c190 = function(sequence) { return sequence;  },\n        peg$c191 = function(sequence) { return sequence; },\n        peg$c192 = function() { return \"\\0\"; },\n        peg$c193 = /^['\"\\\\bfnrt]/,\n        peg$c194 = { type: \"class\", value: \"['\\\"\\\\\\\\bfnrt]\", description: \"['\\\"\\\\\\\\bfnrt]\" },\n        peg$c195 = function(char_) {\n              return char_\n                .replace(\"b\", \"\\b\")\n                .replace(\"f\", \"\\f\")\n                .replace(\"n\", \"\\n\")\n                .replace(\"r\", \"\\r\")\n                .replace(\"t\", \"\\t\")\n            },\n        peg$c196 = function(char_) { return char_; },\n        peg$c197 = \"x\",\n        peg$c198 = { type: \"literal\", value: \"x\", description: \"\\\"x\\\"\" },\n        peg$c199 = \"u\",\n        peg$c200 = { type: \"literal\", value: \"u\", description: \"\\\"u\\\"\" },\n        peg$c201 = function(digits) {\n              return String.fromCharCode(parseInt(digits, 16));\n            },\n        peg$c202 = { type: \"other\", description: \"identifier\" },\n        peg$c203 = /^[a-zA-Z_$]/,\n        peg$c204 = { type: \"class\", value: \"[a-zA-Z_$]\", description: \"[a-zA-Z_$]\" },\n        peg$c205 = /^[a-zA-Z_$0-9]/,\n        peg$c206 = { type: \"class\", value: \"[a-zA-Z_$0-9]\", description: \"[a-zA-Z_$0-9]\" },\n        peg$c207 = function(start, rest) {\n          return start + rest.join(\"\");\n        },\n        peg$c208 = { type: \"other\", description: \"whitespace\" },\n        peg$c209 = /^[ \\t\\r\\n]/,\n        peg$c210 = { type: \"class\", value: \"[ \\\\t\\\\r\\\\n]\", description: \"[ \\\\t\\\\r\\\\n]\" },\n        peg$c211 = { type: \"other\", description: \"comment\" },\n        peg$c212 = \"/*\",\n        peg$c213 = { type: \"literal\", value: \"/*\", description: \"\\\"/*\\\"\" },\n        peg$c214 = \"*/\",\n        peg$c215 = { type: \"literal\", value: \"*/\", description: \"\\\"*/\\\"\" },\n        peg$c216 = \"//\",\n        peg$c217 = { type: \"literal\", value: \"//\", description: \"\\\"//\\\"\" },\n        peg$c218 = /^[;,}]/,\n        peg$c219 = { type: \"class\", value: \"[;,}]\", description: \"[;,}]\" },\n        peg$c220 = function(chars) { return chars.join(''); },\n        peg$c221 = /^[\\n\\r]/,\n        peg$c222 = { type: \"class\", value: \"[\\\\n\\\\r]\", description: \"[\\\\n\\\\r]\" },\n\n        peg$currPos          = 0,\n        peg$reportedPos      = 0,\n        peg$cachedPos        = 0,\n        peg$cachedPosDetails = { line: 1, column: 1, seenCR: false },\n        peg$maxFailPos       = 0,\n        peg$maxFailExpected  = [],\n        peg$silentFails      = 0,\n\n        peg$result;\n\n    if (\"startRule\" in options) {\n      if (!(options.startRule in peg$startRuleFunctions)) {\n        throw new Error(\"Can't start parsing from rule \\\"\" + options.startRule + \"\\\".\");\n      }\n\n      peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n    }\n\n    function text() {\n      return input.substring(peg$reportedPos, peg$currPos);\n    }\n\n    function offset() {\n      return peg$reportedPos;\n    }\n\n    function line() {\n      return peg$computePosDetails(peg$reportedPos).line;\n    }\n\n    function column() {\n      return peg$computePosDetails(peg$reportedPos).column;\n    }\n\n    function expected(description) {\n      throw peg$buildException(\n        null,\n        [{ type: \"other\", description: description }],\n        peg$reportedPos\n      );\n    }\n\n    function error(message) {\n      throw peg$buildException(message, null, peg$reportedPos);\n    }\n\n    function peg$computePosDetails(pos) {\n      function advance(details, startPos, endPos) {\n        var p, ch;\n\n        for (p = startPos; p < endPos; p++) {\n          ch = input.charAt(p);\n          if (ch === \"\\n\") {\n            if (!details.seenCR) { details.line++; }\n            details.column = 1;\n            details.seenCR = false;\n          } else if (ch === \"\\r\" || ch === \"\\u2028\" || ch === \"\\u2029\") {\n            details.line++;\n            details.column = 1;\n            details.seenCR = true;\n          } else {\n            details.column++;\n            details.seenCR = false;\n          }\n        }\n      }\n\n      if (peg$cachedPos !== pos) {\n        if (peg$cachedPos > pos) {\n          peg$cachedPos = 0;\n          peg$cachedPosDetails = { line: 1, column: 1, seenCR: false };\n        }\n        advance(peg$cachedPosDetails, peg$cachedPos, pos);\n        peg$cachedPos = pos;\n      }\n\n      return peg$cachedPosDetails;\n    }\n\n    function peg$fail(expected) {\n      if (peg$currPos < peg$maxFailPos) { return; }\n\n      if (peg$currPos > peg$maxFailPos) {\n        peg$maxFailPos = peg$currPos;\n        peg$maxFailExpected = [];\n      }\n\n      peg$maxFailExpected.push(expected);\n    }\n\n    function peg$buildException(message, expected, pos) {\n      function cleanupExpected(expected) {\n        var i = 1;\n\n        expected.sort(function(a, b) {\n          if (a.description < b.description) {\n            return -1;\n          } else if (a.description > b.description) {\n            return 1;\n          } else {\n            return 0;\n          }\n        });\n\n        while (i < expected.length) {\n          if (expected[i - 1] === expected[i]) {\n            expected.splice(i, 1);\n          } else {\n            i++;\n          }\n        }\n      }\n\n      function buildMessage(expected, found) {\n        function stringEscape(s) {\n          function hex(ch) { return ch.charCodeAt(0).toString(16).toUpperCase(); }\n\n          return s\n            .replace(/\\\\/g,   '\\\\\\\\')\n            .replace(/\"/g,    '\\\\\"')\n            .replace(/\\x08/g, '\\\\b')\n            .replace(/\\t/g,   '\\\\t')\n            .replace(/\\n/g,   '\\\\n')\n            .replace(/\\f/g,   '\\\\f')\n            .replace(/\\r/g,   '\\\\r')\n            .replace(/[\\x00-\\x07\\x0B\\x0E\\x0F]/g, function(ch) { return '\\\\x0' + hex(ch); })\n            .replace(/[\\x10-\\x1F\\x80-\\xFF]/g,    function(ch) { return '\\\\x'  + hex(ch); })\n            .replace(/[\\u0180-\\u0FFF]/g,         function(ch) { return '\\\\u0' + hex(ch); })\n            .replace(/[\\u1080-\\uFFFF]/g,         function(ch) { return '\\\\u'  + hex(ch); });\n        }\n\n        var expectedDescs = new Array(expected.length),\n            expectedDesc, foundDesc, i;\n\n        for (i = 0; i < expected.length; i++) {\n          expectedDescs[i] = expected[i].description;\n        }\n\n        expectedDesc = expected.length > 1\n          ? expectedDescs.slice(0, -1).join(\", \")\n              + \" or \"\n              + expectedDescs[expected.length - 1]\n          : expectedDescs[0];\n\n        foundDesc = found ? \"\\\"\" + stringEscape(found) + \"\\\"\" : \"end of input\";\n\n        return \"Expected \" + expectedDesc + \" but \" + foundDesc + \" found.\";\n      }\n\n      var posDetails = peg$computePosDetails(pos),\n          found      = pos < input.length ? input.charAt(pos) : null;\n\n      if (expected !== null) {\n        cleanupExpected(expected);\n      }\n\n      return new SyntaxError(\n        message !== null ? message : buildMessage(expected, found),\n        expected,\n        found,\n        pos,\n        posDetails.line,\n        posDetails.column\n      );\n    }\n\n    function peg$parsestart() {\n      var s0, s1, s2, s3;\n\n      s0 = peg$currPos;\n      s1 = peg$parse_();\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parseStatements();\n        if (s2 !== peg$FAILED) {\n          s3 = peg$parse_();\n          if (s3 !== peg$FAILED) {\n            peg$reportedPos = s0;\n            s1 = peg$c1();\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseStatements() {\n      var s0, s1, s2, s3;\n\n      s0 = [];\n      s1 = peg$currPos;\n      s2 = peg$parseStatement();\n      if (s2 !== peg$FAILED) {\n        s3 = peg$parse_();\n        if (s3 !== peg$FAILED) {\n          s2 = [s2, s3];\n          s1 = s2;\n        } else {\n          peg$currPos = s1;\n          s1 = peg$c0;\n        }\n      } else {\n        peg$currPos = s1;\n        s1 = peg$c0;\n      }\n      while (s1 !== peg$FAILED) {\n        s0.push(s1);\n        s1 = peg$currPos;\n        s2 = peg$parseStatement();\n        if (s2 !== peg$FAILED) {\n          s3 = peg$parse_();\n          if (s3 !== peg$FAILED) {\n            s2 = [s2, s3];\n            s1 = s2;\n          } else {\n            peg$currPos = s1;\n            s1 = peg$c0;\n          }\n        } else {\n          peg$currPos = s1;\n          s1 = peg$c0;\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseStatement() {\n      var s0;\n\n      s0 = peg$parseFunction();\n      if (s0 === peg$FAILED) {\n        s0 = peg$parsePath();\n        if (s0 === peg$FAILED) {\n          s0 = peg$parseSchema();\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseFunction() {\n      var s0, s1, s2;\n\n      peg$silentFails++;\n      s0 = peg$currPos;\n      s1 = peg$parseFunctionStart();\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parseFunctionBody();\n        if (s2 === peg$FAILED) {\n          s2 = peg$c4;\n        }\n        if (s2 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c5(s1, s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n      peg$silentFails--;\n      if (s0 === peg$FAILED) {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c3); }\n      }\n\n      return s0;\n    }\n\n    function peg$parseFunctionStart() {\n      var s0, s1, s2, s3, s4, s5, s6;\n\n      s0 = peg$currPos;\n      if (input.substr(peg$currPos, 8) === peg$c6) {\n        s1 = peg$c6;\n        peg$currPos += 8;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c7); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parse__();\n        if (s2 !== peg$FAILED) {\n          s3 = peg$parseIdentifier();\n          if (s3 === peg$FAILED) {\n            s3 = peg$c4;\n          }\n          if (s3 !== peg$FAILED) {\n            s4 = peg$parse_();\n            if (s4 !== peg$FAILED) {\n              s5 = peg$parseParameterList();\n              if (s5 === peg$FAILED) {\n                s5 = peg$c4;\n              }\n              if (s5 !== peg$FAILED) {\n                s6 = peg$parse_();\n                if (s6 !== peg$FAILED) {\n                  peg$reportedPos = s0;\n                  s1 = peg$c8(s3, s5);\n                  s0 = s1;\n                } else {\n                  peg$currPos = s0;\n                  s0 = peg$c0;\n                }\n              } else {\n                peg$currPos = s0;\n                s0 = peg$c0;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$c0;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        s1 = peg$parseIdentifier();\n        if (s1 !== peg$FAILED) {\n          s2 = peg$parse_();\n          if (s2 !== peg$FAILED) {\n            s3 = peg$parseParameterList();\n            if (s3 !== peg$FAILED) {\n              s4 = peg$parse_();\n              if (s4 !== peg$FAILED) {\n                peg$reportedPos = s0;\n                s1 = peg$c9(s1, s3);\n                s0 = s1;\n              } else {\n                peg$currPos = s0;\n                s0 = peg$c0;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$c0;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parsePath() {\n      var s0, s1, s2, s3, s4, s5, s6, s7, s8;\n\n      peg$silentFails++;\n      s0 = peg$currPos;\n      s1 = peg$parsePathStart();\n      if (s1 !== peg$FAILED) {\n        s2 = peg$currPos;\n        s3 = peg$parse__();\n        if (s3 !== peg$FAILED) {\n          if (input.substr(peg$currPos, 2) === peg$c11) {\n            s4 = peg$c11;\n            peg$currPos += 2;\n          } else {\n            s4 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c12); }\n          }\n          if (s4 !== peg$FAILED) {\n            s5 = peg$parse__();\n            if (s5 !== peg$FAILED) {\n              s6 = peg$parseTypeExpression();\n              if (s6 !== peg$FAILED) {\n                peg$reportedPos = s2;\n                s3 = peg$c13(s6);\n                s2 = s3;\n              } else {\n                peg$currPos = s2;\n                s2 = peg$c0;\n              }\n            } else {\n              peg$currPos = s2;\n              s2 = peg$c0;\n            }\n          } else {\n            peg$currPos = s2;\n            s2 = peg$c0;\n          }\n        } else {\n          peg$currPos = s2;\n          s2 = peg$c0;\n        }\n        if (s2 === peg$FAILED) {\n          s2 = peg$c4;\n        }\n        if (s2 !== peg$FAILED) {\n          s3 = peg$parse_();\n          if (s3 !== peg$FAILED) {\n            s4 = peg$currPos;\n            if (input.charCodeAt(peg$currPos) === 123) {\n              s5 = peg$c14;\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c15); }\n            }\n            if (s5 !== peg$FAILED) {\n              s6 = peg$parse_();\n              if (s6 !== peg$FAILED) {\n                s7 = peg$parsePathsAndMethods();\n                if (s7 !== peg$FAILED) {\n                  if (input.charCodeAt(peg$currPos) === 125) {\n                    s8 = peg$c16;\n                    peg$currPos++;\n                  } else {\n                    s8 = peg$FAILED;\n                    if (peg$silentFails === 0) { peg$fail(peg$c17); }\n                  }\n                  if (s8 !== peg$FAILED) {\n                    peg$reportedPos = s4;\n                    s5 = peg$c18(s7);\n                    s4 = s5;\n                  } else {\n                    peg$currPos = s4;\n                    s4 = peg$c0;\n                  }\n                } else {\n                  peg$currPos = s4;\n                  s4 = peg$c0;\n                }\n              } else {\n                peg$currPos = s4;\n                s4 = peg$c0;\n              }\n            } else {\n              peg$currPos = s4;\n              s4 = peg$c0;\n            }\n            if (s4 === peg$FAILED) {\n              s4 = peg$currPos;\n              if (input.charCodeAt(peg$currPos) === 59) {\n                s5 = peg$c19;\n                peg$currPos++;\n              } else {\n                s5 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c20); }\n              }\n              if (s5 !== peg$FAILED) {\n                peg$reportedPos = s4;\n                s5 = peg$c21();\n              }\n              s4 = s5;\n            }\n            if (s4 === peg$FAILED) {\n              s4 = peg$c4;\n            }\n            if (s4 !== peg$FAILED) {\n              s5 = peg$parse_();\n              if (s5 !== peg$FAILED) {\n                peg$reportedPos = s0;\n                s1 = peg$c22(s1, s2, s4);\n                s0 = s1;\n              } else {\n                peg$currPos = s0;\n                s0 = peg$c0;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$c0;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n      peg$silentFails--;\n      if (s0 === peg$FAILED) {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c10); }\n      }\n\n      return s0;\n    }\n\n    function peg$parsePathStart() {\n      var s0, s1, s2, s3;\n\n      s0 = peg$currPos;\n      if (input.substr(peg$currPos, 4) === peg$c23) {\n        s1 = peg$c23;\n        peg$currPos += 4;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c24); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parse__();\n        if (s2 !== peg$FAILED) {\n          s3 = peg$parsePathTemplate();\n          if (s3 === peg$FAILED) {\n            s3 = peg$c4;\n          }\n          if (s3 !== peg$FAILED) {\n            peg$reportedPos = s0;\n            s1 = peg$c25(s3);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        s1 = peg$parsePathTemplate();\n        if (s1 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c26(s1);\n        }\n        s0 = s1;\n      }\n\n      return s0;\n    }\n\n    function peg$parsePathTemplate() {\n      var s0, s1, s2, s3, s4;\n\n      peg$silentFails++;\n      s0 = peg$currPos;\n      s1 = [];\n      s2 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 47) {\n        s3 = peg$c28;\n        peg$currPos++;\n      } else {\n        s3 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c29); }\n      }\n      if (s3 !== peg$FAILED) {\n        s4 = peg$parsePathKey();\n        if (s4 === peg$FAILED) {\n          s4 = peg$c4;\n        }\n        if (s4 !== peg$FAILED) {\n          peg$reportedPos = s2;\n          s3 = peg$c30(s4);\n          s2 = s3;\n        } else {\n          peg$currPos = s2;\n          s2 = peg$c0;\n        }\n      } else {\n        peg$currPos = s2;\n        s2 = peg$c0;\n      }\n      if (s2 !== peg$FAILED) {\n        while (s2 !== peg$FAILED) {\n          s1.push(s2);\n          s2 = peg$currPos;\n          if (input.charCodeAt(peg$currPos) === 47) {\n            s3 = peg$c28;\n            peg$currPos++;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c29); }\n          }\n          if (s3 !== peg$FAILED) {\n            s4 = peg$parsePathKey();\n            if (s4 === peg$FAILED) {\n              s4 = peg$c4;\n            }\n            if (s4 !== peg$FAILED) {\n              peg$reportedPos = s2;\n              s3 = peg$c30(s4);\n              s2 = s3;\n            } else {\n              peg$currPos = s2;\n              s2 = peg$c0;\n            }\n          } else {\n            peg$currPos = s2;\n            s2 = peg$c0;\n          }\n        }\n      } else {\n        s1 = peg$c0;\n      }\n      if (s1 !== peg$FAILED) {\n        peg$reportedPos = s0;\n        s1 = peg$c31(s1);\n      }\n      s0 = s1;\n      peg$silentFails--;\n      if (s0 === peg$FAILED) {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c27); }\n      }\n\n      return s0;\n    }\n\n    function peg$parsePathKey() {\n      var s0;\n\n      s0 = peg$parseCaptureKey();\n      if (s0 === peg$FAILED) {\n        s0 = peg$parseLiteralPathKey();\n      }\n\n      return s0;\n    }\n\n    function peg$parseCaptureKey() {\n      var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n\n      s0 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 123) {\n        s1 = peg$c14;\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c15); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parse_();\n        if (s2 !== peg$FAILED) {\n          s3 = peg$parseIdentifier();\n          if (s3 !== peg$FAILED) {\n            s4 = peg$parse_();\n            if (s4 !== peg$FAILED) {\n              s5 = peg$currPos;\n              if (input.charCodeAt(peg$currPos) === 61) {\n                s6 = peg$c32;\n                peg$currPos++;\n              } else {\n                s6 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c33); }\n              }\n              if (s6 !== peg$FAILED) {\n                s7 = peg$parse_();\n                if (s7 !== peg$FAILED) {\n                  if (input.charCodeAt(peg$currPos) === 42) {\n                    s8 = peg$c34;\n                    peg$currPos++;\n                  } else {\n                    s8 = peg$FAILED;\n                    if (peg$silentFails === 0) { peg$fail(peg$c35); }\n                  }\n                  if (s8 !== peg$FAILED) {\n                    s9 = peg$parse_();\n                    if (s9 !== peg$FAILED) {\n                      s6 = [s6, s7, s8, s9];\n                      s5 = s6;\n                    } else {\n                      peg$currPos = s5;\n                      s5 = peg$c0;\n                    }\n                  } else {\n                    peg$currPos = s5;\n                    s5 = peg$c0;\n                  }\n                } else {\n                  peg$currPos = s5;\n                  s5 = peg$c0;\n                }\n              } else {\n                peg$currPos = s5;\n                s5 = peg$c0;\n              }\n              if (s5 === peg$FAILED) {\n                s5 = peg$c4;\n              }\n              if (s5 !== peg$FAILED) {\n                if (input.charCodeAt(peg$currPos) === 125) {\n                  s6 = peg$c16;\n                  peg$currPos++;\n                } else {\n                  s6 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c17); }\n                }\n                if (s6 !== peg$FAILED) {\n                  peg$reportedPos = s0;\n                  s1 = peg$c36(s3);\n                  s0 = s1;\n                } else {\n                  peg$currPos = s0;\n                  s0 = peg$c0;\n                }\n              } else {\n                peg$currPos = s0;\n                s0 = peg$c0;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$c0;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseLiteralPathKey() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      s1 = [];\n      if (peg$c37.test(input.charAt(peg$currPos))) {\n        s2 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s2 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c38); }\n      }\n      if (s2 !== peg$FAILED) {\n        while (s2 !== peg$FAILED) {\n          s1.push(s2);\n          if (peg$c37.test(input.charAt(peg$currPos))) {\n            s2 = input.charAt(peg$currPos);\n            peg$currPos++;\n          } else {\n            s2 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c38); }\n          }\n        }\n      } else {\n        s1 = peg$c0;\n      }\n      if (s1 !== peg$FAILED) {\n        peg$reportedPos = s0;\n        s1 = peg$c39(s1);\n      }\n      s0 = s1;\n\n      return s0;\n    }\n\n    function peg$parsePathsAndMethods() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      s1 = [];\n      s2 = peg$parsePath();\n      if (s2 === peg$FAILED) {\n        s2 = peg$parseMethod();\n        if (s2 === peg$FAILED) {\n          s2 = peg$parseAnyBlock();\n        }\n      }\n      while (s2 !== peg$FAILED) {\n        s1.push(s2);\n        s2 = peg$parsePath();\n        if (s2 === peg$FAILED) {\n          s2 = peg$parseMethod();\n          if (s2 === peg$FAILED) {\n            s2 = peg$parseAnyBlock();\n          }\n        }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parse_();\n        if (s2 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c40(s1);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseSchema() {\n      var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;\n\n      peg$silentFails++;\n      s0 = peg$currPos;\n      if (input.substr(peg$currPos, 4) === peg$c42) {\n        s1 = peg$c42;\n        peg$currPos += 4;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c43); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parse__();\n        if (s2 !== peg$FAILED) {\n          s3 = peg$parseIdentifier();\n          if (s3 === peg$FAILED) {\n            s3 = peg$c4;\n          }\n          if (s3 !== peg$FAILED) {\n            s4 = peg$currPos;\n            if (input.charCodeAt(peg$currPos) === 60) {\n              s5 = peg$c44;\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c45); }\n            }\n            if (s5 !== peg$FAILED) {\n              s6 = peg$parseIdentifierList();\n              if (s6 !== peg$FAILED) {\n                if (input.charCodeAt(peg$currPos) === 62) {\n                  s7 = peg$c46;\n                  peg$currPos++;\n                } else {\n                  s7 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c47); }\n                }\n                if (s7 !== peg$FAILED) {\n                  peg$reportedPos = s4;\n                  s5 = peg$c48(s6);\n                  s4 = s5;\n                } else {\n                  peg$currPos = s4;\n                  s4 = peg$c0;\n                }\n              } else {\n                peg$currPos = s4;\n                s4 = peg$c0;\n              }\n            } else {\n              peg$currPos = s4;\n              s4 = peg$c0;\n            }\n            if (s4 === peg$FAILED) {\n              s4 = peg$c4;\n            }\n            if (s4 !== peg$FAILED) {\n              s5 = peg$currPos;\n              s6 = peg$parse__();\n              if (s6 !== peg$FAILED) {\n                if (input.substr(peg$currPos, 7) === peg$c49) {\n                  s7 = peg$c49;\n                  peg$currPos += 7;\n                } else {\n                  s7 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c50); }\n                }\n                if (s7 !== peg$FAILED) {\n                  s8 = peg$parse__();\n                  if (s8 !== peg$FAILED) {\n                    s9 = peg$parseTypeExpression();\n                    if (s9 !== peg$FAILED) {\n                      s10 = peg$parse_();\n                      if (s10 !== peg$FAILED) {\n                        peg$reportedPos = s5;\n                        s6 = peg$c51(s9);\n                        s5 = s6;\n                      } else {\n                        peg$currPos = s5;\n                        s5 = peg$c0;\n                      }\n                    } else {\n                      peg$currPos = s5;\n                      s5 = peg$c0;\n                    }\n                  } else {\n                    peg$currPos = s5;\n                    s5 = peg$c0;\n                  }\n                } else {\n                  peg$currPos = s5;\n                  s5 = peg$c0;\n                }\n              } else {\n                peg$currPos = s5;\n                s5 = peg$c0;\n              }\n              if (s5 === peg$FAILED) {\n                s5 = peg$c4;\n              }\n              if (s5 !== peg$FAILED) {\n                s6 = peg$currPos;\n                s7 = peg$parse_();\n                if (s7 !== peg$FAILED) {\n                  if (input.charCodeAt(peg$currPos) === 123) {\n                    s8 = peg$c14;\n                    peg$currPos++;\n                  } else {\n                    s8 = peg$FAILED;\n                    if (peg$silentFails === 0) { peg$fail(peg$c15); }\n                  }\n                  if (s8 !== peg$FAILED) {\n                    s9 = peg$parse_();\n                    if (s9 !== peg$FAILED) {\n                      s10 = peg$parsePropertiesAndMethods();\n                      if (s10 !== peg$FAILED) {\n                        if (input.charCodeAt(peg$currPos) === 125) {\n                          s11 = peg$c16;\n                          peg$currPos++;\n                        } else {\n                          s11 = peg$FAILED;\n                          if (peg$silentFails === 0) { peg$fail(peg$c17); }\n                        }\n                        if (s11 !== peg$FAILED) {\n                          peg$reportedPos = s6;\n                          s7 = peg$c18(s10);\n                          s6 = s7;\n                        } else {\n                          peg$currPos = s6;\n                          s6 = peg$c0;\n                        }\n                      } else {\n                        peg$currPos = s6;\n                        s6 = peg$c0;\n                      }\n                    } else {\n                      peg$currPos = s6;\n                      s6 = peg$c0;\n                    }\n                  } else {\n                    peg$currPos = s6;\n                    s6 = peg$c0;\n                  }\n                } else {\n                  peg$currPos = s6;\n                  s6 = peg$c0;\n                }\n                if (s6 === peg$FAILED) {\n                  s6 = peg$currPos;\n                  s7 = peg$parse_();\n                  if (s7 !== peg$FAILED) {\n                    if (input.charCodeAt(peg$currPos) === 59) {\n                      s8 = peg$c19;\n                      peg$currPos++;\n                    } else {\n                      s8 = peg$FAILED;\n                      if (peg$silentFails === 0) { peg$fail(peg$c20); }\n                    }\n                    if (s8 !== peg$FAILED) {\n                      peg$reportedPos = s6;\n                      s7 = peg$c52();\n                      s6 = s7;\n                    } else {\n                      peg$currPos = s6;\n                      s6 = peg$c0;\n                    }\n                  } else {\n                    peg$currPos = s6;\n                    s6 = peg$c0;\n                  }\n                }\n                if (s6 === peg$FAILED) {\n                  s6 = peg$c4;\n                }\n                if (s6 !== peg$FAILED) {\n                  peg$reportedPos = s0;\n                  s1 = peg$c53(s3, s4, s5, s6);\n                  s0 = s1;\n                } else {\n                  peg$currPos = s0;\n                  s0 = peg$c0;\n                }\n              } else {\n                peg$currPos = s0;\n                s0 = peg$c0;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$c0;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n      peg$silentFails--;\n      if (s0 === peg$FAILED) {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c41); }\n      }\n\n      return s0;\n    }\n\n    function peg$parsePropertiesAndMethods() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      s1 = [];\n      s2 = peg$parseProperty();\n      if (s2 === peg$FAILED) {\n        s2 = peg$parseMethod();\n        if (s2 === peg$FAILED) {\n          s2 = peg$parseAnyBlock();\n        }\n      }\n      while (s2 !== peg$FAILED) {\n        s1.push(s2);\n        s2 = peg$parseProperty();\n        if (s2 === peg$FAILED) {\n          s2 = peg$parseMethod();\n          if (s2 === peg$FAILED) {\n            s2 = peg$parseAnyBlock();\n          }\n        }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parse_();\n        if (s2 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c54(s1);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseProperty() {\n      var s0, s1, s2, s3, s4, s5, s6, s7;\n\n      s0 = peg$currPos;\n      s1 = peg$parseIdentifier();\n      if (s1 === peg$FAILED) {\n        s1 = peg$parseString();\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parse_();\n        if (s2 !== peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 58) {\n            s3 = peg$c55;\n            peg$currPos++;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c56); }\n          }\n          if (s3 !== peg$FAILED) {\n            s4 = peg$parse_();\n            if (s4 !== peg$FAILED) {\n              s5 = peg$parseTypeExpression();\n              if (s5 !== peg$FAILED) {\n                s6 = peg$parse_();\n                if (s6 !== peg$FAILED) {\n                  s7 = peg$parsePropSep();\n                  if (s7 !== peg$FAILED) {\n                    peg$reportedPos = s0;\n                    s1 = peg$c57(s1, s5);\n                    s0 = s1;\n                  } else {\n                    peg$currPos = s0;\n                    s0 = peg$c0;\n                  }\n                } else {\n                  peg$currPos = s0;\n                  s0 = peg$c0;\n                }\n              } else {\n                peg$currPos = s0;\n                s0 = peg$c0;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$c0;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parsePropSep() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 44) {\n        s1 = peg$c58;\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c59); }\n      }\n      if (s1 === peg$FAILED) {\n        if (input.charCodeAt(peg$currPos) === 59) {\n          s1 = peg$c19;\n          peg$currPos++;\n        } else {\n          s1 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c20); }\n        }\n      }\n      if (s1 === peg$FAILED) {\n        s1 = peg$c4;\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parse_();\n        if (s2 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c60(s1);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseMethod() {\n      var s0, s1, s2, s3, s4, s5;\n\n      peg$silentFails++;\n      s0 = peg$currPos;\n      s1 = peg$parseIdentifier();\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parseParameterList();\n        if (s2 !== peg$FAILED) {\n          s3 = peg$parse_();\n          if (s3 !== peg$FAILED) {\n            s4 = peg$parseFunctionBody();\n            if (s4 !== peg$FAILED) {\n              s5 = peg$parsePropSep();\n              if (s5 !== peg$FAILED) {\n                peg$reportedPos = s0;\n                s1 = peg$c62(s1, s2, s4, s5);\n                s0 = s1;\n              } else {\n                peg$currPos = s0;\n                s0 = peg$c0;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$c0;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n      peg$silentFails--;\n      if (s0 === peg$FAILED) {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c61); }\n      }\n\n      return s0;\n    }\n\n    function peg$parseFunctionBody() {\n      var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n\n      s0 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 123) {\n        s1 = peg$c14;\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c15); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parse_();\n        if (s2 !== peg$FAILED) {\n          s3 = peg$currPos;\n          if (input.substr(peg$currPos, 6) === peg$c63) {\n            s4 = peg$c63;\n            peg$currPos += 6;\n          } else {\n            s4 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c64); }\n          }\n          if (s4 !== peg$FAILED) {\n            s5 = peg$parse__();\n            if (s5 !== peg$FAILED) {\n              s4 = [s4, s5];\n              s3 = s4;\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n          if (s3 === peg$FAILED) {\n            s3 = peg$c4;\n          }\n          if (s3 !== peg$FAILED) {\n            s4 = peg$parseConditionalExpression();\n            if (s4 !== peg$FAILED) {\n              s5 = peg$parse_();\n              if (s5 !== peg$FAILED) {\n                if (input.charCodeAt(peg$currPos) === 59) {\n                  s6 = peg$c19;\n                  peg$currPos++;\n                } else {\n                  s6 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c20); }\n                }\n                if (s6 === peg$FAILED) {\n                  s6 = peg$c4;\n                }\n                if (s6 !== peg$FAILED) {\n                  s7 = peg$parse_();\n                  if (s7 !== peg$FAILED) {\n                    if (input.charCodeAt(peg$currPos) === 125) {\n                      s8 = peg$c16;\n                      peg$currPos++;\n                    } else {\n                      s8 = peg$FAILED;\n                      if (peg$silentFails === 0) { peg$fail(peg$c17); }\n                    }\n                    if (s8 !== peg$FAILED) {\n                      s9 = peg$parse_();\n                      if (s9 !== peg$FAILED) {\n                        peg$reportedPos = s0;\n                        s1 = peg$c65(s4);\n                        s0 = s1;\n                      } else {\n                        peg$currPos = s0;\n                        s0 = peg$c0;\n                      }\n                    } else {\n                      peg$currPos = s0;\n                      s0 = peg$c0;\n                    }\n                  } else {\n                    peg$currPos = s0;\n                    s0 = peg$c0;\n                  }\n                } else {\n                  peg$currPos = s0;\n                  s0 = peg$c0;\n                }\n              } else {\n                peg$currPos = s0;\n                s0 = peg$c0;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$c0;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 61) {\n          s1 = peg$c32;\n          peg$currPos++;\n        } else {\n          s1 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c33); }\n        }\n        if (s1 !== peg$FAILED) {\n          s2 = peg$parse_();\n          if (s2 !== peg$FAILED) {\n            s3 = peg$parseConditionalExpression();\n            if (s3 !== peg$FAILED) {\n              if (input.charCodeAt(peg$currPos) === 59) {\n                s4 = peg$c19;\n                peg$currPos++;\n              } else {\n                s4 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c20); }\n              }\n              if (s4 === peg$FAILED) {\n                s4 = peg$c4;\n              }\n              if (s4 !== peg$FAILED) {\n                s5 = peg$parse_();\n                if (s5 !== peg$FAILED) {\n                  peg$reportedPos = s0;\n                  s1 = peg$c66(s3);\n                  s0 = s1;\n                } else {\n                  peg$currPos = s0;\n                  s0 = peg$c0;\n                }\n              } else {\n                peg$currPos = s0;\n                s0 = peg$c0;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$c0;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseParameterList() {\n      var s0, s1, s2, s3, s4;\n\n      s0 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 40) {\n        s1 = peg$c67;\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c68); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parseIdentifierList();\n        if (s2 !== peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 41) {\n            s3 = peg$c69;\n            peg$currPos++;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c70); }\n          }\n          if (s3 !== peg$FAILED) {\n            s4 = peg$parse_();\n            if (s4 !== peg$FAILED) {\n              peg$reportedPos = s0;\n              s1 = peg$c71(s2);\n              s0 = s1;\n            } else {\n              peg$currPos = s0;\n              s0 = peg$c0;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseIdentifierList() {\n      var s0, s1, s2, s3, s4, s5, s6, s7;\n\n      s0 = peg$currPos;\n      s1 = peg$parseIdentifier();\n      if (s1 === peg$FAILED) {\n        s1 = peg$c4;\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        s3 = peg$currPos;\n        s4 = peg$parse_();\n        if (s4 !== peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 44) {\n            s5 = peg$c58;\n            peg$currPos++;\n          } else {\n            s5 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c59); }\n          }\n          if (s5 !== peg$FAILED) {\n            s6 = peg$parse_();\n            if (s6 !== peg$FAILED) {\n              s7 = peg$parseIdentifier();\n              if (s7 !== peg$FAILED) {\n                peg$reportedPos = s3;\n                s4 = peg$c13(s7);\n                s3 = s4;\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        } else {\n          peg$currPos = s3;\n          s3 = peg$c0;\n        }\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          s3 = peg$currPos;\n          s4 = peg$parse_();\n          if (s4 !== peg$FAILED) {\n            if (input.charCodeAt(peg$currPos) === 44) {\n              s5 = peg$c58;\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c59); }\n            }\n            if (s5 !== peg$FAILED) {\n              s6 = peg$parse_();\n              if (s6 !== peg$FAILED) {\n                s7 = peg$parseIdentifier();\n                if (s7 !== peg$FAILED) {\n                  peg$reportedPos = s3;\n                  s4 = peg$c13(s7);\n                  s3 = s4;\n                } else {\n                  peg$currPos = s3;\n                  s3 = peg$c0;\n                }\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        }\n        if (s2 !== peg$FAILED) {\n          s3 = peg$parse_();\n          if (s3 !== peg$FAILED) {\n            peg$reportedPos = s0;\n            s1 = peg$c72(s1, s2);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseTypeExpression() {\n      var s0, s1, s2, s3, s4, s5, s6, s7;\n\n      s0 = peg$currPos;\n      s1 = peg$parseSingleType();\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        s3 = peg$currPos;\n        s4 = peg$parse_();\n        if (s4 !== peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 124) {\n            s5 = peg$c73;\n            peg$currPos++;\n          } else {\n            s5 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c74); }\n          }\n          if (s5 !== peg$FAILED) {\n            s6 = peg$parse_();\n            if (s6 !== peg$FAILED) {\n              s7 = peg$parseSingleType();\n              if (s7 !== peg$FAILED) {\n                peg$reportedPos = s3;\n                s4 = peg$c51(s7);\n                s3 = s4;\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        } else {\n          peg$currPos = s3;\n          s3 = peg$c0;\n        }\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          s3 = peg$currPos;\n          s4 = peg$parse_();\n          if (s4 !== peg$FAILED) {\n            if (input.charCodeAt(peg$currPos) === 124) {\n              s5 = peg$c73;\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c74); }\n            }\n            if (s5 !== peg$FAILED) {\n              s6 = peg$parse_();\n              if (s6 !== peg$FAILED) {\n                s7 = peg$parseSingleType();\n                if (s7 !== peg$FAILED) {\n                  peg$reportedPos = s3;\n                  s4 = peg$c51(s7);\n                  s3 = s4;\n                } else {\n                  peg$currPos = s3;\n                  s3 = peg$c0;\n                }\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        }\n        if (s2 !== peg$FAILED) {\n          s3 = peg$parse_();\n          if (s3 !== peg$FAILED) {\n            peg$reportedPos = s0;\n            s1 = peg$c75(s1, s2);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseSingleType() {\n      var s0, s1, s2, s3, s4, s5, s6;\n\n      s0 = peg$currPos;\n      s1 = peg$parseIdentifier();\n      if (s1 !== peg$FAILED) {\n        s2 = peg$currPos;\n        if (input.substr(peg$currPos, 2) === peg$c76) {\n          s3 = peg$c76;\n          peg$currPos += 2;\n        } else {\n          s3 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c77); }\n        }\n        if (s3 !== peg$FAILED) {\n          peg$reportedPos = s2;\n          s3 = peg$c78();\n        }\n        s2 = s3;\n        if (s2 === peg$FAILED) {\n          s2 = peg$currPos;\n          if (input.charCodeAt(peg$currPos) === 60) {\n            s3 = peg$c44;\n            peg$currPos++;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c45); }\n          }\n          if (s3 !== peg$FAILED) {\n            s4 = peg$parse_();\n            if (s4 !== peg$FAILED) {\n              s5 = peg$parseTypeList();\n              if (s5 !== peg$FAILED) {\n                if (input.charCodeAt(peg$currPos) === 62) {\n                  s6 = peg$c46;\n                  peg$currPos++;\n                } else {\n                  s6 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c47); }\n                }\n                if (s6 !== peg$FAILED) {\n                  peg$reportedPos = s2;\n                  s3 = peg$c79(s5);\n                  s2 = s3;\n                } else {\n                  peg$currPos = s2;\n                  s2 = peg$c0;\n                }\n              } else {\n                peg$currPos = s2;\n                s2 = peg$c0;\n              }\n            } else {\n              peg$currPos = s2;\n              s2 = peg$c0;\n            }\n          } else {\n            peg$currPos = s2;\n            s2 = peg$c0;\n          }\n        }\n        if (s2 === peg$FAILED) {\n          s2 = peg$c4;\n        }\n        if (s2 !== peg$FAILED) {\n          s3 = peg$parse_();\n          if (s3 !== peg$FAILED) {\n            peg$reportedPos = s0;\n            s1 = peg$c80(s1, s2);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseTypeList() {\n      var s0, s1, s2, s3, s4, s5, s6, s7;\n\n      s0 = peg$currPos;\n      s1 = peg$parseTypeExpression();\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        s3 = peg$currPos;\n        s4 = peg$parse_();\n        if (s4 !== peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 44) {\n            s5 = peg$c58;\n            peg$currPos++;\n          } else {\n            s5 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c59); }\n          }\n          if (s5 !== peg$FAILED) {\n            s6 = peg$parse_();\n            if (s6 !== peg$FAILED) {\n              s7 = peg$parseTypeExpression();\n              if (s7 !== peg$FAILED) {\n                peg$reportedPos = s3;\n                s4 = peg$c51(s7);\n                s3 = s4;\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        } else {\n          peg$currPos = s3;\n          s3 = peg$c0;\n        }\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          s3 = peg$currPos;\n          s4 = peg$parse_();\n          if (s4 !== peg$FAILED) {\n            if (input.charCodeAt(peg$currPos) === 44) {\n              s5 = peg$c58;\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c59); }\n            }\n            if (s5 !== peg$FAILED) {\n              s6 = peg$parse_();\n              if (s6 !== peg$FAILED) {\n                s7 = peg$parseTypeExpression();\n                if (s7 !== peg$FAILED) {\n                  peg$reportedPos = s3;\n                  s4 = peg$c51(s7);\n                  s3 = s4;\n                } else {\n                  peg$currPos = s3;\n                  s3 = peg$c0;\n                }\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        }\n        if (s2 !== peg$FAILED) {\n          s3 = peg$parse_();\n          if (s3 !== peg$FAILED) {\n            peg$reportedPos = s0;\n            s1 = peg$c81(s1, s2);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parsePrimaryExpression() {\n      var s0, s1, s2, s3, s4, s5;\n\n      s0 = peg$currPos;\n      s1 = peg$currPos;\n      peg$silentFails++;\n      s2 = peg$parseLiteral();\n      peg$silentFails--;\n      if (s2 === peg$FAILED) {\n        s1 = peg$c82;\n      } else {\n        peg$currPos = s1;\n        s1 = peg$c0;\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parseIdentifier();\n        if (s2 !== peg$FAILED) {\n          s3 = peg$parse_();\n          if (s3 !== peg$FAILED) {\n            peg$reportedPos = s0;\n            s1 = peg$c83(s2);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n      if (s0 === peg$FAILED) {\n        s0 = peg$parseLiteral();\n        if (s0 === peg$FAILED) {\n          s0 = peg$currPos;\n          if (input.charCodeAt(peg$currPos) === 40) {\n            s1 = peg$c67;\n            peg$currPos++;\n          } else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c68); }\n          }\n          if (s1 !== peg$FAILED) {\n            s2 = peg$parse_();\n            if (s2 !== peg$FAILED) {\n              s3 = peg$parseConditionalExpression();\n              if (s3 !== peg$FAILED) {\n                s4 = peg$parse_();\n                if (s4 !== peg$FAILED) {\n                  if (input.charCodeAt(peg$currPos) === 41) {\n                    s5 = peg$c69;\n                    peg$currPos++;\n                  } else {\n                    s5 = peg$FAILED;\n                    if (peg$silentFails === 0) { peg$fail(peg$c70); }\n                  }\n                  if (s5 !== peg$FAILED) {\n                    peg$reportedPos = s0;\n                    s1 = peg$c84(s3);\n                    s0 = s1;\n                  } else {\n                    peg$currPos = s0;\n                    s0 = peg$c0;\n                  }\n                } else {\n                  peg$currPos = s0;\n                  s0 = peg$c0;\n                }\n              } else {\n                peg$currPos = s0;\n                s0 = peg$c0;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$c0;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseMemberExpression() {\n      var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n\n      s0 = peg$currPos;\n      s1 = peg$parsePrimaryExpression();\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        s3 = peg$currPos;\n        s4 = peg$parse_();\n        if (s4 !== peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 91) {\n            s5 = peg$c85;\n            peg$currPos++;\n          } else {\n            s5 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c86); }\n          }\n          if (s5 !== peg$FAILED) {\n            s6 = peg$parse_();\n            if (s6 !== peg$FAILED) {\n              s7 = peg$parseConditionalExpression();\n              if (s7 !== peg$FAILED) {\n                s8 = peg$parse_();\n                if (s8 !== peg$FAILED) {\n                  if (input.charCodeAt(peg$currPos) === 93) {\n                    s9 = peg$c87;\n                    peg$currPos++;\n                  } else {\n                    s9 = peg$FAILED;\n                    if (peg$silentFails === 0) { peg$fail(peg$c88); }\n                  }\n                  if (s9 !== peg$FAILED) {\n                    peg$reportedPos = s3;\n                    s4 = peg$c89(s7);\n                    s3 = s4;\n                  } else {\n                    peg$currPos = s3;\n                    s3 = peg$c0;\n                  }\n                } else {\n                  peg$currPos = s3;\n                  s3 = peg$c0;\n                }\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        } else {\n          peg$currPos = s3;\n          s3 = peg$c0;\n        }\n        if (s3 === peg$FAILED) {\n          s3 = peg$currPos;\n          s4 = peg$parse_();\n          if (s4 !== peg$FAILED) {\n            if (input.charCodeAt(peg$currPos) === 46) {\n              s5 = peg$c90;\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c91); }\n            }\n            if (s5 !== peg$FAILED) {\n              s6 = peg$parse_();\n              if (s6 !== peg$FAILED) {\n                s7 = peg$parseIdentifier();\n                if (s7 !== peg$FAILED) {\n                  peg$reportedPos = s3;\n                  s4 = peg$c89(s7);\n                  s3 = s4;\n                } else {\n                  peg$currPos = s3;\n                  s3 = peg$c0;\n                }\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        }\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          s3 = peg$currPos;\n          s4 = peg$parse_();\n          if (s4 !== peg$FAILED) {\n            if (input.charCodeAt(peg$currPos) === 91) {\n              s5 = peg$c85;\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c86); }\n            }\n            if (s5 !== peg$FAILED) {\n              s6 = peg$parse_();\n              if (s6 !== peg$FAILED) {\n                s7 = peg$parseConditionalExpression();\n                if (s7 !== peg$FAILED) {\n                  s8 = peg$parse_();\n                  if (s8 !== peg$FAILED) {\n                    if (input.charCodeAt(peg$currPos) === 93) {\n                      s9 = peg$c87;\n                      peg$currPos++;\n                    } else {\n                      s9 = peg$FAILED;\n                      if (peg$silentFails === 0) { peg$fail(peg$c88); }\n                    }\n                    if (s9 !== peg$FAILED) {\n                      peg$reportedPos = s3;\n                      s4 = peg$c89(s7);\n                      s3 = s4;\n                    } else {\n                      peg$currPos = s3;\n                      s3 = peg$c0;\n                    }\n                  } else {\n                    peg$currPos = s3;\n                    s3 = peg$c0;\n                  }\n                } else {\n                  peg$currPos = s3;\n                  s3 = peg$c0;\n                }\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n          if (s3 === peg$FAILED) {\n            s3 = peg$currPos;\n            s4 = peg$parse_();\n            if (s4 !== peg$FAILED) {\n              if (input.charCodeAt(peg$currPos) === 46) {\n                s5 = peg$c90;\n                peg$currPos++;\n              } else {\n                s5 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c91); }\n              }\n              if (s5 !== peg$FAILED) {\n                s6 = peg$parse_();\n                if (s6 !== peg$FAILED) {\n                  s7 = peg$parseIdentifier();\n                  if (s7 !== peg$FAILED) {\n                    peg$reportedPos = s3;\n                    s4 = peg$c89(s7);\n                    s3 = s4;\n                  } else {\n                    peg$currPos = s3;\n                    s3 = peg$c0;\n                  }\n                } else {\n                  peg$currPos = s3;\n                  s3 = peg$c0;\n                }\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          }\n        }\n        if (s2 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c92(s1, s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseCallExpression() {\n      var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n\n      s0 = peg$currPos;\n      s1 = peg$currPos;\n      s2 = peg$parseMemberExpression();\n      if (s2 !== peg$FAILED) {\n        s3 = peg$parseArguments();\n        if (s3 !== peg$FAILED) {\n          peg$reportedPos = s1;\n          s2 = peg$c93(s2, s3);\n          s1 = s2;\n        } else {\n          peg$currPos = s1;\n          s1 = peg$c0;\n        }\n      } else {\n        peg$currPos = s1;\n        s1 = peg$c0;\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        s3 = peg$currPos;\n        s4 = peg$parse_();\n        if (s4 !== peg$FAILED) {\n          s5 = peg$parseArguments();\n          if (s5 !== peg$FAILED) {\n            peg$reportedPos = s3;\n            s4 = peg$c94(s5);\n            s3 = s4;\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        } else {\n          peg$currPos = s3;\n          s3 = peg$c0;\n        }\n        if (s3 === peg$FAILED) {\n          s3 = peg$currPos;\n          s4 = peg$parse_();\n          if (s4 !== peg$FAILED) {\n            if (input.charCodeAt(peg$currPos) === 91) {\n              s5 = peg$c85;\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c86); }\n            }\n            if (s5 !== peg$FAILED) {\n              s6 = peg$parse_();\n              if (s6 !== peg$FAILED) {\n                s7 = peg$parseConditionalExpression();\n                if (s7 !== peg$FAILED) {\n                  s8 = peg$parse_();\n                  if (s8 !== peg$FAILED) {\n                    if (input.charCodeAt(peg$currPos) === 93) {\n                      s9 = peg$c87;\n                      peg$currPos++;\n                    } else {\n                      s9 = peg$FAILED;\n                      if (peg$silentFails === 0) { peg$fail(peg$c88); }\n                    }\n                    if (s9 !== peg$FAILED) {\n                      peg$reportedPos = s3;\n                      s4 = peg$c95(s7);\n                      s3 = s4;\n                    } else {\n                      peg$currPos = s3;\n                      s3 = peg$c0;\n                    }\n                  } else {\n                    peg$currPos = s3;\n                    s3 = peg$c0;\n                  }\n                } else {\n                  peg$currPos = s3;\n                  s3 = peg$c0;\n                }\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n          if (s3 === peg$FAILED) {\n            s3 = peg$currPos;\n            s4 = peg$parse_();\n            if (s4 !== peg$FAILED) {\n              if (input.charCodeAt(peg$currPos) === 46) {\n                s5 = peg$c90;\n                peg$currPos++;\n              } else {\n                s5 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c91); }\n              }\n              if (s5 !== peg$FAILED) {\n                s6 = peg$parse_();\n                if (s6 !== peg$FAILED) {\n                  s7 = peg$parseIdentifier();\n                  if (s7 !== peg$FAILED) {\n                    peg$reportedPos = s3;\n                    s4 = peg$c95(s7);\n                    s3 = s4;\n                  } else {\n                    peg$currPos = s3;\n                    s3 = peg$c0;\n                  }\n                } else {\n                  peg$currPos = s3;\n                  s3 = peg$c0;\n                }\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          }\n        }\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          s3 = peg$currPos;\n          s4 = peg$parse_();\n          if (s4 !== peg$FAILED) {\n            s5 = peg$parseArguments();\n            if (s5 !== peg$FAILED) {\n              peg$reportedPos = s3;\n              s4 = peg$c94(s5);\n              s3 = s4;\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n          if (s3 === peg$FAILED) {\n            s3 = peg$currPos;\n            s4 = peg$parse_();\n            if (s4 !== peg$FAILED) {\n              if (input.charCodeAt(peg$currPos) === 91) {\n                s5 = peg$c85;\n                peg$currPos++;\n              } else {\n                s5 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c86); }\n              }\n              if (s5 !== peg$FAILED) {\n                s6 = peg$parse_();\n                if (s6 !== peg$FAILED) {\n                  s7 = peg$parseConditionalExpression();\n                  if (s7 !== peg$FAILED) {\n                    s8 = peg$parse_();\n                    if (s8 !== peg$FAILED) {\n                      if (input.charCodeAt(peg$currPos) === 93) {\n                        s9 = peg$c87;\n                        peg$currPos++;\n                      } else {\n                        s9 = peg$FAILED;\n                        if (peg$silentFails === 0) { peg$fail(peg$c88); }\n                      }\n                      if (s9 !== peg$FAILED) {\n                        peg$reportedPos = s3;\n                        s4 = peg$c95(s7);\n                        s3 = s4;\n                      } else {\n                        peg$currPos = s3;\n                        s3 = peg$c0;\n                      }\n                    } else {\n                      peg$currPos = s3;\n                      s3 = peg$c0;\n                    }\n                  } else {\n                    peg$currPos = s3;\n                    s3 = peg$c0;\n                  }\n                } else {\n                  peg$currPos = s3;\n                  s3 = peg$c0;\n                }\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n            if (s3 === peg$FAILED) {\n              s3 = peg$currPos;\n              s4 = peg$parse_();\n              if (s4 !== peg$FAILED) {\n                if (input.charCodeAt(peg$currPos) === 46) {\n                  s5 = peg$c90;\n                  peg$currPos++;\n                } else {\n                  s5 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c91); }\n                }\n                if (s5 !== peg$FAILED) {\n                  s6 = peg$parse_();\n                  if (s6 !== peg$FAILED) {\n                    s7 = peg$parseIdentifier();\n                    if (s7 !== peg$FAILED) {\n                      peg$reportedPos = s3;\n                      s4 = peg$c95(s7);\n                      s3 = s4;\n                    } else {\n                      peg$currPos = s3;\n                      s3 = peg$c0;\n                    }\n                  } else {\n                    peg$currPos = s3;\n                    s3 = peg$c0;\n                  }\n                } else {\n                  peg$currPos = s3;\n                  s3 = peg$c0;\n                }\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            }\n          }\n        }\n        if (s2 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c96(s1, s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n      if (s0 === peg$FAILED) {\n        s0 = peg$parseMemberExpression();\n      }\n\n      return s0;\n    }\n\n    function peg$parseArguments() {\n      var s0, s1, s2, s3, s4, s5;\n\n      s0 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 40) {\n        s1 = peg$c67;\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c68); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parse_();\n        if (s2 !== peg$FAILED) {\n          s3 = peg$parseArgumentList();\n          if (s3 === peg$FAILED) {\n            s3 = peg$c4;\n          }\n          if (s3 !== peg$FAILED) {\n            s4 = peg$parse_();\n            if (s4 !== peg$FAILED) {\n              if (input.charCodeAt(peg$currPos) === 41) {\n                s5 = peg$c69;\n                peg$currPos++;\n              } else {\n                s5 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c70); }\n              }\n              if (s5 !== peg$FAILED) {\n                peg$reportedPos = s0;\n                s1 = peg$c97(s3);\n                s0 = s1;\n              } else {\n                peg$currPos = s0;\n                s0 = peg$c0;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$c0;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseArgumentList() {\n      var s0, s1, s2, s3, s4, s5, s6, s7;\n\n      s0 = peg$currPos;\n      s1 = peg$parseConditionalExpression();\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        s3 = peg$currPos;\n        s4 = peg$parse_();\n        if (s4 !== peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 44) {\n            s5 = peg$c58;\n            peg$currPos++;\n          } else {\n            s5 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c59); }\n          }\n          if (s5 !== peg$FAILED) {\n            s6 = peg$parse_();\n            if (s6 !== peg$FAILED) {\n              s7 = peg$parseConditionalExpression();\n              if (s7 !== peg$FAILED) {\n                peg$reportedPos = s3;\n                s4 = peg$c65(s7);\n                s3 = s4;\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        } else {\n          peg$currPos = s3;\n          s3 = peg$c0;\n        }\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          s3 = peg$currPos;\n          s4 = peg$parse_();\n          if (s4 !== peg$FAILED) {\n            if (input.charCodeAt(peg$currPos) === 44) {\n              s5 = peg$c58;\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c59); }\n            }\n            if (s5 !== peg$FAILED) {\n              s6 = peg$parse_();\n              if (s6 !== peg$FAILED) {\n                s7 = peg$parseConditionalExpression();\n                if (s7 !== peg$FAILED) {\n                  peg$reportedPos = s3;\n                  s4 = peg$c65(s7);\n                  s3 = s4;\n                } else {\n                  peg$currPos = s3;\n                  s3 = peg$c0;\n                }\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        }\n        if (s2 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c98(s1, s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseUnaryExpression() {\n      var s0, s1, s2;\n\n      s0 = peg$parseCallExpression();\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        s1 = peg$parseUnaryOperator();\n        if (s1 !== peg$FAILED) {\n          s2 = peg$parseUnaryExpression();\n          if (s2 !== peg$FAILED) {\n            peg$reportedPos = s0;\n            s1 = peg$c99(s1, s2);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseUnaryOperator() {\n      var s0, s1;\n\n      s0 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 43) {\n        s1 = peg$c100;\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c101); }\n      }\n      if (s1 !== peg$FAILED) {\n        peg$reportedPos = s0;\n        s1 = peg$c102();\n      }\n      s0 = s1;\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 45) {\n          s1 = peg$c103;\n          peg$currPos++;\n        } else {\n          s1 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c104); }\n        }\n        if (s1 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c105();\n        }\n        s0 = s1;\n        if (s0 === peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 33) {\n            s0 = peg$c106;\n            peg$currPos++;\n          } else {\n            s0 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c107); }\n          }\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseMultiplicativeExpression() {\n      var s0, s1, s2, s3, s4, s5, s6, s7;\n\n      s0 = peg$currPos;\n      s1 = peg$parseUnaryExpression();\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        s3 = peg$currPos;\n        s4 = peg$parse_();\n        if (s4 !== peg$FAILED) {\n          s5 = peg$parseMultiplicativeOperator();\n          if (s5 !== peg$FAILED) {\n            s6 = peg$parse_();\n            if (s6 !== peg$FAILED) {\n              s7 = peg$parseUnaryExpression();\n              if (s7 !== peg$FAILED) {\n                peg$reportedPos = s3;\n                s4 = peg$c108(s5, s7);\n                s3 = s4;\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        } else {\n          peg$currPos = s3;\n          s3 = peg$c0;\n        }\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          s3 = peg$currPos;\n          s4 = peg$parse_();\n          if (s4 !== peg$FAILED) {\n            s5 = peg$parseMultiplicativeOperator();\n            if (s5 !== peg$FAILED) {\n              s6 = peg$parse_();\n              if (s6 !== peg$FAILED) {\n                s7 = peg$parseUnaryExpression();\n                if (s7 !== peg$FAILED) {\n                  peg$reportedPos = s3;\n                  s4 = peg$c108(s5, s7);\n                  s3 = s4;\n                } else {\n                  peg$currPos = s3;\n                  s3 = peg$c0;\n                }\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        }\n        if (s2 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c109(s1, s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseMultiplicativeOperator() {\n      var s0;\n\n      if (input.charCodeAt(peg$currPos) === 42) {\n        s0 = peg$c34;\n        peg$currPos++;\n      } else {\n        s0 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c35); }\n      }\n      if (s0 === peg$FAILED) {\n        if (input.charCodeAt(peg$currPos) === 47) {\n          s0 = peg$c28;\n          peg$currPos++;\n        } else {\n          s0 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c29); }\n        }\n        if (s0 === peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 37) {\n            s0 = peg$c110;\n            peg$currPos++;\n          } else {\n            s0 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c111); }\n          }\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseAdditiveExpression() {\n      var s0, s1, s2, s3, s4, s5, s6, s7;\n\n      s0 = peg$currPos;\n      s1 = peg$parseMultiplicativeExpression();\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        s3 = peg$currPos;\n        s4 = peg$parse_();\n        if (s4 !== peg$FAILED) {\n          s5 = peg$parseAdditiveOperator();\n          if (s5 !== peg$FAILED) {\n            s6 = peg$parse_();\n            if (s6 !== peg$FAILED) {\n              s7 = peg$parseMultiplicativeExpression();\n              if (s7 !== peg$FAILED) {\n                peg$reportedPos = s3;\n                s4 = peg$c108(s5, s7);\n                s3 = s4;\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        } else {\n          peg$currPos = s3;\n          s3 = peg$c0;\n        }\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          s3 = peg$currPos;\n          s4 = peg$parse_();\n          if (s4 !== peg$FAILED) {\n            s5 = peg$parseAdditiveOperator();\n            if (s5 !== peg$FAILED) {\n              s6 = peg$parse_();\n              if (s6 !== peg$FAILED) {\n                s7 = peg$parseMultiplicativeExpression();\n                if (s7 !== peg$FAILED) {\n                  peg$reportedPos = s3;\n                  s4 = peg$c108(s5, s7);\n                  s3 = s4;\n                } else {\n                  peg$currPos = s3;\n                  s3 = peg$c0;\n                }\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        }\n        if (s2 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c109(s1, s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseAdditiveOperator() {\n      var s0;\n\n      if (input.charCodeAt(peg$currPos) === 43) {\n        s0 = peg$c100;\n        peg$currPos++;\n      } else {\n        s0 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c101); }\n      }\n      if (s0 === peg$FAILED) {\n        if (input.charCodeAt(peg$currPos) === 45) {\n          s0 = peg$c103;\n          peg$currPos++;\n        } else {\n          s0 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c104); }\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseRelationalExpression() {\n      var s0, s1, s2, s3, s4, s5, s6, s7;\n\n      s0 = peg$currPos;\n      s1 = peg$parseAdditiveExpression();\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        s3 = peg$currPos;\n        s4 = peg$parse_();\n        if (s4 !== peg$FAILED) {\n          s5 = peg$parseRelationalOperator();\n          if (s5 !== peg$FAILED) {\n            s6 = peg$parse_();\n            if (s6 !== peg$FAILED) {\n              s7 = peg$parseAdditiveExpression();\n              if (s7 !== peg$FAILED) {\n                peg$reportedPos = s3;\n                s4 = peg$c108(s5, s7);\n                s3 = s4;\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        } else {\n          peg$currPos = s3;\n          s3 = peg$c0;\n        }\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          s3 = peg$currPos;\n          s4 = peg$parse_();\n          if (s4 !== peg$FAILED) {\n            s5 = peg$parseRelationalOperator();\n            if (s5 !== peg$FAILED) {\n              s6 = peg$parse_();\n              if (s6 !== peg$FAILED) {\n                s7 = peg$parseAdditiveExpression();\n                if (s7 !== peg$FAILED) {\n                  peg$reportedPos = s3;\n                  s4 = peg$c108(s5, s7);\n                  s3 = s4;\n                } else {\n                  peg$currPos = s3;\n                  s3 = peg$c0;\n                }\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        }\n        if (s2 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c109(s1, s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseRelationalOperator() {\n      var s0;\n\n      if (input.substr(peg$currPos, 2) === peg$c112) {\n        s0 = peg$c112;\n        peg$currPos += 2;\n      } else {\n        s0 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c113); }\n      }\n      if (s0 === peg$FAILED) {\n        if (input.substr(peg$currPos, 2) === peg$c114) {\n          s0 = peg$c114;\n          peg$currPos += 2;\n        } else {\n          s0 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c115); }\n        }\n        if (s0 === peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 60) {\n            s0 = peg$c44;\n            peg$currPos++;\n          } else {\n            s0 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c45); }\n          }\n          if (s0 === peg$FAILED) {\n            if (input.charCodeAt(peg$currPos) === 62) {\n              s0 = peg$c46;\n              peg$currPos++;\n            } else {\n              s0 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c47); }\n            }\n          }\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseEqualityExpression() {\n      var s0, s1, s2, s3, s4, s5, s6, s7;\n\n      s0 = peg$currPos;\n      s1 = peg$parseRelationalExpression();\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        s3 = peg$currPos;\n        s4 = peg$parse_();\n        if (s4 !== peg$FAILED) {\n          s5 = peg$parseEqualityOperator();\n          if (s5 !== peg$FAILED) {\n            s6 = peg$parse_();\n            if (s6 !== peg$FAILED) {\n              s7 = peg$parseRelationalExpression();\n              if (s7 !== peg$FAILED) {\n                peg$reportedPos = s3;\n                s4 = peg$c108(s5, s7);\n                s3 = s4;\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        } else {\n          peg$currPos = s3;\n          s3 = peg$c0;\n        }\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          s3 = peg$currPos;\n          s4 = peg$parse_();\n          if (s4 !== peg$FAILED) {\n            s5 = peg$parseEqualityOperator();\n            if (s5 !== peg$FAILED) {\n              s6 = peg$parse_();\n              if (s6 !== peg$FAILED) {\n                s7 = peg$parseRelationalExpression();\n                if (s7 !== peg$FAILED) {\n                  peg$reportedPos = s3;\n                  s4 = peg$c108(s5, s7);\n                  s3 = s4;\n                } else {\n                  peg$currPos = s3;\n                  s3 = peg$c0;\n                }\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        }\n        if (s2 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c109(s1, s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseEqualityOperator() {\n      var s0, s1;\n\n      s0 = peg$currPos;\n      if (input.substr(peg$currPos, 3) === peg$c116) {\n        s1 = peg$c116;\n        peg$currPos += 3;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c117); }\n      }\n      if (s1 === peg$FAILED) {\n        if (input.substr(peg$currPos, 2) === peg$c118) {\n          s1 = peg$c118;\n          peg$currPos += 2;\n        } else {\n          s1 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c119); }\n        }\n      }\n      if (s1 !== peg$FAILED) {\n        peg$reportedPos = s0;\n        s1 = peg$c120();\n      }\n      s0 = s1;\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 61) {\n          s1 = peg$c32;\n          peg$currPos++;\n        } else {\n          s1 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c33); }\n        }\n        if (s1 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c121();\n        }\n        s0 = s1;\n        if (s0 === peg$FAILED) {\n          s0 = peg$currPos;\n          if (input.substr(peg$currPos, 3) === peg$c122) {\n            s1 = peg$c122;\n            peg$currPos += 3;\n          } else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c123); }\n          }\n          if (s1 === peg$FAILED) {\n            if (input.substr(peg$currPos, 2) === peg$c124) {\n              s1 = peg$c124;\n              peg$currPos += 2;\n            } else {\n              s1 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c125); }\n            }\n          }\n          if (s1 !== peg$FAILED) {\n            peg$reportedPos = s0;\n            s1 = peg$c126();\n          }\n          s0 = s1;\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseLogicalANDExpression() {\n      var s0, s1, s2, s3, s4, s5, s6, s7;\n\n      s0 = peg$currPos;\n      s1 = peg$parseEqualityExpression();\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        s3 = peg$currPos;\n        s4 = peg$parse_();\n        if (s4 !== peg$FAILED) {\n          s5 = peg$parseLogicalANDOperator();\n          if (s5 !== peg$FAILED) {\n            s6 = peg$parse_();\n            if (s6 !== peg$FAILED) {\n              s7 = peg$parseEqualityExpression();\n              if (s7 !== peg$FAILED) {\n                peg$reportedPos = s3;\n                s4 = peg$c108(s5, s7);\n                s3 = s4;\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        } else {\n          peg$currPos = s3;\n          s3 = peg$c0;\n        }\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          s3 = peg$currPos;\n          s4 = peg$parse_();\n          if (s4 !== peg$FAILED) {\n            s5 = peg$parseLogicalANDOperator();\n            if (s5 !== peg$FAILED) {\n              s6 = peg$parse_();\n              if (s6 !== peg$FAILED) {\n                s7 = peg$parseEqualityExpression();\n                if (s7 !== peg$FAILED) {\n                  peg$reportedPos = s3;\n                  s4 = peg$c108(s5, s7);\n                  s3 = s4;\n                } else {\n                  peg$currPos = s3;\n                  s3 = peg$c0;\n                }\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        }\n        if (s2 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c109(s1, s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseLogicalANDOperator() {\n      var s0, s1;\n\n      s0 = peg$currPos;\n      if (input.substr(peg$currPos, 2) === peg$c127) {\n        s1 = peg$c127;\n        peg$currPos += 2;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c128); }\n      }\n      if (s1 === peg$FAILED) {\n        if (input.substr(peg$currPos, 3) === peg$c129) {\n          s1 = peg$c129;\n          peg$currPos += 3;\n        } else {\n          s1 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c130); }\n        }\n      }\n      if (s1 !== peg$FAILED) {\n        peg$reportedPos = s0;\n        s1 = peg$c131();\n      }\n      s0 = s1;\n\n      return s0;\n    }\n\n    function peg$parseLogicalORExpression() {\n      var s0, s1, s2, s3, s4, s5, s6, s7;\n\n      s0 = peg$currPos;\n      s1 = peg$parseLogicalANDExpression();\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        s3 = peg$currPos;\n        s4 = peg$parse_();\n        if (s4 !== peg$FAILED) {\n          s5 = peg$parseLogicalOROperator();\n          if (s5 !== peg$FAILED) {\n            s6 = peg$parse_();\n            if (s6 !== peg$FAILED) {\n              s7 = peg$parseLogicalANDExpression();\n              if (s7 !== peg$FAILED) {\n                peg$reportedPos = s3;\n                s4 = peg$c108(s5, s7);\n                s3 = s4;\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        } else {\n          peg$currPos = s3;\n          s3 = peg$c0;\n        }\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          s3 = peg$currPos;\n          s4 = peg$parse_();\n          if (s4 !== peg$FAILED) {\n            s5 = peg$parseLogicalOROperator();\n            if (s5 !== peg$FAILED) {\n              s6 = peg$parse_();\n              if (s6 !== peg$FAILED) {\n                s7 = peg$parseLogicalANDExpression();\n                if (s7 !== peg$FAILED) {\n                  peg$reportedPos = s3;\n                  s4 = peg$c108(s5, s7);\n                  s3 = s4;\n                } else {\n                  peg$currPos = s3;\n                  s3 = peg$c0;\n                }\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        }\n        if (s2 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c109(s1, s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseLogicalOROperator() {\n      var s0, s1;\n\n      s0 = peg$currPos;\n      if (input.substr(peg$currPos, 2) === peg$c132) {\n        s1 = peg$c132;\n        peg$currPos += 2;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c133); }\n      }\n      if (s1 === peg$FAILED) {\n        if (input.substr(peg$currPos, 2) === peg$c134) {\n          s1 = peg$c134;\n          peg$currPos += 2;\n        } else {\n          s1 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c135); }\n        }\n      }\n      if (s1 !== peg$FAILED) {\n        peg$reportedPos = s0;\n        s1 = peg$c136();\n      }\n      s0 = s1;\n\n      return s0;\n    }\n\n    function peg$parseConditionalExpression() {\n      var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;\n\n      s0 = peg$currPos;\n      s1 = peg$parseLogicalORExpression();\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parse_();\n        if (s2 !== peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 63) {\n            s3 = peg$c137;\n            peg$currPos++;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c138); }\n          }\n          if (s3 !== peg$FAILED) {\n            s4 = peg$parse_();\n            if (s4 !== peg$FAILED) {\n              s5 = peg$parseConditionalExpression();\n              if (s5 !== peg$FAILED) {\n                s6 = peg$parse_();\n                if (s6 !== peg$FAILED) {\n                  if (input.charCodeAt(peg$currPos) === 58) {\n                    s7 = peg$c55;\n                    peg$currPos++;\n                  } else {\n                    s7 = peg$FAILED;\n                    if (peg$silentFails === 0) { peg$fail(peg$c56); }\n                  }\n                  if (s7 !== peg$FAILED) {\n                    s8 = peg$parse_();\n                    if (s8 !== peg$FAILED) {\n                      s9 = peg$parseConditionalExpression();\n                      if (s9 !== peg$FAILED) {\n                        peg$reportedPos = s0;\n                        s1 = peg$c139(s1, s5, s9);\n                        s0 = s1;\n                      } else {\n                        peg$currPos = s0;\n                        s0 = peg$c0;\n                      }\n                    } else {\n                      peg$currPos = s0;\n                      s0 = peg$c0;\n                    }\n                  } else {\n                    peg$currPos = s0;\n                    s0 = peg$c0;\n                  }\n                } else {\n                  peg$currPos = s0;\n                  s0 = peg$c0;\n                }\n              } else {\n                peg$currPos = s0;\n                s0 = peg$c0;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$c0;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n      if (s0 === peg$FAILED) {\n        s0 = peg$parseLogicalORExpression();\n      }\n\n      return s0;\n    }\n\n    function peg$parseLiteral() {\n      var s0;\n\n      s0 = peg$parseNull();\n      if (s0 === peg$FAILED) {\n        s0 = peg$parseBooleanLiteral();\n        if (s0 === peg$FAILED) {\n          s0 = peg$parseNumericLiteral();\n          if (s0 === peg$FAILED) {\n            s0 = peg$parseStringLiteral();\n            if (s0 === peg$FAILED) {\n              s0 = peg$parseArrayLiteral();\n              if (s0 === peg$FAILED) {\n                s0 = peg$parseRegExp();\n              }\n            }\n          }\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseNull() {\n      var s0, s1;\n\n      s0 = peg$currPos;\n      if (input.substr(peg$currPos, 4) === peg$c140) {\n        s1 = peg$c140;\n        peg$currPos += 4;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c141); }\n      }\n      if (s1 !== peg$FAILED) {\n        peg$reportedPos = s0;\n        s1 = peg$c142();\n      }\n      s0 = s1;\n\n      return s0;\n    }\n\n    function peg$parseArrayLiteral() {\n      var s0, s1, s2, s3, s4, s5;\n\n      s0 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 91) {\n        s1 = peg$c85;\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c86); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parse_();\n        if (s2 !== peg$FAILED) {\n          s3 = peg$parseArgumentList();\n          if (s3 === peg$FAILED) {\n            s3 = peg$c4;\n          }\n          if (s3 !== peg$FAILED) {\n            s4 = peg$parse_();\n            if (s4 !== peg$FAILED) {\n              if (input.charCodeAt(peg$currPos) === 93) {\n                s5 = peg$c87;\n                peg$currPos++;\n              } else {\n                s5 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c88); }\n              }\n              if (s5 !== peg$FAILED) {\n                peg$reportedPos = s0;\n                s1 = peg$c143(s3);\n                s0 = s1;\n              } else {\n                peg$currPos = s0;\n                s0 = peg$c0;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$c0;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseBooleanLiteral() {\n      var s0, s1;\n\n      s0 = peg$currPos;\n      if (input.substr(peg$currPos, 4) === peg$c144) {\n        s1 = peg$c144;\n        peg$currPos += 4;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c145); }\n      }\n      if (s1 !== peg$FAILED) {\n        peg$reportedPos = s0;\n        s1 = peg$c146();\n      }\n      s0 = s1;\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        if (input.substr(peg$currPos, 5) === peg$c147) {\n          s1 = peg$c147;\n          peg$currPos += 5;\n        } else {\n          s1 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c148); }\n        }\n        if (s1 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c149();\n        }\n        s0 = s1;\n      }\n\n      return s0;\n    }\n\n    function peg$parseNumericLiteral() {\n      var s0, s1, s2;\n\n      peg$silentFails++;\n      s0 = peg$currPos;\n      if (peg$c151.test(input.charAt(peg$currPos))) {\n        s1 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c152); }\n      }\n      if (s1 === peg$FAILED) {\n        s1 = peg$c4;\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parseHexIntegerLiteral();\n        if (s2 === peg$FAILED) {\n          s2 = peg$parseDecimalLiteral();\n        }\n        if (s2 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c153(s1, s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n      peg$silentFails--;\n      if (s0 === peg$FAILED) {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c150); }\n      }\n\n      return s0;\n    }\n\n    function peg$parseDecimalLiteral() {\n      var s0, s1, s2, s3, s4, s5, s6;\n\n      s0 = peg$currPos;\n      s1 = peg$currPos;\n      s2 = peg$currPos;\n      s3 = peg$parseDecimalIntegerLiteral();\n      if (s3 !== peg$FAILED) {\n        if (input.charCodeAt(peg$currPos) === 46) {\n          s4 = peg$c90;\n          peg$currPos++;\n        } else {\n          s4 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c91); }\n        }\n        if (s4 !== peg$FAILED) {\n          s5 = peg$parseDecimalDigits();\n          if (s5 === peg$FAILED) {\n            s5 = peg$c4;\n          }\n          if (s5 !== peg$FAILED) {\n            s6 = peg$parseExponentPart();\n            if (s6 === peg$FAILED) {\n              s6 = peg$c4;\n            }\n            if (s6 !== peg$FAILED) {\n              s3 = [s3, s4, s5, s6];\n              s2 = s3;\n            } else {\n              peg$currPos = s2;\n              s2 = peg$c0;\n            }\n          } else {\n            peg$currPos = s2;\n            s2 = peg$c0;\n          }\n        } else {\n          peg$currPos = s2;\n          s2 = peg$c0;\n        }\n      } else {\n        peg$currPos = s2;\n        s2 = peg$c0;\n      }\n      if (s2 !== peg$FAILED) {\n        s2 = input.substring(s1, peg$currPos);\n      }\n      s1 = s2;\n      if (s1 !== peg$FAILED) {\n        peg$reportedPos = s0;\n        s1 = peg$c154(s1);\n      }\n      s0 = s1;\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        s1 = peg$currPos;\n        s2 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 46) {\n          s3 = peg$c90;\n          peg$currPos++;\n        } else {\n          s3 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c91); }\n        }\n        if (s3 !== peg$FAILED) {\n          s4 = peg$parseDecimalDigits();\n          if (s4 !== peg$FAILED) {\n            s5 = peg$parseExponentPart();\n            if (s5 === peg$FAILED) {\n              s5 = peg$c4;\n            }\n            if (s5 !== peg$FAILED) {\n              s3 = [s3, s4, s5];\n              s2 = s3;\n            } else {\n              peg$currPos = s2;\n              s2 = peg$c0;\n            }\n          } else {\n            peg$currPos = s2;\n            s2 = peg$c0;\n          }\n        } else {\n          peg$currPos = s2;\n          s2 = peg$c0;\n        }\n        if (s2 !== peg$FAILED) {\n          s2 = input.substring(s1, peg$currPos);\n        }\n        s1 = s2;\n        if (s1 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c155(s1);\n        }\n        s0 = s1;\n        if (s0 === peg$FAILED) {\n          s0 = peg$currPos;\n          s1 = peg$currPos;\n          s2 = peg$currPos;\n          s3 = peg$parseDecimalIntegerLiteral();\n          if (s3 !== peg$FAILED) {\n            s4 = peg$parseExponentPart();\n            if (s4 === peg$FAILED) {\n              s4 = peg$c4;\n            }\n            if (s4 !== peg$FAILED) {\n              s3 = [s3, s4];\n              s2 = s3;\n            } else {\n              peg$currPos = s2;\n              s2 = peg$c0;\n            }\n          } else {\n            peg$currPos = s2;\n            s2 = peg$c0;\n          }\n          if (s2 !== peg$FAILED) {\n            s2 = input.substring(s1, peg$currPos);\n          }\n          s1 = s2;\n          if (s1 !== peg$FAILED) {\n            peg$reportedPos = s0;\n            s1 = peg$c155(s1);\n          }\n          s0 = s1;\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseDecimalIntegerLiteral() {\n      var s0, s1, s2;\n\n      if (input.charCodeAt(peg$currPos) === 48) {\n        s0 = peg$c156;\n        peg$currPos++;\n      } else {\n        s0 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c157); }\n      }\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        s1 = peg$parseNonZeroDigit();\n        if (s1 !== peg$FAILED) {\n          s2 = peg$parseDecimalDigits();\n          if (s2 === peg$FAILED) {\n            s2 = peg$c4;\n          }\n          if (s2 !== peg$FAILED) {\n            s1 = [s1, s2];\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseDecimalDigits() {\n      var s0, s1;\n\n      s0 = [];\n      s1 = peg$parseDecimalDigit();\n      if (s1 !== peg$FAILED) {\n        while (s1 !== peg$FAILED) {\n          s0.push(s1);\n          s1 = peg$parseDecimalDigit();\n        }\n      } else {\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseDecimalDigit() {\n      var s0;\n\n      if (peg$c158.test(input.charAt(peg$currPos))) {\n        s0 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s0 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c159); }\n      }\n\n      return s0;\n    }\n\n    function peg$parseNonZeroDigit() {\n      var s0;\n\n      if (peg$c160.test(input.charAt(peg$currPos))) {\n        s0 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s0 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c161); }\n      }\n\n      return s0;\n    }\n\n    function peg$parseExponentPart() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      s1 = peg$parseExponentIndicator();\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parseSignedInteger();\n        if (s2 !== peg$FAILED) {\n          s1 = [s1, s2];\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseExponentIndicator() {\n      var s0;\n\n      if (peg$c162.test(input.charAt(peg$currPos))) {\n        s0 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s0 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c163); }\n      }\n\n      return s0;\n    }\n\n    function peg$parseSignedInteger() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      if (peg$c164.test(input.charAt(peg$currPos))) {\n        s1 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c165); }\n      }\n      if (s1 === peg$FAILED) {\n        s1 = peg$c4;\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parseDecimalDigits();\n        if (s2 !== peg$FAILED) {\n          s1 = [s1, s2];\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseHexIntegerLiteral() {\n      var s0, s1, s2, s3, s4, s5;\n\n      s0 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 48) {\n        s1 = peg$c156;\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c157); }\n      }\n      if (s1 !== peg$FAILED) {\n        if (peg$c166.test(input.charAt(peg$currPos))) {\n          s2 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s2 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c167); }\n        }\n        if (s2 !== peg$FAILED) {\n          s3 = peg$currPos;\n          s4 = [];\n          s5 = peg$parseHexDigit();\n          if (s5 !== peg$FAILED) {\n            while (s5 !== peg$FAILED) {\n              s4.push(s5);\n              s5 = peg$parseHexDigit();\n            }\n          } else {\n            s4 = peg$c0;\n          }\n          if (s4 !== peg$FAILED) {\n            s4 = input.substring(s3, peg$currPos);\n          }\n          s3 = s4;\n          if (s3 !== peg$FAILED) {\n            peg$reportedPos = s0;\n            s1 = peg$c168(s3);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseHexDigit() {\n      var s0;\n\n      if (peg$c169.test(input.charAt(peg$currPos))) {\n        s0 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s0 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c170); }\n      }\n\n      return s0;\n    }\n\n    function peg$parseRegExp() {\n      var s0, s1, s2, s3, s4, s5;\n\n      peg$silentFails++;\n      s0 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 47) {\n        s1 = peg$c28;\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c29); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parseRegExpCharacters();\n        if (s2 === peg$FAILED) {\n          s2 = peg$c4;\n        }\n        if (s2 !== peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 47) {\n            s3 = peg$c28;\n            peg$currPos++;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c29); }\n          }\n          if (s3 !== peg$FAILED) {\n            s4 = [];\n            if (peg$c172.test(input.charAt(peg$currPos))) {\n              s5 = input.charAt(peg$currPos);\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c173); }\n            }\n            while (s5 !== peg$FAILED) {\n              s4.push(s5);\n              if (peg$c172.test(input.charAt(peg$currPos))) {\n                s5 = input.charAt(peg$currPos);\n                peg$currPos++;\n              } else {\n                s5 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c173); }\n              }\n            }\n            if (s4 !== peg$FAILED) {\n              peg$reportedPos = s0;\n              s1 = peg$c174(s2, s4);\n              s0 = s1;\n            } else {\n              peg$currPos = s0;\n              s0 = peg$c0;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n      peg$silentFails--;\n      if (s0 === peg$FAILED) {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c171); }\n      }\n\n      return s0;\n    }\n\n    function peg$parseRegExpCharacters() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      s1 = [];\n      if (peg$c175.test(input.charAt(peg$currPos))) {\n        s2 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s2 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c176); }\n      }\n      if (s2 === peg$FAILED) {\n        s2 = peg$parseRegExpEscaped();\n      }\n      if (s2 !== peg$FAILED) {\n        while (s2 !== peg$FAILED) {\n          s1.push(s2);\n          if (peg$c175.test(input.charAt(peg$currPos))) {\n            s2 = input.charAt(peg$currPos);\n            peg$currPos++;\n          } else {\n            s2 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c176); }\n          }\n          if (s2 === peg$FAILED) {\n            s2 = peg$parseRegExpEscaped();\n          }\n        }\n      } else {\n        s1 = peg$c0;\n      }\n      if (s1 !== peg$FAILED) {\n        peg$reportedPos = s0;\n        s1 = peg$c177(s1);\n      }\n      s0 = s1;\n\n      return s0;\n    }\n\n    function peg$parseRegExpEscaped() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 92) {\n        s1 = peg$c178;\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c179); }\n      }\n      if (s1 !== peg$FAILED) {\n        if (input.length > peg$currPos) {\n          s2 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s2 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c180); }\n        }\n        if (s2 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c181(s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseStringLiteral() {\n      var s0, s1;\n\n      peg$silentFails++;\n      s0 = peg$currPos;\n      s1 = peg$parseString();\n      if (s1 !== peg$FAILED) {\n        peg$reportedPos = s0;\n        s1 = peg$c183(s1);\n      }\n      s0 = s1;\n      peg$silentFails--;\n      if (s0 === peg$FAILED) {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c182); }\n      }\n\n      return s0;\n    }\n\n    function peg$parseString() {\n      var s0, s1, s2, s3, s4;\n\n      s0 = peg$currPos;\n      s1 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 34) {\n        s2 = peg$c184;\n        peg$currPos++;\n      } else {\n        s2 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c185); }\n      }\n      if (s2 !== peg$FAILED) {\n        s3 = peg$parseDoubleStringCharacters();\n        if (s3 !== peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 34) {\n            s4 = peg$c184;\n            peg$currPos++;\n          } else {\n            s4 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c185); }\n          }\n          if (s4 !== peg$FAILED) {\n            s2 = [s2, s3, s4];\n            s1 = s2;\n          } else {\n            peg$currPos = s1;\n            s1 = peg$c0;\n          }\n        } else {\n          peg$currPos = s1;\n          s1 = peg$c0;\n        }\n      } else {\n        peg$currPos = s1;\n        s1 = peg$c0;\n      }\n      if (s1 === peg$FAILED) {\n        s1 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 39) {\n          s2 = peg$c186;\n          peg$currPos++;\n        } else {\n          s2 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c187); }\n        }\n        if (s2 !== peg$FAILED) {\n          s3 = peg$parseSingleStringCharacters();\n          if (s3 !== peg$FAILED) {\n            if (input.charCodeAt(peg$currPos) === 39) {\n              s4 = peg$c186;\n              peg$currPos++;\n            } else {\n              s4 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c187); }\n            }\n            if (s4 !== peg$FAILED) {\n              s2 = [s2, s3, s4];\n              s1 = s2;\n            } else {\n              peg$currPos = s1;\n              s1 = peg$c0;\n            }\n          } else {\n            peg$currPos = s1;\n            s1 = peg$c0;\n          }\n        } else {\n          peg$currPos = s1;\n          s1 = peg$c0;\n        }\n      }\n      if (s1 !== peg$FAILED) {\n        peg$reportedPos = s0;\n        s1 = peg$c188(s1);\n      }\n      s0 = s1;\n\n      return s0;\n    }\n\n    function peg$parseDoubleStringCharacters() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      s1 = [];\n      s2 = peg$parseDoubleStringCharacter();\n      while (s2 !== peg$FAILED) {\n        s1.push(s2);\n        s2 = peg$parseDoubleStringCharacter();\n      }\n      if (s1 !== peg$FAILED) {\n        peg$reportedPos = s0;\n        s1 = peg$c177(s1);\n      }\n      s0 = s1;\n\n      return s0;\n    }\n\n    function peg$parseSingleStringCharacters() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      s1 = [];\n      s2 = peg$parseSingleStringCharacter();\n      while (s2 !== peg$FAILED) {\n        s1.push(s2);\n        s2 = peg$parseSingleStringCharacter();\n      }\n      if (s1 !== peg$FAILED) {\n        peg$reportedPos = s0;\n        s1 = peg$c177(s1);\n      }\n      s0 = s1;\n\n      return s0;\n    }\n\n    function peg$parseDoubleStringCharacter() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      s1 = peg$currPos;\n      peg$silentFails++;\n      if (input.charCodeAt(peg$currPos) === 34) {\n        s2 = peg$c184;\n        peg$currPos++;\n      } else {\n        s2 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c185); }\n      }\n      if (s2 === peg$FAILED) {\n        if (input.charCodeAt(peg$currPos) === 92) {\n          s2 = peg$c178;\n          peg$currPos++;\n        } else {\n          s2 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c179); }\n        }\n        if (s2 === peg$FAILED) {\n          s2 = peg$parseNewLine();\n        }\n      }\n      peg$silentFails--;\n      if (s2 === peg$FAILED) {\n        s1 = peg$c82;\n      } else {\n        peg$currPos = s1;\n        s1 = peg$c0;\n      }\n      if (s1 !== peg$FAILED) {\n        if (input.length > peg$currPos) {\n          s2 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s2 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c180); }\n        }\n        if (s2 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c189(s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 92) {\n          s1 = peg$c178;\n          peg$currPos++;\n        } else {\n          s1 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c179); }\n        }\n        if (s1 !== peg$FAILED) {\n          s2 = peg$parseEscapeSequence();\n          if (s2 !== peg$FAILED) {\n            peg$reportedPos = s0;\n            s1 = peg$c190(s2);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n        if (s0 === peg$FAILED) {\n          s0 = peg$parseLineContinuation();\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseSingleStringCharacter() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      s1 = peg$currPos;\n      peg$silentFails++;\n      if (input.charCodeAt(peg$currPos) === 39) {\n        s2 = peg$c186;\n        peg$currPos++;\n      } else {\n        s2 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c187); }\n      }\n      if (s2 === peg$FAILED) {\n        if (input.charCodeAt(peg$currPos) === 92) {\n          s2 = peg$c178;\n          peg$currPos++;\n        } else {\n          s2 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c179); }\n        }\n        if (s2 === peg$FAILED) {\n          s2 = peg$parseNewLine();\n        }\n      }\n      peg$silentFails--;\n      if (s2 === peg$FAILED) {\n        s1 = peg$c82;\n      } else {\n        peg$currPos = s1;\n        s1 = peg$c0;\n      }\n      if (s1 !== peg$FAILED) {\n        if (input.length > peg$currPos) {\n          s2 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s2 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c180); }\n        }\n        if (s2 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c189(s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 92) {\n          s1 = peg$c178;\n          peg$currPos++;\n        } else {\n          s1 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c179); }\n        }\n        if (s1 !== peg$FAILED) {\n          s2 = peg$parseEscapeSequence();\n          if (s2 !== peg$FAILED) {\n            peg$reportedPos = s0;\n            s1 = peg$c190(s2);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n        if (s0 === peg$FAILED) {\n          s0 = peg$parseLineContinuation();\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseLineContinuation() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 92) {\n        s1 = peg$c178;\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c179); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parseNewLine();\n        if (s2 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c191(s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseEscapeSequence() {\n      var s0, s1, s2, s3;\n\n      s0 = peg$parseCharacterEscapeSequence();\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 48) {\n          s1 = peg$c156;\n          peg$currPos++;\n        } else {\n          s1 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c157); }\n        }\n        if (s1 !== peg$FAILED) {\n          s2 = peg$currPos;\n          peg$silentFails++;\n          s3 = peg$parseDecimalDigit();\n          peg$silentFails--;\n          if (s3 === peg$FAILED) {\n            s2 = peg$c82;\n          } else {\n            peg$currPos = s2;\n            s2 = peg$c0;\n          }\n          if (s2 !== peg$FAILED) {\n            peg$reportedPos = s0;\n            s1 = peg$c192();\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n        if (s0 === peg$FAILED) {\n          s0 = peg$parseHexEscapeSequence();\n          if (s0 === peg$FAILED) {\n            s0 = peg$parseUnicodeEscapeSequence();\n          }\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseCharacterEscapeSequence() {\n      var s0;\n\n      s0 = peg$parseSingleEscapeCharacter();\n      if (s0 === peg$FAILED) {\n        s0 = peg$parseNonEscapeCharacter();\n      }\n\n      return s0;\n    }\n\n    function peg$parseSingleEscapeCharacter() {\n      var s0, s1;\n\n      s0 = peg$currPos;\n      if (peg$c193.test(input.charAt(peg$currPos))) {\n        s1 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c194); }\n      }\n      if (s1 !== peg$FAILED) {\n        peg$reportedPos = s0;\n        s1 = peg$c195(s1);\n      }\n      s0 = s1;\n\n      return s0;\n    }\n\n    function peg$parseNonEscapeCharacter() {\n      var s0, s1, s2;\n\n      s0 = peg$currPos;\n      s1 = peg$currPos;\n      peg$silentFails++;\n      s2 = peg$parseEscapeCharacter();\n      peg$silentFails--;\n      if (s2 === peg$FAILED) {\n        s1 = peg$c82;\n      } else {\n        peg$currPos = s1;\n        s1 = peg$c0;\n      }\n      if (s1 === peg$FAILED) {\n        s1 = peg$parseNewLine();\n      }\n      if (s1 !== peg$FAILED) {\n        if (input.length > peg$currPos) {\n          s2 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s2 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c180); }\n        }\n        if (s2 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c196(s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseEscapeCharacter() {\n      var s0;\n\n      s0 = peg$parseSingleEscapeCharacter();\n      if (s0 === peg$FAILED) {\n        s0 = peg$parseDecimalDigit();\n        if (s0 === peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 120) {\n            s0 = peg$c197;\n            peg$currPos++;\n          } else {\n            s0 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c198); }\n          }\n          if (s0 === peg$FAILED) {\n            if (input.charCodeAt(peg$currPos) === 117) {\n              s0 = peg$c199;\n              peg$currPos++;\n            } else {\n              s0 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c200); }\n            }\n          }\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseHexEscapeSequence() {\n      var s0, s1, s2, s3, s4, s5;\n\n      s0 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 120) {\n        s1 = peg$c197;\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c198); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$currPos;\n        s3 = peg$currPos;\n        s4 = peg$parseHexDigit();\n        if (s4 !== peg$FAILED) {\n          s5 = peg$parseHexDigit();\n          if (s5 !== peg$FAILED) {\n            s4 = [s4, s5];\n            s3 = s4;\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        } else {\n          peg$currPos = s3;\n          s3 = peg$c0;\n        }\n        if (s3 !== peg$FAILED) {\n          s3 = input.substring(s2, peg$currPos);\n        }\n        s2 = s3;\n        if (s2 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c201(s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseUnicodeEscapeSequence() {\n      var s0, s1, s2, s3, s4, s5, s6, s7;\n\n      s0 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 117) {\n        s1 = peg$c199;\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c200); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$currPos;\n        s3 = peg$currPos;\n        s4 = peg$parseHexDigit();\n        if (s4 !== peg$FAILED) {\n          s5 = peg$parseHexDigit();\n          if (s5 !== peg$FAILED) {\n            s6 = peg$parseHexDigit();\n            if (s6 !== peg$FAILED) {\n              s7 = peg$parseHexDigit();\n              if (s7 !== peg$FAILED) {\n                s4 = [s4, s5, s6, s7];\n                s3 = s4;\n              } else {\n                peg$currPos = s3;\n                s3 = peg$c0;\n              }\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        } else {\n          peg$currPos = s3;\n          s3 = peg$c0;\n        }\n        if (s3 !== peg$FAILED) {\n          s3 = input.substring(s2, peg$currPos);\n        }\n        s2 = s3;\n        if (s2 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c201(s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseIdentifier() {\n      var s0, s1, s2, s3;\n\n      peg$silentFails++;\n      s0 = peg$currPos;\n      if (peg$c203.test(input.charAt(peg$currPos))) {\n        s1 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c204); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        if (peg$c205.test(input.charAt(peg$currPos))) {\n          s3 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s3 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c206); }\n        }\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          if (peg$c205.test(input.charAt(peg$currPos))) {\n            s3 = input.charAt(peg$currPos);\n            peg$currPos++;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c206); }\n          }\n        }\n        if (s2 !== peg$FAILED) {\n          peg$reportedPos = s0;\n          s1 = peg$c207(s1, s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n      peg$silentFails--;\n      if (s0 === peg$FAILED) {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c202); }\n      }\n\n      return s0;\n    }\n\n    function peg$parse__() {\n      var s0, s1;\n\n      s0 = [];\n      s1 = peg$parseWhitespace();\n      if (s1 === peg$FAILED) {\n        s1 = peg$parseComment();\n      }\n      if (s1 !== peg$FAILED) {\n        while (s1 !== peg$FAILED) {\n          s0.push(s1);\n          s1 = peg$parseWhitespace();\n          if (s1 === peg$FAILED) {\n            s1 = peg$parseComment();\n          }\n        }\n      } else {\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parse_() {\n      var s0, s1;\n\n      s0 = [];\n      s1 = peg$parseWhitespace();\n      if (s1 === peg$FAILED) {\n        s1 = peg$parseComment();\n      }\n      while (s1 !== peg$FAILED) {\n        s0.push(s1);\n        s1 = peg$parseWhitespace();\n        if (s1 === peg$FAILED) {\n          s1 = peg$parseComment();\n        }\n      }\n\n      return s0;\n    }\n\n    function peg$parseWhitespace() {\n      var s0, s1;\n\n      peg$silentFails++;\n      s0 = [];\n      if (peg$c209.test(input.charAt(peg$currPos))) {\n        s1 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c210); }\n      }\n      if (s1 !== peg$FAILED) {\n        while (s1 !== peg$FAILED) {\n          s0.push(s1);\n          if (peg$c209.test(input.charAt(peg$currPos))) {\n            s1 = input.charAt(peg$currPos);\n            peg$currPos++;\n          } else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c210); }\n          }\n        }\n      } else {\n        s0 = peg$c0;\n      }\n      peg$silentFails--;\n      if (s0 === peg$FAILED) {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c208); }\n      }\n\n      return s0;\n    }\n\n    function peg$parseComment() {\n      var s0, s1;\n\n      peg$silentFails++;\n      s0 = peg$parseMultiLineComment();\n      if (s0 === peg$FAILED) {\n        s0 = peg$parseSingleLineComment();\n      }\n      peg$silentFails--;\n      if (s0 === peg$FAILED) {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c211); }\n      }\n\n      return s0;\n    }\n\n    function peg$parseMultiLineComment() {\n      var s0, s1, s2, s3, s4, s5;\n\n      s0 = peg$currPos;\n      if (input.substr(peg$currPos, 2) === peg$c212) {\n        s1 = peg$c212;\n        peg$currPos += 2;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c213); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        s3 = peg$currPos;\n        s4 = peg$currPos;\n        peg$silentFails++;\n        if (input.substr(peg$currPos, 2) === peg$c214) {\n          s5 = peg$c214;\n          peg$currPos += 2;\n        } else {\n          s5 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c215); }\n        }\n        peg$silentFails--;\n        if (s5 === peg$FAILED) {\n          s4 = peg$c82;\n        } else {\n          peg$currPos = s4;\n          s4 = peg$c0;\n        }\n        if (s4 !== peg$FAILED) {\n          if (input.length > peg$currPos) {\n            s5 = input.charAt(peg$currPos);\n            peg$currPos++;\n          } else {\n            s5 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c180); }\n          }\n          if (s5 !== peg$FAILED) {\n            s4 = [s4, s5];\n            s3 = s4;\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        } else {\n          peg$currPos = s3;\n          s3 = peg$c0;\n        }\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          s3 = peg$currPos;\n          s4 = peg$currPos;\n          peg$silentFails++;\n          if (input.substr(peg$currPos, 2) === peg$c214) {\n            s5 = peg$c214;\n            peg$currPos += 2;\n          } else {\n            s5 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c215); }\n          }\n          peg$silentFails--;\n          if (s5 === peg$FAILED) {\n            s4 = peg$c82;\n          } else {\n            peg$currPos = s4;\n            s4 = peg$c0;\n          }\n          if (s4 !== peg$FAILED) {\n            if (input.length > peg$currPos) {\n              s5 = input.charAt(peg$currPos);\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c180); }\n            }\n            if (s5 !== peg$FAILED) {\n              s4 = [s4, s5];\n              s3 = s4;\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        }\n        if (s2 !== peg$FAILED) {\n          if (input.substr(peg$currPos, 2) === peg$c214) {\n            s3 = peg$c214;\n            peg$currPos += 2;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c215); }\n          }\n          if (s3 !== peg$FAILED) {\n            s1 = [s1, s2, s3];\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseSingleLineComment() {\n      var s0, s1, s2, s3, s4, s5;\n\n      s0 = peg$currPos;\n      if (input.substr(peg$currPos, 2) === peg$c216) {\n        s1 = peg$c216;\n        peg$currPos += 2;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c217); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        s3 = peg$currPos;\n        s4 = peg$currPos;\n        peg$silentFails++;\n        s5 = peg$parseNewLine();\n        peg$silentFails--;\n        if (s5 === peg$FAILED) {\n          s4 = peg$c82;\n        } else {\n          peg$currPos = s4;\n          s4 = peg$c0;\n        }\n        if (s4 !== peg$FAILED) {\n          if (input.length > peg$currPos) {\n            s5 = input.charAt(peg$currPos);\n            peg$currPos++;\n          } else {\n            s5 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c180); }\n          }\n          if (s5 !== peg$FAILED) {\n            s4 = [s4, s5];\n            s3 = s4;\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        } else {\n          peg$currPos = s3;\n          s3 = peg$c0;\n        }\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          s3 = peg$currPos;\n          s4 = peg$currPos;\n          peg$silentFails++;\n          s5 = peg$parseNewLine();\n          peg$silentFails--;\n          if (s5 === peg$FAILED) {\n            s4 = peg$c82;\n          } else {\n            peg$currPos = s4;\n            s4 = peg$c0;\n          }\n          if (s4 !== peg$FAILED) {\n            if (input.length > peg$currPos) {\n              s5 = input.charAt(peg$currPos);\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c180); }\n            }\n            if (s5 !== peg$FAILED) {\n              s4 = [s4, s5];\n              s3 = s4;\n            } else {\n              peg$currPos = s3;\n              s3 = peg$c0;\n            }\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n        }\n        if (s2 !== peg$FAILED) {\n          s1 = [s1, s2];\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseAnyBlock() {\n      var s0, s1, s2, s3, s4;\n\n      s0 = peg$currPos;\n      s1 = [];\n      s2 = peg$currPos;\n      s3 = peg$currPos;\n      peg$silentFails++;\n      if (peg$c218.test(input.charAt(peg$currPos))) {\n        s4 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s4 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c219); }\n      }\n      peg$silentFails--;\n      if (s4 === peg$FAILED) {\n        s3 = peg$c82;\n      } else {\n        peg$currPos = s3;\n        s3 = peg$c0;\n      }\n      if (s3 !== peg$FAILED) {\n        if (input.length > peg$currPos) {\n          s4 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s4 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c180); }\n        }\n        if (s4 !== peg$FAILED) {\n          peg$reportedPos = s2;\n          s3 = peg$c196(s4);\n          s2 = s3;\n        } else {\n          peg$currPos = s2;\n          s2 = peg$c0;\n        }\n      } else {\n        peg$currPos = s2;\n        s2 = peg$c0;\n      }\n      if (s2 !== peg$FAILED) {\n        while (s2 !== peg$FAILED) {\n          s1.push(s2);\n          s2 = peg$currPos;\n          s3 = peg$currPos;\n          peg$silentFails++;\n          if (peg$c218.test(input.charAt(peg$currPos))) {\n            s4 = input.charAt(peg$currPos);\n            peg$currPos++;\n          } else {\n            s4 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c219); }\n          }\n          peg$silentFails--;\n          if (s4 === peg$FAILED) {\n            s3 = peg$c82;\n          } else {\n            peg$currPos = s3;\n            s3 = peg$c0;\n          }\n          if (s3 !== peg$FAILED) {\n            if (input.length > peg$currPos) {\n              s4 = input.charAt(peg$currPos);\n              peg$currPos++;\n            } else {\n              s4 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c180); }\n            }\n            if (s4 !== peg$FAILED) {\n              peg$reportedPos = s2;\n              s3 = peg$c196(s4);\n              s2 = s3;\n            } else {\n              peg$currPos = s2;\n              s2 = peg$c0;\n            }\n          } else {\n            peg$currPos = s2;\n            s2 = peg$c0;\n          }\n        }\n      } else {\n        s1 = peg$c0;\n      }\n      if (s1 !== peg$FAILED) {\n        if (peg$c218.test(input.charAt(peg$currPos))) {\n          s2 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s2 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c219); }\n        }\n        if (s2 !== peg$FAILED) {\n          s3 = peg$parse_();\n          if (s3 !== peg$FAILED) {\n            peg$reportedPos = s0;\n            s1 = peg$c220(s1);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$c0;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$c0;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$c0;\n      }\n\n      return s0;\n    }\n\n    function peg$parseNewLine() {\n      var s0;\n\n      if (peg$c221.test(input.charAt(peg$currPos))) {\n        s0 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s0 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c222); }\n      }\n\n      return s0;\n    }\n\n\n      \"use strict\";\n\n      var ast = require('./ast');\n      var util = require('./util');\n      var logger = require('./logger');\n      var error = logger.error;\n      var warn = logger.warn;\n\n      logger.setContext(function() {\n        return {\n          line: line(),\n          column: column()\n        };\n      });\n\n      // Return a left-associative binary structure\n      // consisting of head (exp), and tail (op, exp)*.\n      function leftAssociative(head, tail) {\n        var result = head;\n        for (var i = 0; i < tail.length; i++) {\n          result = ast.op(tail[i].op, [result, tail[i].exp]);\n        }\n        return result;\n      }\n\n      var symbols = new ast.Symbols();\n\n      var currentPath = new ast.PathTemplate();\n\n      function ensureLowerCase(s, m) {\n        if (s instanceof Array) {\n          s = s.map(function(id) {\n            return ensureLowerCase(id, m);\n          });\n          return s;\n        }\n        var canonical = s[0].toLowerCase() + s.slice(1);\n        if (s != canonical) {\n          warn(m + \" should begin with a lowercase letter: ('\" + s + \"' should be '\" + canonical + \"').\");\n        }\n        return s;\n      }\n\n      function ensureUpperCase(s, m) {\n        if (s instanceof Array) {\n          s = s.map(function(id) {\n            return ensureUpperCase(id, m);\n          });\n          return s;\n        }\n        var canonical = s[0].toUpperCase() + s.slice(1);\n        if (s != canonical) {\n          warn(m + \" should begin with an uppercase letter: ('\" + s + \"' should be '\" + canonical + \"').\");\n        }\n        return s;\n      }\n\n\n    peg$result = peg$startRuleFunction();\n\n    if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n      return peg$result;\n    } else {\n      if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n        peg$fail({ type: \"end\", description: \"end of input\" });\n      }\n\n      throw peg$buildException(null, peg$maxFailExpected, peg$maxFailPos);\n    }\n  }\n\n  return {\n    SyntaxError: SyntaxError,\n    parse:       parse\n  };\n})();","/*\n * Copyright 2015 Google Inc. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\ntype Object = {[prop: string]: any};\nexport function extend(dest: Object, ...srcs: Object[]): Object {\n  var i: number;\n  var source: any;\n  var prop: string;\n\n  if (dest === undefined) {\n    dest = {};\n  }\n  for (i = 0; i < srcs.length; i++) {\n    source = srcs[i];\n    for (prop in source) {\n      if (source.hasOwnProperty(prop)) {\n        dest[prop] = source[prop];\n      }\n    }\n  }\n\n  return dest;\n}\n\nexport function copyArray(arg: ArrayLike<any>): any[] {\n  return Array.prototype.slice.call(arg);\n}\n\nvar baseTypes = ['number', 'string', 'boolean', 'array', 'function', 'date',\n                 'regexp', 'arguments', 'undefined', 'null'];\n\nfunction internalType(value: any): string {\n  return Object.prototype.toString.call(value).match(/\\[object (.*)\\]/)[1].toLowerCase();\n}\n\nexport function isType(value: any, type: string): boolean {\n  return typeOf(value) === type;\n}\n\n// Return one of the baseTypes as a string\nexport function typeOf(value: any): string {\n  if (value === undefined) {\n    return 'undefined';\n  }\n  if (value === null) {\n    return 'null';\n  }\n  var type = internalType(value);\n  if (!arrayIncludes(baseTypes, type)) {\n    type = typeof value;\n  }\n  return type;\n}\n\nexport function isThenable(obj: any): boolean {\n  return typeOf(obj) === 'object' && 'then' in obj && typeof(obj.then) === 'function';\n}\n\n// Converts a synchronous function to one allowing Promises\n// as arguments and returning a Promise value.\n//\n//   fn(U, V, ...): T => fn(U | Promise<U>, V | Promise<V>, ...): Promise<T>\nexport function lift<T>(fn: (...args: any[]) => T)\n: (...args: any[]) => Promise<T> {\n  return function(...args: any[]): Promise<T> {\n    return Promise.all(args)\n      .then((values: any[]) => {\n        return fn.apply(undefined, values);\n      });\n  };\n}\n\n// Converts an asynchronous function to one allowing Promises\n// as arguments.\n//\n//   fn(U, V, ...): Promise<T> => fn(U | Promise<U>, V | Promise<V>, ...): Promise<T>\nexport let liftArgs: <T>\n  (fn: (...args: any[]) => Promise<T>) =>\n  ((...args: any[]) => Promise<T>) = lift;\n\nexport let getProp = lift((obj, prop) => obj[prop]);\n\nexport function ensureExtension(fileName: string, extension: string): string {\n  if (fileName.indexOf('.') === -1) {\n    return fileName + '.' + extension;\n  }\n  return fileName;\n}\n\nexport function replaceExtension(fileName: string, extension: string): string {\n  return fileName.replace(/\\.[^\\.]*$/, '.' + extension);\n}\n\nexport function prettyJSON(o: any): string {\n  return JSON.stringify(o, null, 2);\n}\n\nfunction deepExtend(target: Object, source: Object): void {\n  for (var prop in source) {\n    if (!source.hasOwnProperty(prop)) {\n      continue;\n    }\n\n    if (target[prop] !== undefined) {\n      throw new Error(\"Property overwrite: \" + prop);\n    }\n\n    if (isType(source[prop], 'object')) {\n      target[prop] = {};\n      deepExtend(target[prop], source[prop]);\n    } else {\n      target[prop] = source[prop];\n    }\n  }\n}\n\nexport function deepLookup(o: Object, path: string[]): Object | undefined {\n  let result = o;\n\n  for (let i = 0; i < path.length; i++) {\n    if (result === undefined) {\n      return undefined;\n    }\n    result = result[path[i]];\n  }\n  return result;\n}\n\n// Like JSON.stringify - but for single-quoted strings instead of double-quoted ones.\n// This just makes the compiled rules much easier to read.\n\n// Quote all control characters, slash, single quotes, and non-ascii printables.\nvar quotableCharacters = /[\\u0000-\\u001f\\\\\\'\\u007f-\\uffff]/g;\nvar specialQuotes = <{[c: string]: string}> {\n  '\\'': '\\\\\\'',\n  '\\b': '\\\\b',\n  '\\t': '\\\\t',\n  '\\n': '\\\\n',\n  '\\f': '\\\\f',\n  '\\r': '\\\\r'\n};\n\nexport function quoteString(s: string): string {\n  s = s.replace(quotableCharacters, function(c) {\n    if (specialQuotes[c]) {\n      return specialQuotes[c];\n    }\n    return '\\\\u' + ('0000' + c.charCodeAt(0).toString(16)).slice(-4);\n  });\n  return \"'\" + s + \"'\";\n}\n\nexport function arrayIncludes(a: any[], e: any): boolean {\n  return a.indexOf(e) !== -1;\n}\n\n// Like Python list.extend\nexport function extendArray(target: any[], src: any[]) {\n  if (target === undefined) {\n    target = [];\n  }\n  Array.prototype.push.apply(target, src);\n  return target;\n}\n\nexport function or(target: any, src: any) {\n  if (target === undefined) {\n    return false;\n  }\n  return target || src;\n}\n\nexport function ensureObjectPath(obj: Object, parts: string[]): Object {\n  for (var i = 0; i < parts.length; i++) {\n    var name = parts[i];\n    if (!(name in obj)) {\n      obj[name] = {};\n    }\n    obj = obj[name];\n  }\n  return obj;\n}\n\n// Remove all empty, '{}',  children and undefined - returns true iff obj is empty.\nexport function pruneEmptyChildren(obj: Object): boolean {\n  if (obj === undefined) {\n    return true;\n  }\n  if (obj.constructor !== Object) {\n    return false;\n  }\n  var hasChildren = false;\n  for (var prop in obj) {\n    if (!obj.hasOwnProperty(prop)) {\n      continue;\n    }\n    if (pruneEmptyChildren(obj[prop])) {\n      delete obj[prop];\n    } else {\n      hasChildren = true;\n    }\n  }\n  return !hasChildren;\n}\n\nexport function deletePropName(obj: Object, name: string) {\n  if (obj.constructor !== Object) {\n    return;\n  }\n  for (var prop in obj) {\n    if (!obj.hasOwnProperty(prop)) {\n      continue;\n    }\n    if (prop === name) {\n      delete obj[prop];\n    } else {\n      deletePropName(obj[prop], name);\n    }\n  }\n}\n\nexport function formatColumns(indent: number, lines: string[][]): string[] {\n  let result: string[] = [];\n  let columnSize = <number[]> [];\n\n  for (let i = 0; i < lines.length; i++) {\n    let line = lines[i];\n    for (let j = 0; j < line.length; j++) {\n      if (columnSize[j] === undefined) {\n        columnSize[j] = 0;\n      }\n      columnSize[j] = Math.max(columnSize[j], line[j].length);\n    }\n  }\n\n  var prefix = repeatString(' ', indent);\n  var s: string;\n  for (let i = 0; i < lines.length; i++) {\n    let line = lines[i];\n    let sep = \"\";\n    s = \"\";\n    for (let j = 0; j < line.length; j++) {\n      if (j === 0) {\n        s = prefix;\n      }\n      if (j === line.length - 1) {\n        s += sep + line[j];\n      } else {\n        s += sep + fillString(line[j], columnSize[j]);\n      }\n      sep = \"  \";\n    }\n    result.push(s);\n  }\n\n  return result;\n}\n\nfunction repeatString(s: string, n: number): string {\n  return new Array(n + 1).join(s);\n}\n\nfunction fillString(s: string, n: number): string {\n  let padding = n - s.length;\n  if (padding > 0) {\n    s += repeatString(' ', padding);\n  }\n  return s;\n}\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\n(function () {\n    try {\n        cachedSetTimeout = setTimeout;\n    } catch (e) {\n        cachedSetTimeout = function () {\n            throw new Error('setTimeout is not defined');\n        }\n    }\n    try {\n        cachedClearTimeout = clearTimeout;\n    } catch (e) {\n        cachedClearTimeout = function () {\n            throw new Error('clearTimeout is not defined');\n        }\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        return setTimeout(fun, 0);\n    } else {\n        return cachedSetTimeout.call(null, fun, 0);\n    }\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        clearTimeout(marker);\n    } else {\n        cachedClearTimeout.call(null, marker);\n    }\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","/*!\n * @overview es6-promise - a tiny implementation of Promises/A+.\n * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)\n * @license   Licensed under MIT license\n *            See https://raw.githubusercontent.com/jakearchibald/es6-promise/master/LICENSE\n * @version   3.2.1\n */\n\n(function() {\n    \"use strict\";\n    function lib$es6$promise$utils$$objectOrFunction(x) {\n      return typeof x === 'function' || (typeof x === 'object' && x !== null);\n    }\n\n    function lib$es6$promise$utils$$isFunction(x) {\n      return typeof x === 'function';\n    }\n\n    function lib$es6$promise$utils$$isMaybeThenable(x) {\n      return typeof x === 'object' && x !== null;\n    }\n\n    var lib$es6$promise$utils$$_isArray;\n    if (!Array.isArray) {\n      lib$es6$promise$utils$$_isArray = function (x) {\n        return Object.prototype.toString.call(x) === '[object Array]';\n      };\n    } else {\n      lib$es6$promise$utils$$_isArray = Array.isArray;\n    }\n\n    var lib$es6$promise$utils$$isArray = lib$es6$promise$utils$$_isArray;\n    var lib$es6$promise$asap$$len = 0;\n    var lib$es6$promise$asap$$vertxNext;\n    var lib$es6$promise$asap$$customSchedulerFn;\n\n    var lib$es6$promise$asap$$asap = function asap(callback, arg) {\n      lib$es6$promise$asap$$queue[lib$es6$promise$asap$$len] = callback;\n      lib$es6$promise$asap$$queue[lib$es6$promise$asap$$len + 1] = arg;\n      lib$es6$promise$asap$$len += 2;\n      if (lib$es6$promise$asap$$len === 2) {\n        // If len is 2, that means that we need to schedule an async flush.\n        // If additional callbacks are queued before the queue is flushed, they\n        // will be processed by this flush that we are scheduling.\n        if (lib$es6$promise$asap$$customSchedulerFn) {\n          lib$es6$promise$asap$$customSchedulerFn(lib$es6$promise$asap$$flush);\n        } else {\n          lib$es6$promise$asap$$scheduleFlush();\n        }\n      }\n    }\n\n    function lib$es6$promise$asap$$setScheduler(scheduleFn) {\n      lib$es6$promise$asap$$customSchedulerFn = scheduleFn;\n    }\n\n    function lib$es6$promise$asap$$setAsap(asapFn) {\n      lib$es6$promise$asap$$asap = asapFn;\n    }\n\n    var lib$es6$promise$asap$$browserWindow = (typeof window !== 'undefined') ? window : undefined;\n    var lib$es6$promise$asap$$browserGlobal = lib$es6$promise$asap$$browserWindow || {};\n    var lib$es6$promise$asap$$BrowserMutationObserver = lib$es6$promise$asap$$browserGlobal.MutationObserver || lib$es6$promise$asap$$browserGlobal.WebKitMutationObserver;\n    var lib$es6$promise$asap$$isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';\n\n    // test for web worker but not in IE10\n    var lib$es6$promise$asap$$isWorker = typeof Uint8ClampedArray !== 'undefined' &&\n      typeof importScripts !== 'undefined' &&\n      typeof MessageChannel !== 'undefined';\n\n    // node\n    function lib$es6$promise$asap$$useNextTick() {\n      // node version 0.10.x displays a deprecation warning when nextTick is used recursively\n      // see https://github.com/cujojs/when/issues/410 for details\n      return function() {\n        process.nextTick(lib$es6$promise$asap$$flush);\n      };\n    }\n\n    // vertx\n    function lib$es6$promise$asap$$useVertxTimer() {\n      return function() {\n        lib$es6$promise$asap$$vertxNext(lib$es6$promise$asap$$flush);\n      };\n    }\n\n    function lib$es6$promise$asap$$useMutationObserver() {\n      var iterations = 0;\n      var observer = new lib$es6$promise$asap$$BrowserMutationObserver(lib$es6$promise$asap$$flush);\n      var node = document.createTextNode('');\n      observer.observe(node, { characterData: true });\n\n      return function() {\n        node.data = (iterations = ++iterations % 2);\n      };\n    }\n\n    // web worker\n    function lib$es6$promise$asap$$useMessageChannel() {\n      var channel = new MessageChannel();\n      channel.port1.onmessage = lib$es6$promise$asap$$flush;\n      return function () {\n        channel.port2.postMessage(0);\n      };\n    }\n\n    function lib$es6$promise$asap$$useSetTimeout() {\n      return function() {\n        setTimeout(lib$es6$promise$asap$$flush, 1);\n      };\n    }\n\n    var lib$es6$promise$asap$$queue = new Array(1000);\n    function lib$es6$promise$asap$$flush() {\n      for (var i = 0; i < lib$es6$promise$asap$$len; i+=2) {\n        var callback = lib$es6$promise$asap$$queue[i];\n        var arg = lib$es6$promise$asap$$queue[i+1];\n\n        callback(arg);\n\n        lib$es6$promise$asap$$queue[i] = undefined;\n        lib$es6$promise$asap$$queue[i+1] = undefined;\n      }\n\n      lib$es6$promise$asap$$len = 0;\n    }\n\n    function lib$es6$promise$asap$$attemptVertx() {\n      try {\n        var r = require;\n        var vertx = r('vertx');\n        lib$es6$promise$asap$$vertxNext = vertx.runOnLoop || vertx.runOnContext;\n        return lib$es6$promise$asap$$useVertxTimer();\n      } catch(e) {\n        return lib$es6$promise$asap$$useSetTimeout();\n      }\n    }\n\n    var lib$es6$promise$asap$$scheduleFlush;\n    // Decide what async method to use to triggering processing of queued callbacks:\n    if (lib$es6$promise$asap$$isNode) {\n      lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useNextTick();\n    } else if (lib$es6$promise$asap$$BrowserMutationObserver) {\n      lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useMutationObserver();\n    } else if (lib$es6$promise$asap$$isWorker) {\n      lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useMessageChannel();\n    } else if (lib$es6$promise$asap$$browserWindow === undefined && typeof require === 'function') {\n      lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$attemptVertx();\n    } else {\n      lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useSetTimeout();\n    }\n    function lib$es6$promise$then$$then(onFulfillment, onRejection) {\n      var parent = this;\n\n      var child = new this.constructor(lib$es6$promise$$internal$$noop);\n\n      if (child[lib$es6$promise$$internal$$PROMISE_ID] === undefined) {\n        lib$es6$promise$$internal$$makePromise(child);\n      }\n\n      var state = parent._state;\n\n      if (state) {\n        var callback = arguments[state - 1];\n        lib$es6$promise$asap$$asap(function(){\n          lib$es6$promise$$internal$$invokeCallback(state, child, callback, parent._result);\n        });\n      } else {\n        lib$es6$promise$$internal$$subscribe(parent, child, onFulfillment, onRejection);\n      }\n\n      return child;\n    }\n    var lib$es6$promise$then$$default = lib$es6$promise$then$$then;\n    function lib$es6$promise$promise$resolve$$resolve(object) {\n      /*jshint validthis:true */\n      var Constructor = this;\n\n      if (object && typeof object === 'object' && object.constructor === Constructor) {\n        return object;\n      }\n\n      var promise = new Constructor(lib$es6$promise$$internal$$noop);\n      lib$es6$promise$$internal$$resolve(promise, object);\n      return promise;\n    }\n    var lib$es6$promise$promise$resolve$$default = lib$es6$promise$promise$resolve$$resolve;\n    var lib$es6$promise$$internal$$PROMISE_ID = Math.random().toString(36).substring(16);\n\n    function lib$es6$promise$$internal$$noop() {}\n\n    var lib$es6$promise$$internal$$PENDING   = void 0;\n    var lib$es6$promise$$internal$$FULFILLED = 1;\n    var lib$es6$promise$$internal$$REJECTED  = 2;\n\n    var lib$es6$promise$$internal$$GET_THEN_ERROR = new lib$es6$promise$$internal$$ErrorObject();\n\n    function lib$es6$promise$$internal$$selfFulfillment() {\n      return new TypeError(\"You cannot resolve a promise with itself\");\n    }\n\n    function lib$es6$promise$$internal$$cannotReturnOwn() {\n      return new TypeError('A promises callback cannot return that same promise.');\n    }\n\n    function lib$es6$promise$$internal$$getThen(promise) {\n      try {\n        return promise.then;\n      } catch(error) {\n        lib$es6$promise$$internal$$GET_THEN_ERROR.error = error;\n        return lib$es6$promise$$internal$$GET_THEN_ERROR;\n      }\n    }\n\n    function lib$es6$promise$$internal$$tryThen(then, value, fulfillmentHandler, rejectionHandler) {\n      try {\n        then.call(value, fulfillmentHandler, rejectionHandler);\n      } catch(e) {\n        return e;\n      }\n    }\n\n    function lib$es6$promise$$internal$$handleForeignThenable(promise, thenable, then) {\n       lib$es6$promise$asap$$asap(function(promise) {\n        var sealed = false;\n        var error = lib$es6$promise$$internal$$tryThen(then, thenable, function(value) {\n          if (sealed) { return; }\n          sealed = true;\n          if (thenable !== value) {\n            lib$es6$promise$$internal$$resolve(promise, value);\n          } else {\n            lib$es6$promise$$internal$$fulfill(promise, value);\n          }\n        }, function(reason) {\n          if (sealed) { return; }\n          sealed = true;\n\n          lib$es6$promise$$internal$$reject(promise, reason);\n        }, 'Settle: ' + (promise._label || ' unknown promise'));\n\n        if (!sealed && error) {\n          sealed = true;\n          lib$es6$promise$$internal$$reject(promise, error);\n        }\n      }, promise);\n    }\n\n    function lib$es6$promise$$internal$$handleOwnThenable(promise, thenable) {\n      if (thenable._state === lib$es6$promise$$internal$$FULFILLED) {\n        lib$es6$promise$$internal$$fulfill(promise, thenable._result);\n      } else if (thenable._state === lib$es6$promise$$internal$$REJECTED) {\n        lib$es6$promise$$internal$$reject(promise, thenable._result);\n      } else {\n        lib$es6$promise$$internal$$subscribe(thenable, undefined, function(value) {\n          lib$es6$promise$$internal$$resolve(promise, value);\n        }, function(reason) {\n          lib$es6$promise$$internal$$reject(promise, reason);\n        });\n      }\n    }\n\n    function lib$es6$promise$$internal$$handleMaybeThenable(promise, maybeThenable, then) {\n      if (maybeThenable.constructor === promise.constructor &&\n          then === lib$es6$promise$then$$default &&\n          constructor.resolve === lib$es6$promise$promise$resolve$$default) {\n        lib$es6$promise$$internal$$handleOwnThenable(promise, maybeThenable);\n      } else {\n        if (then === lib$es6$promise$$internal$$GET_THEN_ERROR) {\n          lib$es6$promise$$internal$$reject(promise, lib$es6$promise$$internal$$GET_THEN_ERROR.error);\n        } else if (then === undefined) {\n          lib$es6$promise$$internal$$fulfill(promise, maybeThenable);\n        } else if (lib$es6$promise$utils$$isFunction(then)) {\n          lib$es6$promise$$internal$$handleForeignThenable(promise, maybeThenable, then);\n        } else {\n          lib$es6$promise$$internal$$fulfill(promise, maybeThenable);\n        }\n      }\n    }\n\n    function lib$es6$promise$$internal$$resolve(promise, value) {\n      if (promise === value) {\n        lib$es6$promise$$internal$$reject(promise, lib$es6$promise$$internal$$selfFulfillment());\n      } else if (lib$es6$promise$utils$$objectOrFunction(value)) {\n        lib$es6$promise$$internal$$handleMaybeThenable(promise, value, lib$es6$promise$$internal$$getThen(value));\n      } else {\n        lib$es6$promise$$internal$$fulfill(promise, value);\n      }\n    }\n\n    function lib$es6$promise$$internal$$publishRejection(promise) {\n      if (promise._onerror) {\n        promise._onerror(promise._result);\n      }\n\n      lib$es6$promise$$internal$$publish(promise);\n    }\n\n    function lib$es6$promise$$internal$$fulfill(promise, value) {\n      if (promise._state !== lib$es6$promise$$internal$$PENDING) { return; }\n\n      promise._result = value;\n      promise._state = lib$es6$promise$$internal$$FULFILLED;\n\n      if (promise._subscribers.length !== 0) {\n        lib$es6$promise$asap$$asap(lib$es6$promise$$internal$$publish, promise);\n      }\n    }\n\n    function lib$es6$promise$$internal$$reject(promise, reason) {\n      if (promise._state !== lib$es6$promise$$internal$$PENDING) { return; }\n      promise._state = lib$es6$promise$$internal$$REJECTED;\n      promise._result = reason;\n\n      lib$es6$promise$asap$$asap(lib$es6$promise$$internal$$publishRejection, promise);\n    }\n\n    function lib$es6$promise$$internal$$subscribe(parent, child, onFulfillment, onRejection) {\n      var subscribers = parent._subscribers;\n      var length = subscribers.length;\n\n      parent._onerror = null;\n\n      subscribers[length] = child;\n      subscribers[length + lib$es6$promise$$internal$$FULFILLED] = onFulfillment;\n      subscribers[length + lib$es6$promise$$internal$$REJECTED]  = onRejection;\n\n      if (length === 0 && parent._state) {\n        lib$es6$promise$asap$$asap(lib$es6$promise$$internal$$publish, parent);\n      }\n    }\n\n    function lib$es6$promise$$internal$$publish(promise) {\n      var subscribers = promise._subscribers;\n      var settled = promise._state;\n\n      if (subscribers.length === 0) { return; }\n\n      var child, callback, detail = promise._result;\n\n      for (var i = 0; i < subscribers.length; i += 3) {\n        child = subscribers[i];\n        callback = subscribers[i + settled];\n\n        if (child) {\n          lib$es6$promise$$internal$$invokeCallback(settled, child, callback, detail);\n        } else {\n          callback(detail);\n        }\n      }\n\n      promise._subscribers.length = 0;\n    }\n\n    function lib$es6$promise$$internal$$ErrorObject() {\n      this.error = null;\n    }\n\n    var lib$es6$promise$$internal$$TRY_CATCH_ERROR = new lib$es6$promise$$internal$$ErrorObject();\n\n    function lib$es6$promise$$internal$$tryCatch(callback, detail) {\n      try {\n        return callback(detail);\n      } catch(e) {\n        lib$es6$promise$$internal$$TRY_CATCH_ERROR.error = e;\n        return lib$es6$promise$$internal$$TRY_CATCH_ERROR;\n      }\n    }\n\n    function lib$es6$promise$$internal$$invokeCallback(settled, promise, callback, detail) {\n      var hasCallback = lib$es6$promise$utils$$isFunction(callback),\n          value, error, succeeded, failed;\n\n      if (hasCallback) {\n        value = lib$es6$promise$$internal$$tryCatch(callback, detail);\n\n        if (value === lib$es6$promise$$internal$$TRY_CATCH_ERROR) {\n          failed = true;\n          error = value.error;\n          value = null;\n        } else {\n          succeeded = true;\n        }\n\n        if (promise === value) {\n          lib$es6$promise$$internal$$reject(promise, lib$es6$promise$$internal$$cannotReturnOwn());\n          return;\n        }\n\n      } else {\n        value = detail;\n        succeeded = true;\n      }\n\n      if (promise._state !== lib$es6$promise$$internal$$PENDING) {\n        // noop\n      } else if (hasCallback && succeeded) {\n        lib$es6$promise$$internal$$resolve(promise, value);\n      } else if (failed) {\n        lib$es6$promise$$internal$$reject(promise, error);\n      } else if (settled === lib$es6$promise$$internal$$FULFILLED) {\n        lib$es6$promise$$internal$$fulfill(promise, value);\n      } else if (settled === lib$es6$promise$$internal$$REJECTED) {\n        lib$es6$promise$$internal$$reject(promise, value);\n      }\n    }\n\n    function lib$es6$promise$$internal$$initializePromise(promise, resolver) {\n      try {\n        resolver(function resolvePromise(value){\n          lib$es6$promise$$internal$$resolve(promise, value);\n        }, function rejectPromise(reason) {\n          lib$es6$promise$$internal$$reject(promise, reason);\n        });\n      } catch(e) {\n        lib$es6$promise$$internal$$reject(promise, e);\n      }\n    }\n\n    var lib$es6$promise$$internal$$id = 0;\n    function lib$es6$promise$$internal$$nextId() {\n      return lib$es6$promise$$internal$$id++;\n    }\n\n    function lib$es6$promise$$internal$$makePromise(promise) {\n      promise[lib$es6$promise$$internal$$PROMISE_ID] = lib$es6$promise$$internal$$id++;\n      promise._state = undefined;\n      promise._result = undefined;\n      promise._subscribers = [];\n    }\n\n    function lib$es6$promise$promise$all$$all(entries) {\n      return new lib$es6$promise$enumerator$$default(this, entries).promise;\n    }\n    var lib$es6$promise$promise$all$$default = lib$es6$promise$promise$all$$all;\n    function lib$es6$promise$promise$race$$race(entries) {\n      /*jshint validthis:true */\n      var Constructor = this;\n\n      if (!lib$es6$promise$utils$$isArray(entries)) {\n        return new Constructor(function(resolve, reject) {\n          reject(new TypeError('You must pass an array to race.'));\n        });\n      } else {\n        return new Constructor(function(resolve, reject) {\n          var length = entries.length;\n          for (var i = 0; i < length; i++) {\n            Constructor.resolve(entries[i]).then(resolve, reject);\n          }\n        });\n      }\n    }\n    var lib$es6$promise$promise$race$$default = lib$es6$promise$promise$race$$race;\n    function lib$es6$promise$promise$reject$$reject(reason) {\n      /*jshint validthis:true */\n      var Constructor = this;\n      var promise = new Constructor(lib$es6$promise$$internal$$noop);\n      lib$es6$promise$$internal$$reject(promise, reason);\n      return promise;\n    }\n    var lib$es6$promise$promise$reject$$default = lib$es6$promise$promise$reject$$reject;\n\n\n    function lib$es6$promise$promise$$needsResolver() {\n      throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');\n    }\n\n    function lib$es6$promise$promise$$needsNew() {\n      throw new TypeError(\"Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.\");\n    }\n\n    var lib$es6$promise$promise$$default = lib$es6$promise$promise$$Promise;\n    /**\n      Promise objects represent the eventual result of an asynchronous operation. The\n      primary way of interacting with a promise is through its `then` method, which\n      registers callbacks to receive either a promise's eventual value or the reason\n      why the promise cannot be fulfilled.\n\n      Terminology\n      -----------\n\n      - `promise` is an object or function with a `then` method whose behavior conforms to this specification.\n      - `thenable` is an object or function that defines a `then` method.\n      - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).\n      - `exception` is a value that is thrown using the throw statement.\n      - `reason` is a value that indicates why a promise was rejected.\n      - `settled` the final resting state of a promise, fulfilled or rejected.\n\n      A promise can be in one of three states: pending, fulfilled, or rejected.\n\n      Promises that are fulfilled have a fulfillment value and are in the fulfilled\n      state.  Promises that are rejected have a rejection reason and are in the\n      rejected state.  A fulfillment value is never a thenable.\n\n      Promises can also be said to *resolve* a value.  If this value is also a\n      promise, then the original promise's settled state will match the value's\n      settled state.  So a promise that *resolves* a promise that rejects will\n      itself reject, and a promise that *resolves* a promise that fulfills will\n      itself fulfill.\n\n\n      Basic Usage:\n      ------------\n\n      ```js\n      var promise = new Promise(function(resolve, reject) {\n        // on success\n        resolve(value);\n\n        // on failure\n        reject(reason);\n      });\n\n      promise.then(function(value) {\n        // on fulfillment\n      }, function(reason) {\n        // on rejection\n      });\n      ```\n\n      Advanced Usage:\n      ---------------\n\n      Promises shine when abstracting away asynchronous interactions such as\n      `XMLHttpRequest`s.\n\n      ```js\n      function getJSON(url) {\n        return new Promise(function(resolve, reject){\n          var xhr = new XMLHttpRequest();\n\n          xhr.open('GET', url);\n          xhr.onreadystatechange = handler;\n          xhr.responseType = 'json';\n          xhr.setRequestHeader('Accept', 'application/json');\n          xhr.send();\n\n          function handler() {\n            if (this.readyState === this.DONE) {\n              if (this.status === 200) {\n                resolve(this.response);\n              } else {\n                reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));\n              }\n            }\n          };\n        });\n      }\n\n      getJSON('/posts.json').then(function(json) {\n        // on fulfillment\n      }, function(reason) {\n        // on rejection\n      });\n      ```\n\n      Unlike callbacks, promises are great composable primitives.\n\n      ```js\n      Promise.all([\n        getJSON('/posts'),\n        getJSON('/comments')\n      ]).then(function(values){\n        values[0] // => postsJSON\n        values[1] // => commentsJSON\n\n        return values;\n      });\n      ```\n\n      @class Promise\n      @param {function} resolver\n      Useful for tooling.\n      @constructor\n    */\n    function lib$es6$promise$promise$$Promise(resolver) {\n      this[lib$es6$promise$$internal$$PROMISE_ID] = lib$es6$promise$$internal$$nextId();\n      this._result = this._state = undefined;\n      this._subscribers = [];\n\n      if (lib$es6$promise$$internal$$noop !== resolver) {\n        typeof resolver !== 'function' && lib$es6$promise$promise$$needsResolver();\n        this instanceof lib$es6$promise$promise$$Promise ? lib$es6$promise$$internal$$initializePromise(this, resolver) : lib$es6$promise$promise$$needsNew();\n      }\n    }\n\n    lib$es6$promise$promise$$Promise.all = lib$es6$promise$promise$all$$default;\n    lib$es6$promise$promise$$Promise.race = lib$es6$promise$promise$race$$default;\n    lib$es6$promise$promise$$Promise.resolve = lib$es6$promise$promise$resolve$$default;\n    lib$es6$promise$promise$$Promise.reject = lib$es6$promise$promise$reject$$default;\n    lib$es6$promise$promise$$Promise._setScheduler = lib$es6$promise$asap$$setScheduler;\n    lib$es6$promise$promise$$Promise._setAsap = lib$es6$promise$asap$$setAsap;\n    lib$es6$promise$promise$$Promise._asap = lib$es6$promise$asap$$asap;\n\n    lib$es6$promise$promise$$Promise.prototype = {\n      constructor: lib$es6$promise$promise$$Promise,\n\n    /**\n      The primary way of interacting with a promise is through its `then` method,\n      which registers callbacks to receive either a promise's eventual value or the\n      reason why the promise cannot be fulfilled.\n\n      ```js\n      findUser().then(function(user){\n        // user is available\n      }, function(reason){\n        // user is unavailable, and you are given the reason why\n      });\n      ```\n\n      Chaining\n      --------\n\n      The return value of `then` is itself a promise.  This second, 'downstream'\n      promise is resolved with the return value of the first promise's fulfillment\n      or rejection handler, or rejected if the handler throws an exception.\n\n      ```js\n      findUser().then(function (user) {\n        return user.name;\n      }, function (reason) {\n        return 'default name';\n      }).then(function (userName) {\n        // If `findUser` fulfilled, `userName` will be the user's name, otherwise it\n        // will be `'default name'`\n      });\n\n      findUser().then(function (user) {\n        throw new Error('Found user, but still unhappy');\n      }, function (reason) {\n        throw new Error('`findUser` rejected and we're unhappy');\n      }).then(function (value) {\n        // never reached\n      }, function (reason) {\n        // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.\n        // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.\n      });\n      ```\n      If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.\n\n      ```js\n      findUser().then(function (user) {\n        throw new PedagogicalException('Upstream error');\n      }).then(function (value) {\n        // never reached\n      }).then(function (value) {\n        // never reached\n      }, function (reason) {\n        // The `PedgagocialException` is propagated all the way down to here\n      });\n      ```\n\n      Assimilation\n      ------------\n\n      Sometimes the value you want to propagate to a downstream promise can only be\n      retrieved asynchronously. This can be achieved by returning a promise in the\n      fulfillment or rejection handler. The downstream promise will then be pending\n      until the returned promise is settled. This is called *assimilation*.\n\n      ```js\n      findUser().then(function (user) {\n        return findCommentsByAuthor(user);\n      }).then(function (comments) {\n        // The user's comments are now available\n      });\n      ```\n\n      If the assimliated promise rejects, then the downstream promise will also reject.\n\n      ```js\n      findUser().then(function (user) {\n        return findCommentsByAuthor(user);\n      }).then(function (comments) {\n        // If `findCommentsByAuthor` fulfills, we'll have the value here\n      }, function (reason) {\n        // If `findCommentsByAuthor` rejects, we'll have the reason here\n      });\n      ```\n\n      Simple Example\n      --------------\n\n      Synchronous Example\n\n      ```javascript\n      var result;\n\n      try {\n        result = findResult();\n        // success\n      } catch(reason) {\n        // failure\n      }\n      ```\n\n      Errback Example\n\n      ```js\n      findResult(function(result, err){\n        if (err) {\n          // failure\n        } else {\n          // success\n        }\n      });\n      ```\n\n      Promise Example;\n\n      ```javascript\n      findResult().then(function(result){\n        // success\n      }, function(reason){\n        // failure\n      });\n      ```\n\n      Advanced Example\n      --------------\n\n      Synchronous Example\n\n      ```javascript\n      var author, books;\n\n      try {\n        author = findAuthor();\n        books  = findBooksByAuthor(author);\n        // success\n      } catch(reason) {\n        // failure\n      }\n      ```\n\n      Errback Example\n\n      ```js\n\n      function foundBooks(books) {\n\n      }\n\n      function failure(reason) {\n\n      }\n\n      findAuthor(function(author, err){\n        if (err) {\n          failure(err);\n          // failure\n        } else {\n          try {\n            findBoooksByAuthor(author, function(books, err) {\n              if (err) {\n                failure(err);\n              } else {\n                try {\n                  foundBooks(books);\n                } catch(reason) {\n                  failure(reason);\n                }\n              }\n            });\n          } catch(error) {\n            failure(err);\n          }\n          // success\n        }\n      });\n      ```\n\n      Promise Example;\n\n      ```javascript\n      findAuthor().\n        then(findBooksByAuthor).\n        then(function(books){\n          // found books\n      }).catch(function(reason){\n        // something went wrong\n      });\n      ```\n\n      @method then\n      @param {Function} onFulfilled\n      @param {Function} onRejected\n      Useful for tooling.\n      @return {Promise}\n    */\n      then: lib$es6$promise$then$$default,\n\n    /**\n      `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same\n      as the catch block of a try/catch statement.\n\n      ```js\n      function findAuthor(){\n        throw new Error('couldn't find that author');\n      }\n\n      // synchronous\n      try {\n        findAuthor();\n      } catch(reason) {\n        // something went wrong\n      }\n\n      // async with promises\n      findAuthor().catch(function(reason){\n        // something went wrong\n      });\n      ```\n\n      @method catch\n      @param {Function} onRejection\n      Useful for tooling.\n      @return {Promise}\n    */\n      'catch': function(onRejection) {\n        return this.then(null, onRejection);\n      }\n    };\n    var lib$es6$promise$enumerator$$default = lib$es6$promise$enumerator$$Enumerator;\n    function lib$es6$promise$enumerator$$Enumerator(Constructor, input) {\n      this._instanceConstructor = Constructor;\n      this.promise = new Constructor(lib$es6$promise$$internal$$noop);\n\n      if (!this.promise[lib$es6$promise$$internal$$PROMISE_ID]) {\n        lib$es6$promise$$internal$$makePromise(this.promise);\n      }\n\n      if (lib$es6$promise$utils$$isArray(input)) {\n        this._input     = input;\n        this.length     = input.length;\n        this._remaining = input.length;\n\n        this._result = new Array(this.length);\n\n        if (this.length === 0) {\n          lib$es6$promise$$internal$$fulfill(this.promise, this._result);\n        } else {\n          this.length = this.length || 0;\n          this._enumerate();\n          if (this._remaining === 0) {\n            lib$es6$promise$$internal$$fulfill(this.promise, this._result);\n          }\n        }\n      } else {\n        lib$es6$promise$$internal$$reject(this.promise, lib$es6$promise$enumerator$$validationError());\n      }\n    }\n\n    function lib$es6$promise$enumerator$$validationError() {\n      return new Error('Array Methods must be provided an Array');\n    }\n\n    lib$es6$promise$enumerator$$Enumerator.prototype._enumerate = function() {\n      var length  = this.length;\n      var input   = this._input;\n\n      for (var i = 0; this._state === lib$es6$promise$$internal$$PENDING && i < length; i++) {\n        this._eachEntry(input[i], i);\n      }\n    };\n\n    lib$es6$promise$enumerator$$Enumerator.prototype._eachEntry = function(entry, i) {\n      var c = this._instanceConstructor;\n      var resolve = c.resolve;\n\n      if (resolve === lib$es6$promise$promise$resolve$$default) {\n        var then = lib$es6$promise$$internal$$getThen(entry);\n\n        if (then === lib$es6$promise$then$$default &&\n            entry._state !== lib$es6$promise$$internal$$PENDING) {\n          this._settledAt(entry._state, i, entry._result);\n        } else if (typeof then !== 'function') {\n          this._remaining--;\n          this._result[i] = entry;\n        } else if (c === lib$es6$promise$promise$$default) {\n          var promise = new c(lib$es6$promise$$internal$$noop);\n          lib$es6$promise$$internal$$handleMaybeThenable(promise, entry, then);\n          this._willSettleAt(promise, i);\n        } else {\n          this._willSettleAt(new c(function(resolve) { resolve(entry); }), i);\n        }\n      } else {\n        this._willSettleAt(resolve(entry), i);\n      }\n    };\n\n    lib$es6$promise$enumerator$$Enumerator.prototype._settledAt = function(state, i, value) {\n      var promise = this.promise;\n\n      if (promise._state === lib$es6$promise$$internal$$PENDING) {\n        this._remaining--;\n\n        if (state === lib$es6$promise$$internal$$REJECTED) {\n          lib$es6$promise$$internal$$reject(promise, value);\n        } else {\n          this._result[i] = value;\n        }\n      }\n\n      if (this._remaining === 0) {\n        lib$es6$promise$$internal$$fulfill(promise, this._result);\n      }\n    };\n\n    lib$es6$promise$enumerator$$Enumerator.prototype._willSettleAt = function(promise, i) {\n      var enumerator = this;\n\n      lib$es6$promise$$internal$$subscribe(promise, undefined, function(value) {\n        enumerator._settledAt(lib$es6$promise$$internal$$FULFILLED, i, value);\n      }, function(reason) {\n        enumerator._settledAt(lib$es6$promise$$internal$$REJECTED, i, reason);\n      });\n    };\n    function lib$es6$promise$polyfill$$polyfill() {\n      var local;\n\n      if (typeof global !== 'undefined') {\n          local = global;\n      } else if (typeof self !== 'undefined') {\n          local = self;\n      } else {\n          try {\n              local = Function('return this')();\n          } catch (e) {\n              throw new Error('polyfill failed because global object is unavailable in this environment');\n          }\n      }\n\n      var P = local.Promise;\n\n      if (P && Object.prototype.toString.call(P.resolve()) === '[object Promise]' && !P.cast) {\n        return;\n      }\n\n      local.Promise = lib$es6$promise$promise$$default;\n    }\n    var lib$es6$promise$polyfill$$default = lib$es6$promise$polyfill$$polyfill;\n\n    var lib$es6$promise$umd$$ES6Promise = {\n      'Promise': lib$es6$promise$promise$$default,\n      'polyfill': lib$es6$promise$polyfill$$default\n    };\n\n    /* global define:true module:true window: true */\n    if (typeof define === 'function' && define['amd']) {\n      define(function() { return lib$es6$promise$umd$$ES6Promise; });\n    } else if (typeof module !== 'undefined' && module['exports']) {\n      module['exports'] = lib$es6$promise$umd$$ES6Promise;\n    } else if (typeof this !== 'undefined') {\n      this['ES6Promise'] = lib$es6$promise$umd$$ES6Promise;\n    }\n\n    lib$es6$promise$polyfill$$default();\n}).call(this);\n\n"]} diff --git a/package.json b/package.json index a6eb117..fd66cf2 100644 --- a/package.json +++ b/package.json @@ -1,7 +1,7 @@ { "name": "firebase-bolt", "description": "Firebase Bolt Security and Modeling Language Compiler", - "version": "0.0.0", + "version": "0.8.1", "author": "Firebase (https://firebase.google.com/)", "main": "lib/bolt.js", "homepage": "https://github.com/firebase/bolt",