@weborigami/language 0.2.0 → 0.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (7) hide show
  1. package/package.json +3 -3
  2. package/src/compiler/origami.pegjs +104 -19
  3. package/src/compiler/parse.js +1352 -597
  4. package/src/compiler/parserHelpers.js +38 -22
  5. package/src/runtime/ops.js +125 -15
  6. package/test/compiler/parse.test.js +150 -5
  7. package/test/runtime/ops.test.js +144 -26
package/src/compiler/parse.js CHANGED
@@ -21,7 +21,7 @@ import {
21
21
  annotate,
22
22
  downgradeReference,
23
23
  makeArray,
24
- makeBinaryOperatorChain,
24
+ makeBinaryOperation,
25
25
  makeCall,
26
26
  makeDeferredArguments,
27
27
  makeObject,
@@ -29,7 +29,7 @@ import {
29
29
  makeProperty,
30
30
  makeReference,
31
31
  makeTemplate,
32
- makeUnaryOperatorCall
32
+ makeUnaryOperation
33
33
  } from "./parserHelpers.js";
34
34
 
35
35
 
@@ -202,187 +202,230 @@ function peg$parse(input, options) {
202
202
  var peg$FAILED = {};
203
203
  var peg$source = options.grammarSource;
204
204
 
205
- var peg$startRuleFunctions = { __: peg$parse__, arguments: peg$parsearguments, arrayLiteral: peg$parsearrayLiteral, arrayEntries: peg$parsearrayEntries, arrayEntry: peg$parsearrayEntry, arrowFunction: peg$parsearrowFunction, callExpression: peg$parsecallExpression, closingBrace: peg$parseclosingBrace, closingBracket: peg$parseclosingBracket, closingParenthesis: peg$parseclosingParenthesis, comment: peg$parsecomment, conditionalExpression: peg$parseconditionalExpression, digits: peg$parsedigits, doubleArrow: peg$parsedoubleArrow, doubleQuoteString: peg$parsedoubleQuoteString, doubleQuoteStringChar: peg$parsedoubleQuoteStringChar, ellipsis: peg$parseellipsis, equalityExpression: peg$parseequalityExpression, equalityOperator: peg$parseequalityOperator, escapedChar: peg$parseescapedChar, expression: peg$parseexpression, floatLiteral: peg$parsefloatLiteral, group: peg$parsegroup, guillemetString: peg$parseguillemetString, guillemetStringChar: peg$parseguillemetStringChar, homeDirectory: peg$parsehomeDirectory, host: peg$parsehost, identifier: peg$parseidentifier, identifierChar: peg$parseidentifierChar, identifierList: peg$parseidentifierList, implicitParenthesesCallExpression: peg$parseimplicitParenthesesCallExpression, implicitParensthesesArguments: peg$parseimplicitParensthesesArguments, inlineSpace: peg$parseinlineSpace, integerLiteral: peg$parseintegerLiteral, list: peg$parselist, literal: peg$parseliteral, logicalAndExpression: peg$parselogicalAndExpression, logicalOrExpression: peg$parselogicalOrExpression, multiLineComment: peg$parsemultiLineComment, namespace: peg$parsenamespace, newLine: peg$parsenewLine, numericLiteral: peg$parsenumericLiteral, nullishCoalescingExpression: peg$parsenullishCoalescingExpression, objectLiteral: peg$parseobjectLiteral, objectEntries: peg$parseobjectEntries, objectEntry: peg$parseobjectEntry, objectGetter: peg$parseobjectGetter, objectHiddenKey: peg$parseobjectHiddenKey, objectKey: peg$parseobjectKey, objectProperty: peg$parseobjectProperty, objectShorthandProperty: peg$parseobjectShorthandProperty, objectPublicKey: peg$parseobjectPublicKey, parenthesesArguments: peg$parseparenthesesArguments, path: peg$parsepath, pathArguments: peg$parsepathArguments, pathKey: peg$parsepathKey, pathSegment: peg$parsepathSegment, pathSegmentChar: peg$parsepathSegmentChar, pipelineExpression: peg$parsepipelineExpression, primary: peg$parseprimary, program: peg$parseprogram, protocolExpression: peg$parseprotocolExpression, qualifiedReference: peg$parsequalifiedReference, reference: peg$parsereference, rootDirectory: peg$parserootDirectory, scopeReference: peg$parsescopeReference, separator: peg$parseseparator, slashFollows: peg$parseslashFollows, shebang: peg$parseshebang, shorthandFunction: peg$parseshorthandFunction, sign: peg$parsesign, singleArrow: peg$parsesingleArrow, singleLineComment: peg$parsesingleLineComment, singleQuoteString: peg$parsesingleQuoteString, singleQuoteStringChar: peg$parsesingleQuoteStringChar, spread: peg$parsespread, stringLiteral: peg$parsestringLiteral, templateDocument: peg$parsetemplateDocument, templateDocumentChar: peg$parsetemplateDocumentChar, templateDocumentContents: peg$parsetemplateDocumentContents, templateDocumentText: peg$parsetemplateDocumentText, templateLiteral: peg$parsetemplateLiteral, templateLiteralChar: peg$parsetemplateLiteralChar, templateLiteralContents: peg$parsetemplateLiteralContents, templateLiteralText: peg$parsetemplateLiteralText, templateSubstitution: peg$parsetemplateSubstitution, textChar: peg$parsetextChar, unaryExpression: peg$parseunaryExpression, unaryOperator: peg$parseunaryOperator, whitespaceWithNewLine: peg$parsewhitespaceWithNewLine };
205
+ var peg$startRuleFunctions = { __: peg$parse__, additiveExpression: peg$parseadditiveExpression, additiveOperator: peg$parseadditiveOperator, arguments: peg$parsearguments, arrayLiteral: peg$parsearrayLiteral, arrayEntries: peg$parsearrayEntries, arrayEntry: peg$parsearrayEntry, arrowFunction: peg$parsearrowFunction, bitwiseAndExpression: peg$parsebitwiseAndExpression, bitwiseAndOperator: peg$parsebitwiseAndOperator, bitwiseOrExpression: peg$parsebitwiseOrExpression, bitwiseOrOperator: peg$parsebitwiseOrOperator, bitwiseXorExpression: peg$parsebitwiseXorExpression, bitwiseXorOperator: peg$parsebitwiseXorOperator, callExpression: peg$parsecallExpression, closingBrace: peg$parseclosingBrace, closingBracket: peg$parseclosingBracket, closingParenthesis: peg$parseclosingParenthesis, commaExpression: peg$parsecommaExpression, comment: peg$parsecomment, conditionalExpression: peg$parseconditionalExpression, digits: peg$parsedigits, doubleArrow: peg$parsedoubleArrow, doubleQuoteString: peg$parsedoubleQuoteString, doubleQuoteStringChar: peg$parsedoubleQuoteStringChar, ellipsis: peg$parseellipsis, equalityExpression: peg$parseequalityExpression, equalityOperator: peg$parseequalityOperator, escapedChar: peg$parseescapedChar, exponentiationExpression: peg$parseexponentiationExpression, expression: peg$parseexpression, floatLiteral: peg$parsefloatLiteral, group: peg$parsegroup, guillemetString: peg$parseguillemetString, guillemetStringChar: peg$parseguillemetStringChar, homeDirectory: peg$parsehomeDirectory, host: peg$parsehost, identifier: peg$parseidentifier, identifierChar: peg$parseidentifierChar, identifierList: peg$parseidentifierList, implicitParenthesesCallExpression: peg$parseimplicitParenthesesCallExpression, implicitParensthesesArguments: peg$parseimplicitParensthesesArguments, inlineSpace: peg$parseinlineSpace, integerLiteral: peg$parseintegerLiteral, list: peg$parselist, literal: peg$parseliteral, logicalAndExpression: peg$parselogicalAndExpression, logicalOrExpression: peg$parselogicalOrExpression, multiLineComment: peg$parsemultiLineComment, multiplicativeExpression: peg$parsemultiplicativeExpression, multiplicativeOperator: peg$parsemultiplicativeOperator, namespace: peg$parsenamespace, newLine: peg$parsenewLine, numericLiteral: peg$parsenumericLiteral, nullishCoalescingExpression: peg$parsenullishCoalescingExpression, objectLiteral: peg$parseobjectLiteral, objectEntries: peg$parseobjectEntries, objectEntry: peg$parseobjectEntry, objectGetter: peg$parseobjectGetter, objectHiddenKey: peg$parseobjectHiddenKey, objectKey: peg$parseobjectKey, objectProperty: peg$parseobjectProperty, objectShorthandProperty: peg$parseobjectShorthandProperty, objectPublicKey: peg$parseobjectPublicKey, parenthesesArguments: peg$parseparenthesesArguments, path: peg$parsepath, pathArguments: peg$parsepathArguments, pathKey: peg$parsepathKey, pathSegment: peg$parsepathSegment, pathSegmentChar: peg$parsepathSegmentChar, pipelineExpression: peg$parsepipelineExpression, primary: peg$parseprimary, program: peg$parseprogram, protocolExpression: peg$parseprotocolExpression, qualifiedReference: peg$parsequalifiedReference, reference: peg$parsereference, relationalExpression: peg$parserelationalExpression, relationalOperator: peg$parserelationalOperator, rootDirectory: peg$parserootDirectory, scopeReference: peg$parsescopeReference, separator: peg$parseseparator, slashFollows: peg$parseslashFollows, shebang: peg$parseshebang, shiftExpression: peg$parseshiftExpression, shiftOperator: peg$parseshiftOperator, shorthandFunction: peg$parseshorthandFunction, singleArrow: peg$parsesingleArrow, singleLineComment: peg$parsesingleLineComment, singleQuoteString: peg$parsesingleQuoteString, singleQuoteStringChar: peg$parsesingleQuoteStringChar, spread: peg$parsespread, stringLiteral: peg$parsestringLiteral, templateDocument: peg$parsetemplateDocument, templateDocumentChar: peg$parsetemplateDocumentChar, templateDocumentContents: peg$parsetemplateDocumentContents, templateDocumentText: peg$parsetemplateDocumentText, templateLiteral: peg$parsetemplateLiteral, templateLiteralChar: peg$parsetemplateLiteralChar, templateLiteralContents: peg$parsetemplateLiteralContents, templateLiteralText: peg$parsetemplateLiteralText, templateSubstitution: peg$parsetemplateSubstitution, textChar: peg$parsetextChar, unaryExpression: peg$parseunaryExpression, unaryOperator: peg$parseunaryOperator, whitespaceWithNewLine: peg$parsewhitespaceWithNewLine };
206
206
  var peg$startRuleFunction = peg$parse__;
207
207
 
208
208
  var peg$c0 = "[";
209
- var peg$c1 = "(";
210
- var peg$c2 = ")";
211
- var peg$c3 = "}";
212
- var peg$c4 = "]";
213
- var peg$c5 = "?";
214
- var peg$c6 = ":";
215
- var peg$c7 = "\u21D2";
216
- var peg$c8 = "=>";
217
- var peg$c9 = "\"";
218
- var peg$c10 = "...";
219
- var peg$c11 = "\u2026";
220
- var peg$c12 = "===";
221
- var peg$c13 = "!==";
222
- var peg$c14 = "==";
223
- var peg$c15 = "!=";
224
- var peg$c16 = "\\0";
225
- var peg$c17 = "\\b";
226
- var peg$c18 = "\\f";
227
- var peg$c19 = "\\n";
228
- var peg$c20 = "\\r";
229
- var peg$c21 = "\\t";
230
- var peg$c22 = "\\v";
231
- var peg$c23 = "\\";
232
- var peg$c24 = ".";
233
- var peg$c25 = "\xAB";
234
- var peg$c26 = "\xBB";
235
- var peg$c27 = "~";
236
- var peg$c28 = "-";
237
- var peg$c29 = ">";
238
- var peg$c30 = "&&";
239
- var peg$c31 = "||";
240
- var peg$c32 = "/*";
241
- var peg$c33 = "*/";
242
- var peg$c34 = "@";
243
- var peg$c35 = "\n";
244
- var peg$c36 = "\r\n";
245
- var peg$c37 = "\r";
246
- var peg$c38 = "??";
247
- var peg$c39 = "{";
248
- var peg$c40 = "=";
249
- var peg$c41 = "/";
250
- var peg$c42 = "//";
251
- var peg$c43 = ",";
252
- var peg$c44 = "#!";
253
- var peg$c45 = "\u2192";
254
- var peg$c46 = "->";
255
- var peg$c47 = "'";
256
- var peg$c48 = "${";
257
- var peg$c49 = "`";
258
- var peg$c50 = "!";
259
-
260
- var peg$r0 = /^[0-9]/;
261
- var peg$r1 = /^[^(){}[\]<>?!&|\-=,\/:`"'\xAB\xBB\\ \u2192\u21D2\t\n\r]/;
262
- var peg$r2 = /^[ \t]/;
263
- var peg$r3 = /^[A-Za-z]/;
264
- var peg$r4 = /^[^(){}[\],:\/\\ \t\n\r]/;
265
- var peg$r5 = /^[^\n\r]/;
266
- var peg$r6 = /^[+\-]/;
267
-
268
- var peg$e0 = peg$otherExpectation("function arguments");
269
- var peg$e1 = peg$otherExpectation("array");
270
- var peg$e2 = peg$literalExpectation("[", false);
271
- var peg$e3 = peg$literalExpectation("(", false);
272
- var peg$e4 = peg$literalExpectation(")", false);
273
- var peg$e5 = peg$otherExpectation("function call");
274
- var peg$e6 = peg$literalExpectation("}", false);
275
- var peg$e7 = peg$anyExpectation();
276
- var peg$e8 = peg$literalExpectation("]", false);
277
- var peg$e9 = peg$otherExpectation("comment");
278
- var peg$e10 = peg$literalExpectation("?", false);
279
- var peg$e11 = peg$literalExpectation(":", false);
280
- var peg$e12 = peg$classExpectation([["0", "9"]], false, false);
281
- var peg$e13 = peg$literalExpectation("\u21D2", false);
282
- var peg$e14 = peg$literalExpectation("=>", false);
283
- var peg$e15 = peg$otherExpectation("double quote string");
284
- var peg$e16 = peg$literalExpectation("\"", false);
285
- var peg$e17 = peg$literalExpectation("...", false);
286
- var peg$e18 = peg$literalExpectation("\u2026", false);
287
- var peg$e19 = peg$literalExpectation("===", false);
288
- var peg$e20 = peg$literalExpectation("!==", false);
289
- var peg$e21 = peg$literalExpectation("==", false);
290
- var peg$e22 = peg$literalExpectation("!=", false);
291
- var peg$e23 = peg$otherExpectation("backslash-escaped character");
292
- var peg$e24 = peg$literalExpectation("\\0", false);
293
- var peg$e25 = peg$literalExpectation("\\b", false);
294
- var peg$e26 = peg$literalExpectation("\\f", false);
295
- var peg$e27 = peg$literalExpectation("\\n", false);
296
- var peg$e28 = peg$literalExpectation("\\r", false);
297
- var peg$e29 = peg$literalExpectation("\\t", false);
298
- var peg$e30 = peg$literalExpectation("\\v", false);
299
- var peg$e31 = peg$literalExpectation("\\", false);
300
- var peg$e32 = peg$otherExpectation("floating-point number");
301
- var peg$e33 = peg$literalExpectation(".", false);
302
- var peg$e34 = peg$otherExpectation("parenthetical group");
303
- var peg$e35 = peg$otherExpectation("guillemet string");
304
- var peg$e36 = peg$literalExpectation("\xAB", false);
305
- var peg$e37 = peg$literalExpectation("\xBB", false);
306
- var peg$e38 = peg$literalExpectation("~", false);
307
- var peg$e39 = peg$otherExpectation("HTTP/HTTPS host");
308
- var peg$e40 = peg$otherExpectation("identifier");
309
- var peg$e41 = peg$classExpectation(["(", ")", "{", "}", "[", "]", "<", ">", "?", "!", "&", "|", "-", "=", ",", "/", ":", "`", "\"", "'", "\xAB", "\xBB", "\\", " ", "\u2192", "\u21D2", "\t", "\n", "\r"], true, false);
310
- var peg$e42 = peg$literalExpectation("-", false);
311
- var peg$e43 = peg$literalExpectation(">", false);
312
- var peg$e44 = peg$otherExpectation("function call with implicit parentheses");
313
- var peg$e45 = peg$classExpectation([" ", "\t"], false, false);
314
- var peg$e46 = peg$otherExpectation("integer");
315
- var peg$e47 = peg$otherExpectation("list");
316
- var peg$e48 = peg$literalExpectation("&&", false);
317
- var peg$e49 = peg$literalExpectation("||", false);
318
- var peg$e50 = peg$literalExpectation("/*", false);
319
- var peg$e51 = peg$literalExpectation("*/", false);
320
- var peg$e52 = peg$literalExpectation("@", false);
321
- var peg$e53 = peg$classExpectation([["A", "Z"], ["a", "z"]], false, false);
322
- var peg$e54 = peg$literalExpectation("\n", false);
323
- var peg$e55 = peg$literalExpectation("\r\n", false);
324
- var peg$e56 = peg$literalExpectation("\r", false);
325
- var peg$e57 = peg$otherExpectation("number");
326
- var peg$e58 = peg$literalExpectation("??", false);
327
- var peg$e59 = peg$otherExpectation("object literal");
328
- var peg$e60 = peg$literalExpectation("{", false);
329
- var peg$e61 = peg$otherExpectation("object getter");
330
- var peg$e62 = peg$literalExpectation("=", false);
331
- var peg$e63 = peg$otherExpectation("object key");
332
- var peg$e64 = peg$otherExpectation("object property");
333
- var peg$e65 = peg$otherExpectation("object identifier");
334
- var peg$e66 = peg$literalExpectation("/", false);
335
- var peg$e67 = peg$otherExpectation("function arguments in parentheses");
336
- var peg$e68 = peg$otherExpectation("slash-separated path");
337
- var peg$e69 = peg$classExpectation(["(", ")", "{", "}", "[", "]", ",", ":", "/", "\\", " ", "\t", "\n", "\r"], true, false);
338
- var peg$e70 = peg$otherExpectation("Origami program");
339
- var peg$e71 = peg$literalExpectation("//", false);
340
- var peg$e72 = peg$otherExpectation("scope reference");
341
- var peg$e73 = peg$literalExpectation(",", false);
342
- var peg$e74 = peg$literalExpectation("#!", false);
343
- var peg$e75 = peg$classExpectation(["\n", "\r"], true, false);
344
- var peg$e76 = peg$otherExpectation("lambda function");
345
- var peg$e77 = peg$classExpectation(["+", "-"], false, false);
346
- var peg$e78 = peg$literalExpectation("\u2192", false);
347
- var peg$e79 = peg$literalExpectation("->", false);
348
- var peg$e80 = peg$otherExpectation("single quote string");
349
- var peg$e81 = peg$literalExpectation("'", false);
350
- var peg$e82 = peg$otherExpectation("string");
351
- var peg$e83 = peg$otherExpectation("template");
352
- var peg$e84 = peg$literalExpectation("${", false);
353
- var peg$e85 = peg$otherExpectation("template text");
354
- var peg$e86 = peg$otherExpectation("template literal");
355
- var peg$e87 = peg$literalExpectation("`", false);
356
- var peg$e88 = peg$otherExpectation("template substitution");
357
- var peg$e89 = peg$literalExpectation("!", false);
209
+ var peg$c1 = "]";
210
+ var peg$c2 = "(";
211
+ var peg$c3 = ")";
212
+ var peg$c4 = "&";
213
+ var peg$c5 = "|";
214
+ var peg$c6 = "^";
215
+ var peg$c7 = "}";
216
+ var peg$c8 = ",";
217
+ var peg$c9 = "?";
218
+ var peg$c10 = ":";
219
+ var peg$c11 = "\u21D2";
220
+ var peg$c12 = "=>";
221
+ var peg$c13 = "\"";
222
+ var peg$c14 = "...";
223
+ var peg$c15 = "\u2026";
224
+ var peg$c16 = "===";
225
+ var peg$c17 = "!==";
226
+ var peg$c18 = "==";
227
+ var peg$c19 = "!=";
228
+ var peg$c20 = "\\0";
229
+ var peg$c21 = "\\b";
230
+ var peg$c22 = "\\f";
231
+ var peg$c23 = "\\n";
232
+ var peg$c24 = "\\r";
233
+ var peg$c25 = "\\t";
234
+ var peg$c26 = "\\v";
235
+ var peg$c27 = "\\";
236
+ var peg$c28 = "**";
237
+ var peg$c29 = ".";
238
+ var peg$c30 = "\xAB";
239
+ var peg$c31 = "\xBB";
240
+ var peg$c32 = "~";
241
+ var peg$c33 = "-";
242
+ var peg$c34 = ">";
243
+ var peg$c35 = "&&";
244
+ var peg$c36 = "||";
245
+ var peg$c37 = "/*";
246
+ var peg$c38 = "*/";
247
+ var peg$c39 = "@";
248
+ var peg$c40 = "\n";
249
+ var peg$c41 = "\r\n";
250
+ var peg$c42 = "\r";
251
+ var peg$c43 = "??";
252
+ var peg$c44 = "{";
253
+ var peg$c45 = "=";
254
+ var peg$c46 = "/";
255
+ var peg$c47 = "//";
256
+ var peg$c48 = "<=";
257
+ var peg$c49 = "<";
258
+ var peg$c50 = ">=";
259
+ var peg$c51 = "#!";
260
+ var peg$c52 = "<<";
261
+ var peg$c53 = ">>>";
262
+ var peg$c54 = ">>";
263
+ var peg$c55 = "\u2192";
264
+ var peg$c56 = "->";
265
+ var peg$c57 = "'";
266
+ var peg$c58 = "${";
267
+ var peg$c59 = "`";
268
+
269
+ var peg$r0 = /^[+\-]/;
270
+ var peg$r1 = /^[0-9]/;
271
+ var peg$r2 = /^[^(){}[\]<>?!|\-=,\/:`"'\xAB\xBB\\\u2192\u21D2\u2026 \t\n\r]/;
272
+ var peg$r3 = /^[ \t]/;
273
+ var peg$r4 = /^[%*\/]/;
274
+ var peg$r5 = /^[A-Za-z]/;
275
+ var peg$r6 = /^[^(){}[\],:\/\\ \t\n\r]/;
276
+ var peg$r7 = /^[^\n\r]/;
277
+ var peg$r8 = /^[!+\-~]/;
278
+
279
+ var peg$e0 = peg$classExpectation(["+", "-"], false, false);
280
+ var peg$e1 = peg$otherExpectation("function arguments");
281
+ var peg$e2 = peg$otherExpectation("array");
282
+ var peg$e3 = peg$literalExpectation("[", false);
283
+ var peg$e4 = peg$literalExpectation("]", false);
284
+ var peg$e5 = peg$literalExpectation("(", false);
285
+ var peg$e6 = peg$literalExpectation(")", false);
286
+ var peg$e7 = peg$literalExpectation("&", false);
287
+ var peg$e8 = peg$literalExpectation("|", false);
288
+ var peg$e9 = peg$literalExpectation("^", false);
289
+ var peg$e10 = peg$otherExpectation("function call");
290
+ var peg$e11 = peg$literalExpectation("}", false);
291
+ var peg$e12 = peg$anyExpectation();
292
+ var peg$e13 = peg$literalExpectation(",", false);
293
+ var peg$e14 = peg$otherExpectation("comment");
294
+ var peg$e15 = peg$literalExpectation("?", false);
295
+ var peg$e16 = peg$literalExpectation(":", false);
296
+ var peg$e17 = peg$classExpectation([["0", "9"]], false, false);
297
+ var peg$e18 = peg$literalExpectation("\u21D2", false);
298
+ var peg$e19 = peg$literalExpectation("=>", false);
299
+ var peg$e20 = peg$otherExpectation("double quote string");
300
+ var peg$e21 = peg$literalExpectation("\"", false);
301
+ var peg$e22 = peg$literalExpectation("...", false);
302
+ var peg$e23 = peg$literalExpectation("\u2026", false);
303
+ var peg$e24 = peg$literalExpectation("===", false);
304
+ var peg$e25 = peg$literalExpectation("!==", false);
305
+ var peg$e26 = peg$literalExpectation("==", false);
306
+ var peg$e27 = peg$literalExpectation("!=", false);
307
+ var peg$e28 = peg$otherExpectation("backslash-escaped character");
308
+ var peg$e29 = peg$literalExpectation("\\0", false);
309
+ var peg$e30 = peg$literalExpectation("\\b", false);
310
+ var peg$e31 = peg$literalExpectation("\\f", false);
311
+ var peg$e32 = peg$literalExpectation("\\n", false);
312
+ var peg$e33 = peg$literalExpectation("\\r", false);
313
+ var peg$e34 = peg$literalExpectation("\\t", false);
314
+ var peg$e35 = peg$literalExpectation("\\v", false);
315
+ var peg$e36 = peg$literalExpectation("\\", false);
316
+ var peg$e37 = peg$literalExpectation("**", false);
317
+ var peg$e38 = peg$otherExpectation("floating-point number");
318
+ var peg$e39 = peg$literalExpectation(".", false);
319
+ var peg$e40 = peg$otherExpectation("parenthetical group");
320
+ var peg$e41 = peg$otherExpectation("guillemet string");
321
+ var peg$e42 = peg$literalExpectation("\xAB", false);
322
+ var peg$e43 = peg$literalExpectation("\xBB", false);
323
+ var peg$e44 = peg$literalExpectation("~", false);
324
+ var peg$e45 = peg$otherExpectation("HTTP/HTTPS host");
325
+ var peg$e46 = peg$otherExpectation("identifier");
326
+ var peg$e47 = peg$classExpectation(["(", ")", "{", "}", "[", "]", "<", ">", "?", "!", "|", "-", "=", ",", "/", ":", "`", "\"", "'", "\xAB", "\xBB", "\\", "\u2192", "\u21D2", "\u2026", " ", "\t", "\n", "\r"], true, false);
327
+ var peg$e48 = peg$literalExpectation("-", false);
328
+ var peg$e49 = peg$literalExpectation(">", false);
329
+ var peg$e50 = peg$otherExpectation("function call with implicit parentheses");
330
+ var peg$e51 = peg$classExpectation([" ", "\t"], false, false);
331
+ var peg$e52 = peg$otherExpectation("integer");
332
+ var peg$e53 = peg$otherExpectation("list");
333
+ var peg$e54 = peg$literalExpectation("&&", false);
334
+ var peg$e55 = peg$literalExpectation("||", false);
335
+ var peg$e56 = peg$literalExpectation("/*", false);
336
+ var peg$e57 = peg$literalExpectation("*/", false);
337
+ var peg$e58 = peg$classExpectation(["%", "*", "/"], false, false);
338
+ var peg$e59 = peg$literalExpectation("@", false);
339
+ var peg$e60 = peg$classExpectation([["A", "Z"], ["a", "z"]], false, false);
340
+ var peg$e61 = peg$literalExpectation("\n", false);
341
+ var peg$e62 = peg$literalExpectation("\r\n", false);
342
+ var peg$e63 = peg$literalExpectation("\r", false);
343
+ var peg$e64 = peg$otherExpectation("number");
344
+ var peg$e65 = peg$literalExpectation("??", false);
345
+ var peg$e66 = peg$otherExpectation("object literal");
346
+ var peg$e67 = peg$literalExpectation("{", false);
347
+ var peg$e68 = peg$otherExpectation("object getter");
348
+ var peg$e69 = peg$literalExpectation("=", false);
349
+ var peg$e70 = peg$otherExpectation("object key");
350
+ var peg$e71 = peg$otherExpectation("object property");
351
+ var peg$e72 = peg$otherExpectation("object identifier");
352
+ var peg$e73 = peg$literalExpectation("/", false);
353
+ var peg$e74 = peg$otherExpectation("function arguments in parentheses");
354
+ var peg$e75 = peg$otherExpectation("slash-separated path");
355
+ var peg$e76 = peg$classExpectation(["(", ")", "{", "}", "[", "]", ",", ":", "/", "\\", " ", "\t", "\n", "\r"], true, false);
356
+ var peg$e77 = peg$otherExpectation("Origami program");
357
+ var peg$e78 = peg$literalExpectation("//", false);
358
+ var peg$e79 = peg$literalExpectation("<=", false);
359
+ var peg$e80 = peg$literalExpectation("<", false);
360
+ var peg$e81 = peg$literalExpectation(">=", false);
361
+ var peg$e82 = peg$otherExpectation("scope reference");
362
+ var peg$e83 = peg$literalExpectation("#!", false);
363
+ var peg$e84 = peg$classExpectation(["\n", "\r"], true, false);
364
+ var peg$e85 = peg$literalExpectation("<<", false);
365
+ var peg$e86 = peg$literalExpectation(">>>", false);
366
+ var peg$e87 = peg$literalExpectation(">>", false);
367
+ var peg$e88 = peg$otherExpectation("lambda function");
368
+ var peg$e89 = peg$literalExpectation("\u2192", false);
369
+ var peg$e90 = peg$literalExpectation("->", false);
370
+ var peg$e91 = peg$otherExpectation("single quote string");
371
+ var peg$e92 = peg$literalExpectation("'", false);
372
+ var peg$e93 = peg$otherExpectation("string");
373
+ var peg$e94 = peg$otherExpectation("template");
374
+ var peg$e95 = peg$literalExpectation("${", false);
375
+ var peg$e96 = peg$otherExpectation("template text");
376
+ var peg$e97 = peg$otherExpectation("template literal");
377
+ var peg$e98 = peg$literalExpectation("`", false);
378
+ var peg$e99 = peg$otherExpectation("template substitution");
379
+ var peg$e100 = peg$classExpectation(["!", "+", "-", "~"], false, false);
358
380
 
359
381
  var peg$f0 = function() {
360
382
  return null;
361
383
  };
362
- var peg$f1 = function(entries) {
363
- return annotate(makeArray(entries ?? []), location());
384
+ var peg$f1 = function(head, tail) {
385
+ return annotate(tail.reduce(makeBinaryOperation, head), location());
364
386
  };
365
387
  var peg$f2 = function(entries) {
388
+ return annotate(makeArray(entries ?? []), location());
389
+ };
390
+ var peg$f3 = function(entries) {
366
391
  return annotate(entries, location());
367
392
  };
368
- var peg$f3 = function(parameters, pipeline) {
393
+ var peg$f4 = function() {
394
+ return annotate([ops.literal, undefined], location());
395
+ };
396
+ var peg$f5 = function(parameters, pipeline) {
369
397
  return annotate([ops.lambda, parameters ?? [], pipeline], location());
370
398
  };
371
- var peg$f4 = function(head, tail) {
372
- return tail.length === 0
373
- ? head
374
- : annotate(tail.reduce(makeCall, head), location());
399
+ var peg$f6 = function(identifier, pipeline) {
400
+ return annotate([ops.lambda, [identifier], pipeline], location());
401
+ };
402
+ var peg$f7 = function(head, tail) {
403
+ return annotate(tail.reduce(makeBinaryOperation, head), location());
404
+ };
405
+ var peg$f8 = function(head, tail) {
406
+ return annotate(tail.reduce(makeBinaryOperation, head), location());
407
+ };
408
+ var peg$f9 = function(head, tail) {
409
+ return annotate(tail.reduce(makeBinaryOperation, head), location());
410
+ };
411
+ var peg$f10 = function(head, tail) {
412
+ return annotate(tail.reduce(makeCall, head), location());
375
413
  };
376
- var peg$f5 = function() {
414
+ var peg$f11 = function() {
377
415
  error("Expected right curly brace");
378
416
  };
379
- var peg$f6 = function() {
417
+ var peg$f12 = function() {
380
418
  error("Expected right bracket");
381
419
  };
382
- var peg$f7 = function() {
420
+ var peg$f13 = function() {
383
421
  error("Expected right parenthesis");
384
422
  };
385
- var peg$f8 = function(condition, truthy, falsy) {
423
+ var peg$f14 = function(list) {
424
+ return list.length === 1
425
+ ? list[0]
426
+ : annotate([ops.comma, ...list], location());
427
+ };
428
+ var peg$f15 = function(condition, truthy, falsy) {
386
429
  return annotate([
387
430
  ops.conditional,
388
431
  downgradeReference(condition),
@@ -390,56 +433,57 @@ function peg$parse(input, options) {
390
433
  [ops.lambda, [], downgradeReference(falsy)]
391
434
  ], location());
392
435
  };
393
- var peg$f9 = function(chars) {
436
+ var peg$f16 = function(chars) {
394
437
  return annotate([ops.literal, chars.join("")], location());
395
438
  };
396
- var peg$f10 = function(head, tail) {
397
- return tail.length === 0
398
- ? head
399
- : annotate(makeBinaryOperatorChain(head, tail), location());
439
+ var peg$f17 = function(head, tail) {
440
+ return annotate(tail.reduce(makeBinaryOperation, head), location());
441
+ };
442
+ var peg$f18 = function() { return "\0"; };
443
+ var peg$f19 = function() { return "\b"; };
444
+ var peg$f20 = function() { return "\f"; };
445
+ var peg$f21 = function() { return "\n"; };
446
+ var peg$f22 = function() { return "\r"; };
447
+ var peg$f23 = function() { return "\t"; };
448
+ var peg$f24 = function() { return "\v"; };
449
+ var peg$f25 = function(left, right) {
450
+ return annotate([ops.exponentiation, left, right], location());
400
451
  };
401
- var peg$f11 = function() { return "\0"; };
402
- var peg$f12 = function() { return "\b"; };
403
- var peg$f13 = function() { return "\f"; };
404
- var peg$f14 = function() { return "\n"; };
405
- var peg$f15 = function() { return "\r"; };
406
- var peg$f16 = function() { return "\t"; };
407
- var peg$f17 = function() { return "\v"; };
408
- var peg$f18 = function() {
452
+ var peg$f26 = function() {
409
453
  return annotate([ops.literal, parseFloat(text())], location());
410
454
  };
411
- var peg$f19 = function(expression) {
455
+ var peg$f27 = function(expression) {
412
456
  return annotate(downgradeReference(expression), location());
413
457
  };
414
- var peg$f20 = function(chars) {
458
+ var peg$f28 = function(chars) {
415
459
  return annotate([ops.literal, chars.join("")], location());
416
460
  };
417
- var peg$f21 = function() {
461
+ var peg$f29 = function() {
418
462
  return annotate([ops.homeDirectory], location());
419
463
  };
420
- var peg$f22 = function(identifier, port, slashFollows) {
464
+ var peg$f30 = function(identifier, port, slashFollows) {
421
465
  const portText = port ? `:${port[1]}` : "";
422
466
  const slashText = slashFollows ? "/" : "";
423
467
  const hostText = identifier + portText + slashText;
424
468
  return annotate([ops.literal, hostText], location());
425
469
  };
426
- var peg$f23 = function(chars) { return chars.join(""); };
427
- var peg$f24 = function(list) {
470
+ var peg$f31 = function(chars) { return chars.join(""); };
471
+ var peg$f32 = function(list) {
428
472
  return annotate(list, location());
429
473
  };
430
- var peg$f25 = function(head, args) {
474
+ var peg$f33 = function(head, args) {
431
475
  return args ? makeCall(head, args) : head;
432
476
  };
433
- var peg$f26 = function(values) {
477
+ var peg$f34 = function(values) {
434
478
  return annotate(values, location());
435
479
  };
436
- var peg$f27 = function() {
480
+ var peg$f35 = function() {
437
481
  return annotate([ops.literal, parseInt(text())], location());
438
482
  };
439
- var peg$f28 = function(values) {
483
+ var peg$f36 = function(values) {
440
484
  return annotate(values, location());
441
485
  };
442
- var peg$f29 = function(head, tail) {
486
+ var peg$f37 = function(head, tail) {
443
487
  return tail.length === 0
444
488
  ? head
445
489
  : annotate(
@@ -447,7 +491,7 @@ function peg$parse(input, options) {
447
491
  location()
448
492
  );
449
493
  };
450
- var peg$f30 = function(head, tail) {
494
+ var peg$f38 = function(head, tail) {
451
495
  return tail.length === 0
452
496
  ? head
453
497
  : annotate(
@@ -455,11 +499,14 @@ function peg$parse(input, options) {
455
499
  location()
456
500
  );
457
501
  };
458
- var peg$f31 = function() { return null; };
459
- var peg$f32 = function(at, chars) {
502
+ var peg$f39 = function() { return null; };
503
+ var peg$f40 = function(head, tail) {
504
+ return annotate(tail.reduce(makeBinaryOperation, head), location());
505
+ };
506
+ var peg$f41 = function(at, chars) {
460
507
  return annotate([ops.builtin, (at ?? "") + chars.join("") + ":"], location());
461
508
  };
462
- var peg$f33 = function(head, tail) {
509
+ var peg$f42 = function(head, tail) {
463
510
  return tail.length === 0
464
511
  ? head
465
512
  : annotate(
@@ -467,103 +514,112 @@ function peg$parse(input, options) {
467
514
  location()
468
515
  );
469
516
  };
470
- var peg$f34 = function(entries) {
517
+ var peg$f43 = function(entries) {
471
518
  return annotate(makeObject(entries ?? [], ops.object), location());
472
519
  };
473
- var peg$f35 = function(entries) {
520
+ var peg$f44 = function(entries) {
474
521
  return annotate(entries, location());
475
522
  };
476
- var peg$f36 = function(key, pipeline) {
523
+ var peg$f45 = function(key, pipeline) {
477
524
  return annotate(
478
525
  makeProperty(key, annotate([ops.getter, pipeline], location())),
479
526
  location()
480
527
  );
481
528
  };
482
- var peg$f37 = function(hiddenKey) { return hiddenKey.join(""); };
483
- var peg$f38 = function(key, pipeline) {
529
+ var peg$f46 = function(hiddenKey) { return hiddenKey.join(""); };
530
+ var peg$f47 = function(key, pipeline) {
484
531
  return annotate(makeProperty(key, pipeline), location());
485
532
  };
486
- var peg$f39 = function(key) {
533
+ var peg$f48 = function(key) {
487
534
  return annotate([key, [ops.inherited, key]], location());
488
535
  };
489
- var peg$f40 = function(identifier, slash) {
536
+ var peg$f49 = function(identifier, slash) {
490
537
  return identifier + (slash ?? "");
491
538
  };
492
- var peg$f41 = function(string) {
539
+ var peg$f50 = function(string) {
493
540
  // Remove `ops.literal` from the string code
494
541
  return string[1];
495
542
  };
496
- var peg$f42 = function(list) {
543
+ var peg$f51 = function(list) {
497
544
  return annotate(list ?? [undefined], location());
498
545
  };
499
- var peg$f43 = function(segments) {
546
+ var peg$f52 = function(segments) {
500
547
  // Drop empty segments that represent consecutive or final slashes
501
548
  segments = segments.filter(segment => segment);
502
549
  return annotate(segments, location());
503
550
  };
504
- var peg$f44 = function(path) {
551
+ var peg$f53 = function(path) {
505
552
  return annotate([ops.traverse, ...path], location());
506
553
  };
507
- var peg$f45 = function(chars, slashFollows) {
554
+ var peg$f54 = function(chars, slashFollows) {
508
555
  // Append a trailing slash if one follows (but don't consume it)
509
556
  const key = chars.join("") + (slashFollows ? "/" : "");
510
557
  return annotate([ops.literal, key], location());
511
558
  };
512
- var peg$f46 = function(head, tail) {
513
- return tail.reduce(makePipeline, downgradeReference(head));
559
+ var peg$f55 = function(head, tail) {
560
+ return annotate(
561
+ tail.reduce(makePipeline, downgradeReference(head)),
562
+ location()
563
+ );
514
564
  };
515
- var peg$f47 = function(fn, host, path) {
565
+ var peg$f56 = function(fn, host, path) {
516
566
  const keys = annotate([host, ...(path ?? [])], location());
517
567
  return annotate(makeCall(fn, keys), location());
518
568
  };
519
- var peg$f48 = function(fn, reference) {
569
+ var peg$f57 = function(fn, reference) {
520
570
  const literal = annotate([ops.literal, reference[1]], reference.location);
521
571
  return annotate(makeCall(fn, [literal]), location());
522
572
  };
523
- var peg$f49 = function(key) {
573
+ var peg$f58 = function(head, tail) {
574
+ return annotate(tail.reduce(makeBinaryOperation, head), location());
575
+ };
576
+ var peg$f59 = function(key) {
524
577
  return annotate([ops.rootDirectory, key], location());
525
578
  };
526
- var peg$f50 = function() {
579
+ var peg$f60 = function() {
527
580
  return annotate([ops.rootDirectory], location());
528
581
  };
529
- var peg$f51 = function(identifier, slashFollows) {
582
+ var peg$f61 = function(identifier, slashFollows) {
530
583
  const id = identifier + (slashFollows ? "/" : "");
531
584
  return annotate(makeReference(id), location());
532
585
  };
533
- var peg$f52 = function() {
586
+ var peg$f62 = function() {
534
587
  return true;
535
588
  };
536
- var peg$f53 = function() { return null; };
537
- var peg$f54 = function(definition) {
589
+ var peg$f63 = function() { return null; };
590
+ var peg$f64 = function(head, tail) {
591
+ return annotate(tail.reduce(makeBinaryOperation, head), location());
592
+ };
593
+ var peg$f65 = function(definition) {
538
594
  return annotate([ops.lambda, ["_"], definition], location());
539
595
  };
540
- var peg$f55 = function() { return null; };
541
- var peg$f56 = function(chars) {
596
+ var peg$f66 = function() { return null; };
597
+ var peg$f67 = function(chars) {
542
598
  return annotate([ops.literal, chars.join("")], location());
543
599
  };
544
- var peg$f57 = function(value) {
600
+ var peg$f68 = function(value) {
545
601
  return annotate([ops.spread, value], location());
546
602
  };
547
- var peg$f58 = function(contents) {
603
+ var peg$f69 = function(contents) {
548
604
  return annotate([ops.lambda, ["_"], contents], location());
549
605
  };
550
- var peg$f59 = function(head, tail) {
606
+ var peg$f70 = function(head, tail) {
551
607
  return annotate(makeTemplate(ops.template, head, tail), location());
552
608
  };
553
- var peg$f60 = function(chars) {
609
+ var peg$f71 = function(chars) {
554
610
  return chars.join("");
555
611
  };
556
- var peg$f61 = function(contents) {
612
+ var peg$f72 = function(contents) {
557
613
  return annotate(makeTemplate(ops.template, contents[0], contents[1]), location());
558
614
  };
559
- var peg$f62 = function(chars) {
615
+ var peg$f73 = function(chars) {
560
616
  return chars.join("");
561
617
  };
562
- var peg$f63 = function(expression) {
618
+ var peg$f74 = function(expression) {
563
619
  return annotate(expression, location());
564
620
  };
565
- var peg$f64 = function(operator, expression) {
566
- return annotate(makeUnaryOperatorCall(operator, expression), location());
621
+ var peg$f75 = function(operator, expression) {
622
+ return annotate(makeUnaryOperation(operator, expression), location());
567
623
  };
568
624
  var peg$currPos = options.peg$currPos | 0;
569
625
  var peg$savedPos = peg$currPos;
@@ -756,6 +812,72 @@ function peg$parse(input, options) {
756
812
  return s0;
757
813
  }
758
814
 
815
+ function peg$parseadditiveExpression() {
816
+ var s0, s1, s2, s3, s4, s5, s6, s7;
817
+
818
+ s0 = peg$currPos;
819
+ s1 = peg$parsemultiplicativeExpression();
820
+ if (s1 !== peg$FAILED) {
821
+ s2 = [];
822
+ s3 = peg$currPos;
823
+ s4 = peg$parse__();
824
+ s5 = peg$parseadditiveOperator();
825
+ if (s5 !== peg$FAILED) {
826
+ s6 = peg$parse__();
827
+ s7 = peg$parsemultiplicativeExpression();
828
+ if (s7 !== peg$FAILED) {
829
+ s3 = [ s5, s7 ];
830
+ } else {
831
+ peg$currPos = s3;
832
+ s3 = peg$FAILED;
833
+ }
834
+ } else {
835
+ peg$currPos = s3;
836
+ s3 = peg$FAILED;
837
+ }
838
+ while (s3 !== peg$FAILED) {
839
+ s2.push(s3);
840
+ s3 = peg$currPos;
841
+ s4 = peg$parse__();
842
+ s5 = peg$parseadditiveOperator();
843
+ if (s5 !== peg$FAILED) {
844
+ s6 = peg$parse__();
845
+ s7 = peg$parsemultiplicativeExpression();
846
+ if (s7 !== peg$FAILED) {
847
+ s3 = [ s5, s7 ];
848
+ } else {
849
+ peg$currPos = s3;
850
+ s3 = peg$FAILED;
851
+ }
852
+ } else {
853
+ peg$currPos = s3;
854
+ s3 = peg$FAILED;
855
+ }
856
+ }
857
+ peg$savedPos = s0;
858
+ s0 = peg$f1(s1, s2);
859
+ } else {
860
+ peg$currPos = s0;
861
+ s0 = peg$FAILED;
862
+ }
863
+
864
+ return s0;
865
+ }
866
+
867
+ function peg$parseadditiveOperator() {
868
+ var s0;
869
+
870
+ s0 = input.charAt(peg$currPos);
871
+ if (peg$r0.test(s0)) {
872
+ peg$currPos++;
873
+ } else {
874
+ s0 = peg$FAILED;
875
+ if (peg$silentFails === 0) { peg$fail(peg$e0); }
876
+ }
877
+
878
+ return s0;
879
+ }
880
+
759
881
  function peg$parsearguments() {
760
882
  var s0, s1;
761
883
 
@@ -770,7 +892,7 @@ function peg$parse(input, options) {
770
892
  peg$silentFails--;
771
893
  if (s0 === peg$FAILED) {
772
894
  s1 = peg$FAILED;
773
- if (peg$silentFails === 0) { peg$fail(peg$e0); }
895
+ if (peg$silentFails === 0) { peg$fail(peg$e1); }
774
896
  }
775
897
 
776
898
  return s0;
@@ -786,7 +908,7 @@ function peg$parse(input, options) {
786
908
  peg$currPos++;
787
909
  } else {
788
910
  s1 = peg$FAILED;
789
- if (peg$silentFails === 0) { peg$fail(peg$e2); }
911
+ if (peg$silentFails === 0) { peg$fail(peg$e3); }
790
912
  }
791
913
  if (s1 !== peg$FAILED) {
792
914
  s2 = peg$parse__();
@@ -798,7 +920,7 @@ function peg$parse(input, options) {
798
920
  s5 = peg$parseclosingBracket();
799
921
  if (s5 !== peg$FAILED) {
800
922
  peg$savedPos = s0;
801
- s0 = peg$f1(s3);
923
+ s0 = peg$f2(s3);
802
924
  } else {
803
925
  peg$currPos = s0;
804
926
  s0 = peg$FAILED;
@@ -810,7 +932,7 @@ function peg$parse(input, options) {
810
932
  peg$silentFails--;
811
933
  if (s0 === peg$FAILED) {
812
934
  s1 = peg$FAILED;
813
- if (peg$silentFails === 0) { peg$fail(peg$e1); }
935
+ if (peg$silentFails === 0) { peg$fail(peg$e2); }
814
936
  }
815
937
 
816
938
  return s0;
@@ -851,7 +973,7 @@ function peg$parse(input, options) {
851
973
  s2 = null;
852
974
  }
853
975
  peg$savedPos = s0;
854
- s0 = peg$f2(s1);
976
+ s0 = peg$f3(s1);
855
977
  } else {
856
978
  peg$currPos = s0;
857
979
  s0 = peg$FAILED;
@@ -861,11 +983,38 @@ function peg$parse(input, options) {
861
983
  }
862
984
 
863
985
  function peg$parsearrayEntry() {
864
- var s0;
986
+ var s0, s1, s2, s3;
865
987
 
866
988
  s0 = peg$parsespread();
867
989
  if (s0 === peg$FAILED) {
868
990
  s0 = peg$parsepipelineExpression();
991
+ if (s0 === peg$FAILED) {
992
+ s0 = peg$currPos;
993
+ s1 = peg$parse__();
994
+ s2 = peg$currPos;
995
+ peg$silentFails++;
996
+ if (input.charCodeAt(peg$currPos) === 93) {
997
+ s3 = peg$c1;
998
+ peg$currPos++;
999
+ } else {
1000
+ s3 = peg$FAILED;
1001
+ if (peg$silentFails === 0) { peg$fail(peg$e4); }
1002
+ }
1003
+ peg$silentFails--;
1004
+ if (s3 === peg$FAILED) {
1005
+ s2 = undefined;
1006
+ } else {
1007
+ peg$currPos = s2;
1008
+ s2 = peg$FAILED;
1009
+ }
1010
+ if (s2 !== peg$FAILED) {
1011
+ peg$savedPos = s0;
1012
+ s0 = peg$f4();
1013
+ } else {
1014
+ peg$currPos = s0;
1015
+ s0 = peg$FAILED;
1016
+ }
1017
+ }
869
1018
  }
870
1019
 
871
1020
  return s0;
@@ -876,11 +1025,11 @@ function peg$parse(input, options) {
876
1025
 
877
1026
  s0 = peg$currPos;
878
1027
  if (input.charCodeAt(peg$currPos) === 40) {
879
- s1 = peg$c1;
1028
+ s1 = peg$c2;
880
1029
  peg$currPos++;
881
1030
  } else {
882
1031
  s1 = peg$FAILED;
883
- if (peg$silentFails === 0) { peg$fail(peg$e3); }
1032
+ if (peg$silentFails === 0) { peg$fail(peg$e5); }
884
1033
  }
885
1034
  if (s1 !== peg$FAILED) {
886
1035
  s2 = peg$parse__();
@@ -890,11 +1039,11 @@ function peg$parse(input, options) {
890
1039
  }
891
1040
  s4 = peg$parse__();
892
1041
  if (input.charCodeAt(peg$currPos) === 41) {
893
- s5 = peg$c2;
1042
+ s5 = peg$c3;
894
1043
  peg$currPos++;
895
1044
  } else {
896
1045
  s5 = peg$FAILED;
897
- if (peg$silentFails === 0) { peg$fail(peg$e4); }
1046
+ if (peg$silentFails === 0) { peg$fail(peg$e6); }
898
1047
  }
899
1048
  if (s5 !== peg$FAILED) {
900
1049
  s6 = peg$parse__();
@@ -904,25 +1053,304 @@ function peg$parse(input, options) {
904
1053
  s9 = peg$parsepipelineExpression();
905
1054
  if (s9 !== peg$FAILED) {
906
1055
  peg$savedPos = s0;
907
- s0 = peg$f3(s3, s9);
1056
+ s0 = peg$f5(s3, s9);
1057
+ } else {
1058
+ peg$currPos = s0;
1059
+ s0 = peg$FAILED;
1060
+ }
1061
+ } else {
1062
+ peg$currPos = s0;
1063
+ s0 = peg$FAILED;
1064
+ }
1065
+ } else {
1066
+ peg$currPos = s0;
1067
+ s0 = peg$FAILED;
1068
+ }
1069
+ } else {
1070
+ peg$currPos = s0;
1071
+ s0 = peg$FAILED;
1072
+ }
1073
+ if (s0 === peg$FAILED) {
1074
+ s0 = peg$currPos;
1075
+ s1 = peg$parseidentifier();
1076
+ if (s1 !== peg$FAILED) {
1077
+ s2 = peg$parse__();
1078
+ s3 = peg$parsedoubleArrow();
1079
+ if (s3 !== peg$FAILED) {
1080
+ s4 = peg$parse__();
1081
+ s5 = peg$parsepipelineExpression();
1082
+ if (s5 !== peg$FAILED) {
1083
+ peg$savedPos = s0;
1084
+ s0 = peg$f6(s1, s5);
1085
+ } else {
1086
+ peg$currPos = s0;
1087
+ s0 = peg$FAILED;
1088
+ }
1089
+ } else {
1090
+ peg$currPos = s0;
1091
+ s0 = peg$FAILED;
1092
+ }
1093
+ } else {
1094
+ peg$currPos = s0;
1095
+ s0 = peg$FAILED;
1096
+ }
1097
+ if (s0 === peg$FAILED) {
1098
+ s0 = peg$parseconditionalExpression();
1099
+ }
1100
+ }
1101
+
1102
+ return s0;
1103
+ }
1104
+
1105
+ function peg$parsebitwiseAndExpression() {
1106
+ var s0, s1, s2, s3, s4, s5, s6, s7;
1107
+
1108
+ s0 = peg$currPos;
1109
+ s1 = peg$parseequalityExpression();
1110
+ if (s1 !== peg$FAILED) {
1111
+ s2 = [];
1112
+ s3 = peg$currPos;
1113
+ s4 = peg$parse__();
1114
+ s5 = peg$parsebitwiseAndOperator();
1115
+ if (s5 !== peg$FAILED) {
1116
+ s6 = peg$parse__();
1117
+ s7 = peg$parseequalityExpression();
1118
+ if (s7 !== peg$FAILED) {
1119
+ s3 = [ s5, s7 ];
1120
+ } else {
1121
+ peg$currPos = s3;
1122
+ s3 = peg$FAILED;
1123
+ }
1124
+ } else {
1125
+ peg$currPos = s3;
1126
+ s3 = peg$FAILED;
1127
+ }
1128
+ while (s3 !== peg$FAILED) {
1129
+ s2.push(s3);
1130
+ s3 = peg$currPos;
1131
+ s4 = peg$parse__();
1132
+ s5 = peg$parsebitwiseAndOperator();
1133
+ if (s5 !== peg$FAILED) {
1134
+ s6 = peg$parse__();
1135
+ s7 = peg$parseequalityExpression();
1136
+ if (s7 !== peg$FAILED) {
1137
+ s3 = [ s5, s7 ];
1138
+ } else {
1139
+ peg$currPos = s3;
1140
+ s3 = peg$FAILED;
1141
+ }
1142
+ } else {
1143
+ peg$currPos = s3;
1144
+ s3 = peg$FAILED;
1145
+ }
1146
+ }
1147
+ peg$savedPos = s0;
1148
+ s0 = peg$f7(s1, s2);
1149
+ } else {
1150
+ peg$currPos = s0;
1151
+ s0 = peg$FAILED;
1152
+ }
1153
+
1154
+ return s0;
1155
+ }
1156
+
1157
+ function peg$parsebitwiseAndOperator() {
1158
+ var s0, s1, s2, s3;
1159
+
1160
+ s0 = peg$currPos;
1161
+ if (input.charCodeAt(peg$currPos) === 38) {
1162
+ s1 = peg$c4;
1163
+ peg$currPos++;
1164
+ } else {
1165
+ s1 = peg$FAILED;
1166
+ if (peg$silentFails === 0) { peg$fail(peg$e7); }
1167
+ }
1168
+ if (s1 !== peg$FAILED) {
1169
+ s2 = peg$currPos;
1170
+ peg$silentFails++;
1171
+ if (input.charCodeAt(peg$currPos) === 38) {
1172
+ s3 = peg$c4;
1173
+ peg$currPos++;
1174
+ } else {
1175
+ s3 = peg$FAILED;
1176
+ if (peg$silentFails === 0) { peg$fail(peg$e7); }
1177
+ }
1178
+ peg$silentFails--;
1179
+ if (s3 === peg$FAILED) {
1180
+ s2 = undefined;
1181
+ } else {
1182
+ peg$currPos = s2;
1183
+ s2 = peg$FAILED;
1184
+ }
1185
+ if (s2 !== peg$FAILED) {
1186
+ s0 = s1;
1187
+ } else {
1188
+ peg$currPos = s0;
1189
+ s0 = peg$FAILED;
1190
+ }
1191
+ } else {
1192
+ peg$currPos = s0;
1193
+ s0 = peg$FAILED;
1194
+ }
1195
+
1196
+ return s0;
1197
+ }
1198
+
1199
+ function peg$parsebitwiseOrExpression() {
1200
+ var s0, s1, s2, s3, s4, s5, s6, s7;
1201
+
1202
+ s0 = peg$currPos;
1203
+ s1 = peg$parsebitwiseXorExpression();
1204
+ if (s1 !== peg$FAILED) {
1205
+ s2 = [];
1206
+ s3 = peg$currPos;
1207
+ s4 = peg$parse__();
1208
+ s5 = peg$parsebitwiseOrOperator();
1209
+ if (s5 !== peg$FAILED) {
1210
+ s6 = peg$parse__();
1211
+ s7 = peg$parsebitwiseXorExpression();
1212
+ if (s7 !== peg$FAILED) {
1213
+ s3 = [ s5, s7 ];
1214
+ } else {
1215
+ peg$currPos = s3;
1216
+ s3 = peg$FAILED;
1217
+ }
1218
+ } else {
1219
+ peg$currPos = s3;
1220
+ s3 = peg$FAILED;
1221
+ }
1222
+ while (s3 !== peg$FAILED) {
1223
+ s2.push(s3);
1224
+ s3 = peg$currPos;
1225
+ s4 = peg$parse__();
1226
+ s5 = peg$parsebitwiseOrOperator();
1227
+ if (s5 !== peg$FAILED) {
1228
+ s6 = peg$parse__();
1229
+ s7 = peg$parsebitwiseXorExpression();
1230
+ if (s7 !== peg$FAILED) {
1231
+ s3 = [ s5, s7 ];
1232
+ } else {
1233
+ peg$currPos = s3;
1234
+ s3 = peg$FAILED;
1235
+ }
1236
+ } else {
1237
+ peg$currPos = s3;
1238
+ s3 = peg$FAILED;
1239
+ }
1240
+ }
1241
+ peg$savedPos = s0;
1242
+ s0 = peg$f8(s1, s2);
1243
+ } else {
1244
+ peg$currPos = s0;
1245
+ s0 = peg$FAILED;
1246
+ }
1247
+
1248
+ return s0;
1249
+ }
1250
+
1251
+ function peg$parsebitwiseOrOperator() {
1252
+ var s0, s1, s2, s3;
1253
+
1254
+ s0 = peg$currPos;
1255
+ if (input.charCodeAt(peg$currPos) === 124) {
1256
+ s1 = peg$c5;
1257
+ peg$currPos++;
1258
+ } else {
1259
+ s1 = peg$FAILED;
1260
+ if (peg$silentFails === 0) { peg$fail(peg$e8); }
1261
+ }
1262
+ if (s1 !== peg$FAILED) {
1263
+ s2 = peg$currPos;
1264
+ peg$silentFails++;
1265
+ if (input.charCodeAt(peg$currPos) === 124) {
1266
+ s3 = peg$c5;
1267
+ peg$currPos++;
1268
+ } else {
1269
+ s3 = peg$FAILED;
1270
+ if (peg$silentFails === 0) { peg$fail(peg$e8); }
1271
+ }
1272
+ peg$silentFails--;
1273
+ if (s3 === peg$FAILED) {
1274
+ s2 = undefined;
1275
+ } else {
1276
+ peg$currPos = s2;
1277
+ s2 = peg$FAILED;
1278
+ }
1279
+ if (s2 !== peg$FAILED) {
1280
+ s0 = s1;
1281
+ } else {
1282
+ peg$currPos = s0;
1283
+ s0 = peg$FAILED;
1284
+ }
1285
+ } else {
1286
+ peg$currPos = s0;
1287
+ s0 = peg$FAILED;
1288
+ }
1289
+
1290
+ return s0;
1291
+ }
1292
+
1293
+ function peg$parsebitwiseXorExpression() {
1294
+ var s0, s1, s2, s3, s4, s5, s6, s7;
1295
+
1296
+ s0 = peg$currPos;
1297
+ s1 = peg$parsebitwiseAndExpression();
1298
+ if (s1 !== peg$FAILED) {
1299
+ s2 = [];
1300
+ s3 = peg$currPos;
1301
+ s4 = peg$parse__();
1302
+ s5 = peg$parsebitwiseXorOperator();
1303
+ if (s5 !== peg$FAILED) {
1304
+ s6 = peg$parse__();
1305
+ s7 = peg$parsebitwiseAndExpression();
1306
+ if (s7 !== peg$FAILED) {
1307
+ s3 = [ s5, s7 ];
1308
+ } else {
1309
+ peg$currPos = s3;
1310
+ s3 = peg$FAILED;
1311
+ }
1312
+ } else {
1313
+ peg$currPos = s3;
1314
+ s3 = peg$FAILED;
1315
+ }
1316
+ while (s3 !== peg$FAILED) {
1317
+ s2.push(s3);
1318
+ s3 = peg$currPos;
1319
+ s4 = peg$parse__();
1320
+ s5 = peg$parsebitwiseXorOperator();
1321
+ if (s5 !== peg$FAILED) {
1322
+ s6 = peg$parse__();
1323
+ s7 = peg$parsebitwiseAndExpression();
1324
+ if (s7 !== peg$FAILED) {
1325
+ s3 = [ s5, s7 ];
908
1326
  } else {
909
- peg$currPos = s0;
910
- s0 = peg$FAILED;
1327
+ peg$currPos = s3;
1328
+ s3 = peg$FAILED;
911
1329
  }
912
1330
  } else {
913
- peg$currPos = s0;
914
- s0 = peg$FAILED;
1331
+ peg$currPos = s3;
1332
+ s3 = peg$FAILED;
915
1333
  }
916
- } else {
917
- peg$currPos = s0;
918
- s0 = peg$FAILED;
919
1334
  }
1335
+ peg$savedPos = s0;
1336
+ s0 = peg$f9(s1, s2);
920
1337
  } else {
921
1338
  peg$currPos = s0;
922
1339
  s0 = peg$FAILED;
923
1340
  }
924
- if (s0 === peg$FAILED) {
925
- s0 = peg$parseconditionalExpression();
1341
+
1342
+ return s0;
1343
+ }
1344
+
1345
+ function peg$parsebitwiseXorOperator() {
1346
+ var s0;
1347
+
1348
+ if (input.charCodeAt(peg$currPos) === 94) {
1349
+ s0 = peg$c6;
1350
+ peg$currPos++;
1351
+ } else {
1352
+ s0 = peg$FAILED;
1353
+ if (peg$silentFails === 0) { peg$fail(peg$e9); }
926
1354
  }
927
1355
 
928
1356
  return s0;
@@ -942,7 +1370,7 @@ function peg$parse(input, options) {
942
1370
  s3 = peg$parsearguments();
943
1371
  }
944
1372
  peg$savedPos = s0;
945
- s0 = peg$f4(s1, s2);
1373
+ s0 = peg$f10(s1, s2);
946
1374
  } else {
947
1375
  peg$currPos = s0;
948
1376
  s0 = peg$FAILED;
@@ -950,7 +1378,7 @@ function peg$parse(input, options) {
950
1378
  peg$silentFails--;
951
1379
  if (s0 === peg$FAILED) {
952
1380
  s1 = peg$FAILED;
953
- if (peg$silentFails === 0) { peg$fail(peg$e5); }
1381
+ if (peg$silentFails === 0) { peg$fail(peg$e10); }
954
1382
  }
955
1383
 
956
1384
  return s0;
@@ -960,11 +1388,11 @@ function peg$parse(input, options) {
960
1388
  var s0, s1;
961
1389
 
962
1390
  if (input.charCodeAt(peg$currPos) === 125) {
963
- s0 = peg$c3;
1391
+ s0 = peg$c7;
964
1392
  peg$currPos++;
965
1393
  } else {
966
1394
  s0 = peg$FAILED;
967
- if (peg$silentFails === 0) { peg$fail(peg$e6); }
1395
+ if (peg$silentFails === 0) { peg$fail(peg$e11); }
968
1396
  }
969
1397
  if (s0 === peg$FAILED) {
970
1398
  s0 = peg$currPos;
@@ -973,13 +1401,13 @@ function peg$parse(input, options) {
973
1401
  peg$currPos++;
974
1402
  } else {
975
1403
  s1 = peg$FAILED;
976
- if (peg$silentFails === 0) { peg$fail(peg$e7); }
1404
+ if (peg$silentFails === 0) { peg$fail(peg$e12); }
977
1405
  }
978
1406
  if (s1 === peg$FAILED) {
979
1407
  s1 = null;
980
1408
  }
981
1409
  peg$savedPos = s0;
982
- s1 = peg$f5();
1410
+ s1 = peg$f11();
983
1411
  s0 = s1;
984
1412
  }
985
1413
 
@@ -990,11 +1418,11 @@ function peg$parse(input, options) {
990
1418
  var s0, s1;
991
1419
 
992
1420
  if (input.charCodeAt(peg$currPos) === 93) {
993
- s0 = peg$c4;
1421
+ s0 = peg$c1;
994
1422
  peg$currPos++;
995
1423
  } else {
996
1424
  s0 = peg$FAILED;
997
- if (peg$silentFails === 0) { peg$fail(peg$e8); }
1425
+ if (peg$silentFails === 0) { peg$fail(peg$e4); }
998
1426
  }
999
1427
  if (s0 === peg$FAILED) {
1000
1428
  s0 = peg$currPos;
@@ -1003,13 +1431,13 @@ function peg$parse(input, options) {
1003
1431
  peg$currPos++;
1004
1432
  } else {
1005
1433
  s1 = peg$FAILED;
1006
- if (peg$silentFails === 0) { peg$fail(peg$e7); }
1434
+ if (peg$silentFails === 0) { peg$fail(peg$e12); }
1007
1435
  }
1008
1436
  if (s1 === peg$FAILED) {
1009
1437
  s1 = null;
1010
1438
  }
1011
1439
  peg$savedPos = s0;
1012
- s1 = peg$f6();
1440
+ s1 = peg$f12();
1013
1441
  s0 = s1;
1014
1442
  }
1015
1443
 
@@ -1020,11 +1448,11 @@ function peg$parse(input, options) {
1020
1448
  var s0, s1;
1021
1449
 
1022
1450
  if (input.charCodeAt(peg$currPos) === 41) {
1023
- s0 = peg$c2;
1451
+ s0 = peg$c3;
1024
1452
  peg$currPos++;
1025
1453
  } else {
1026
1454
  s0 = peg$FAILED;
1027
- if (peg$silentFails === 0) { peg$fail(peg$e4); }
1455
+ if (peg$silentFails === 0) { peg$fail(peg$e6); }
1028
1456
  }
1029
1457
  if (s0 === peg$FAILED) {
1030
1458
  s0 = peg$currPos;
@@ -1033,19 +1461,73 @@ function peg$parse(input, options) {
1033
1461
  peg$currPos++;
1034
1462
  } else {
1035
1463
  s1 = peg$FAILED;
1036
- if (peg$silentFails === 0) { peg$fail(peg$e7); }
1464
+ if (peg$silentFails === 0) { peg$fail(peg$e12); }
1037
1465
  }
1038
1466
  if (s1 === peg$FAILED) {
1039
1467
  s1 = null;
1040
1468
  }
1041
1469
  peg$savedPos = s0;
1042
- s1 = peg$f7();
1470
+ s1 = peg$f13();
1043
1471
  s0 = s1;
1044
1472
  }
1045
1473
 
1046
1474
  return s0;
1047
1475
  }
1048
1476
 
1477
+ function peg$parsecommaExpression() {
1478
+ var s0, s1, s2, s3, s4, s5, s6, s7;
1479
+
1480
+ s0 = peg$currPos;
1481
+ s1 = peg$currPos;
1482
+ s2 = [];
1483
+ s3 = peg$parsepipelineExpression();
1484
+ while (s3 !== peg$FAILED) {
1485
+ s2.push(s3);
1486
+ s3 = peg$currPos;
1487
+ s4 = peg$currPos;
1488
+ s5 = peg$parse__();
1489
+ if (input.charCodeAt(peg$currPos) === 44) {
1490
+ s6 = peg$c8;
1491
+ peg$currPos++;
1492
+ } else {
1493
+ s6 = peg$FAILED;
1494
+ if (peg$silentFails === 0) { peg$fail(peg$e13); }
1495
+ }
1496
+ if (s6 !== peg$FAILED) {
1497
+ s7 = peg$parse__();
1498
+ s5 = [s5, s6, s7];
1499
+ s4 = s5;
1500
+ } else {
1501
+ peg$currPos = s4;
1502
+ s4 = peg$FAILED;
1503
+ }
1504
+ if (s4 !== peg$FAILED) {
1505
+ s4 = peg$parsepipelineExpression();
1506
+ if (s4 === peg$FAILED) {
1507
+ peg$currPos = s3;
1508
+ s3 = peg$FAILED;
1509
+ } else {
1510
+ s3 = s4;
1511
+ }
1512
+ } else {
1513
+ s3 = s4;
1514
+ }
1515
+ }
1516
+ if (s2.length < 1) {
1517
+ peg$currPos = s1;
1518
+ s1 = peg$FAILED;
1519
+ } else {
1520
+ s1 = s2;
1521
+ }
1522
+ if (s1 !== peg$FAILED) {
1523
+ peg$savedPos = s0;
1524
+ s1 = peg$f14(s1);
1525
+ }
1526
+ s0 = s1;
1527
+
1528
+ return s0;
1529
+ }
1530
+
1049
1531
  function peg$parsecomment() {
1050
1532
  var s0, s1;
1051
1533
 
@@ -1057,7 +1539,7 @@ function peg$parse(input, options) {
1057
1539
  peg$silentFails--;
1058
1540
  if (s0 === peg$FAILED) {
1059
1541
  s1 = peg$FAILED;
1060
- if (peg$silentFails === 0) { peg$fail(peg$e9); }
1542
+ if (peg$silentFails === 0) { peg$fail(peg$e14); }
1061
1543
  }
1062
1544
 
1063
1545
  return s0;
@@ -1071,11 +1553,11 @@ function peg$parse(input, options) {
1071
1553
  if (s1 !== peg$FAILED) {
1072
1554
  s2 = peg$parse__();
1073
1555
  if (input.charCodeAt(peg$currPos) === 63) {
1074
- s3 = peg$c5;
1556
+ s3 = peg$c9;
1075
1557
  peg$currPos++;
1076
1558
  } else {
1077
1559
  s3 = peg$FAILED;
1078
- if (peg$silentFails === 0) { peg$fail(peg$e10); }
1560
+ if (peg$silentFails === 0) { peg$fail(peg$e15); }
1079
1561
  }
1080
1562
  if (s3 !== peg$FAILED) {
1081
1563
  s4 = peg$parse__();
@@ -1083,18 +1565,18 @@ function peg$parse(input, options) {
1083
1565
  if (s5 !== peg$FAILED) {
1084
1566
  s6 = peg$parse__();
1085
1567
  if (input.charCodeAt(peg$currPos) === 58) {
1086
- s7 = peg$c6;
1568
+ s7 = peg$c10;
1087
1569
  peg$currPos++;
1088
1570
  } else {
1089
1571
  s7 = peg$FAILED;
1090
- if (peg$silentFails === 0) { peg$fail(peg$e11); }
1572
+ if (peg$silentFails === 0) { peg$fail(peg$e16); }
1091
1573
  }
1092
1574
  if (s7 !== peg$FAILED) {
1093
1575
  s8 = peg$parse__();
1094
1576
  s9 = peg$parsepipelineExpression();
1095
1577
  if (s9 !== peg$FAILED) {
1096
1578
  peg$savedPos = s0;
1097
- s0 = peg$f8(s1, s5, s9);
1579
+ s0 = peg$f15(s1, s5, s9);
1098
1580
  } else {
1099
1581
  peg$currPos = s0;
1100
1582
  s0 = peg$FAILED;
@@ -1128,21 +1610,21 @@ function peg$parse(input, options) {
1128
1610
  s0 = peg$currPos;
1129
1611
  s1 = [];
1130
1612
  s2 = input.charAt(peg$currPos);
1131
- if (peg$r0.test(s2)) {
1613
+ if (peg$r1.test(s2)) {
1132
1614
  peg$currPos++;
1133
1615
  } else {
1134
1616
  s2 = peg$FAILED;
1135
- if (peg$silentFails === 0) { peg$fail(peg$e12); }
1617
+ if (peg$silentFails === 0) { peg$fail(peg$e17); }
1136
1618
  }
1137
1619
  if (s2 !== peg$FAILED) {
1138
1620
  while (s2 !== peg$FAILED) {
1139
1621
  s1.push(s2);
1140
1622
  s2 = input.charAt(peg$currPos);
1141
- if (peg$r0.test(s2)) {
1623
+ if (peg$r1.test(s2)) {
1142
1624
  peg$currPos++;
1143
1625
  } else {
1144
1626
  s2 = peg$FAILED;
1145
- if (peg$silentFails === 0) { peg$fail(peg$e12); }
1627
+ if (peg$silentFails === 0) { peg$fail(peg$e17); }
1146
1628
  }
1147
1629
  }
1148
1630
  } else {
@@ -1162,19 +1644,19 @@ function peg$parse(input, options) {
1162
1644
  var s0;
1163
1645
 
1164
1646
  if (input.charCodeAt(peg$currPos) === 8658) {
1165
- s0 = peg$c7;
1647
+ s0 = peg$c11;
1166
1648
  peg$currPos++;
1167
1649
  } else {
1168
1650
  s0 = peg$FAILED;
1169
- if (peg$silentFails === 0) { peg$fail(peg$e13); }
1651
+ if (peg$silentFails === 0) { peg$fail(peg$e18); }
1170
1652
  }
1171
1653
  if (s0 === peg$FAILED) {
1172
- if (input.substr(peg$currPos, 2) === peg$c8) {
1173
- s0 = peg$c8;
1654
+ if (input.substr(peg$currPos, 2) === peg$c12) {
1655
+ s0 = peg$c12;
1174
1656
  peg$currPos += 2;
1175
1657
  } else {
1176
1658
  s0 = peg$FAILED;
1177
- if (peg$silentFails === 0) { peg$fail(peg$e14); }
1659
+ if (peg$silentFails === 0) { peg$fail(peg$e19); }
1178
1660
  }
1179
1661
  }
1180
1662
 
@@ -1187,11 +1669,11 @@ function peg$parse(input, options) {
1187
1669
  peg$silentFails++;
1188
1670
  s0 = peg$currPos;
1189
1671
  if (input.charCodeAt(peg$currPos) === 34) {
1190
- s1 = peg$c9;
1672
+ s1 = peg$c13;
1191
1673
  peg$currPos++;
1192
1674
  } else {
1193
1675
  s1 = peg$FAILED;
1194
- if (peg$silentFails === 0) { peg$fail(peg$e16); }
1676
+ if (peg$silentFails === 0) { peg$fail(peg$e21); }
1195
1677
  }
1196
1678
  if (s1 !== peg$FAILED) {
1197
1679
  s2 = [];
@@ -1201,15 +1683,15 @@ function peg$parse(input, options) {
1201
1683
  s3 = peg$parsedoubleQuoteStringChar();
1202
1684
  }
1203
1685
  if (input.charCodeAt(peg$currPos) === 34) {
1204
- s3 = peg$c9;
1686
+ s3 = peg$c13;
1205
1687
  peg$currPos++;
1206
1688
  } else {
1207
1689
  s3 = peg$FAILED;
1208
- if (peg$silentFails === 0) { peg$fail(peg$e16); }
1690
+ if (peg$silentFails === 0) { peg$fail(peg$e21); }
1209
1691
  }
1210
1692
  if (s3 !== peg$FAILED) {
1211
1693
  peg$savedPos = s0;
1212
- s0 = peg$f9(s2);
1694
+ s0 = peg$f16(s2);
1213
1695
  } else {
1214
1696
  peg$currPos = s0;
1215
1697
  s0 = peg$FAILED;
@@ -1221,7 +1703,7 @@ function peg$parse(input, options) {
1221
1703
  peg$silentFails--;
1222
1704
  if (s0 === peg$FAILED) {
1223
1705
  s1 = peg$FAILED;
1224
- if (peg$silentFails === 0) { peg$fail(peg$e15); }
1706
+ if (peg$silentFails === 0) { peg$fail(peg$e20); }
1225
1707
  }
1226
1708
 
1227
1709
  return s0;
@@ -1234,11 +1716,11 @@ function peg$parse(input, options) {
1234
1716
  s1 = peg$currPos;
1235
1717
  peg$silentFails++;
1236
1718
  if (input.charCodeAt(peg$currPos) === 34) {
1237
- s2 = peg$c9;
1719
+ s2 = peg$c13;
1238
1720
  peg$currPos++;
1239
1721
  } else {
1240
1722
  s2 = peg$FAILED;
1241
- if (peg$silentFails === 0) { peg$fail(peg$e16); }
1723
+ if (peg$silentFails === 0) { peg$fail(peg$e21); }
1242
1724
  }
1243
1725
  if (s2 === peg$FAILED) {
1244
1726
  s2 = peg$parsenewLine();
@@ -1269,20 +1751,20 @@ function peg$parse(input, options) {
1269
1751
  function peg$parseellipsis() {
1270
1752
  var s0;
1271
1753
 
1272
- if (input.substr(peg$currPos, 3) === peg$c10) {
1273
- s0 = peg$c10;
1754
+ if (input.substr(peg$currPos, 3) === peg$c14) {
1755
+ s0 = peg$c14;
1274
1756
  peg$currPos += 3;
1275
1757
  } else {
1276
1758
  s0 = peg$FAILED;
1277
- if (peg$silentFails === 0) { peg$fail(peg$e17); }
1759
+ if (peg$silentFails === 0) { peg$fail(peg$e22); }
1278
1760
  }
1279
1761
  if (s0 === peg$FAILED) {
1280
1762
  if (input.charCodeAt(peg$currPos) === 8230) {
1281
- s0 = peg$c11;
1763
+ s0 = peg$c15;
1282
1764
  peg$currPos++;
1283
1765
  } else {
1284
1766
  s0 = peg$FAILED;
1285
- if (peg$silentFails === 0) { peg$fail(peg$e18); }
1767
+ if (peg$silentFails === 0) { peg$fail(peg$e23); }
1286
1768
  }
1287
1769
  }
1288
1770
 
@@ -1293,7 +1775,7 @@ function peg$parse(input, options) {
1293
1775
  var s0, s1, s2, s3, s4, s5, s6, s7;
1294
1776
 
1295
1777
  s0 = peg$currPos;
1296
- s1 = peg$parseunaryExpression();
1778
+ s1 = peg$parserelationalExpression();
1297
1779
  if (s1 !== peg$FAILED) {
1298
1780
  s2 = [];
1299
1781
  s3 = peg$currPos;
@@ -1301,7 +1783,7 @@ function peg$parse(input, options) {
1301
1783
  s5 = peg$parseequalityOperator();
1302
1784
  if (s5 !== peg$FAILED) {
1303
1785
  s6 = peg$parse__();
1304
- s7 = peg$parseunaryExpression();
1786
+ s7 = peg$parserelationalExpression();
1305
1787
  if (s7 !== peg$FAILED) {
1306
1788
  s3 = [ s5, s7 ];
1307
1789
  } else {
@@ -1319,7 +1801,7 @@ function peg$parse(input, options) {
1319
1801
  s5 = peg$parseequalityOperator();
1320
1802
  if (s5 !== peg$FAILED) {
1321
1803
  s6 = peg$parse__();
1322
- s7 = peg$parseunaryExpression();
1804
+ s7 = peg$parserelationalExpression();
1323
1805
  if (s7 !== peg$FAILED) {
1324
1806
  s3 = [ s5, s7 ];
1325
1807
  } else {
@@ -1332,7 +1814,7 @@ function peg$parse(input, options) {
1332
1814
  }
1333
1815
  }
1334
1816
  peg$savedPos = s0;
1335
- s0 = peg$f10(s1, s2);
1817
+ s0 = peg$f17(s1, s2);
1336
1818
  } else {
1337
1819
  peg$currPos = s0;
1338
1820
  s0 = peg$FAILED;
@@ -1344,36 +1826,36 @@ function peg$parse(input, options) {
1344
1826
  function peg$parseequalityOperator() {
1345
1827
  var s0;
1346
1828
 
1347
- if (input.substr(peg$currPos, 3) === peg$c12) {
1348
- s0 = peg$c12;
1829
+ if (input.substr(peg$currPos, 3) === peg$c16) {
1830
+ s0 = peg$c16;
1349
1831
  peg$currPos += 3;
1350
1832
  } else {
1351
1833
  s0 = peg$FAILED;
1352
- if (peg$silentFails === 0) { peg$fail(peg$e19); }
1834
+ if (peg$silentFails === 0) { peg$fail(peg$e24); }
1353
1835
  }
1354
1836
  if (s0 === peg$FAILED) {
1355
- if (input.substr(peg$currPos, 3) === peg$c13) {
1356
- s0 = peg$c13;
1837
+ if (input.substr(peg$currPos, 3) === peg$c17) {
1838
+ s0 = peg$c17;
1357
1839
  peg$currPos += 3;
1358
1840
  } else {
1359
1841
  s0 = peg$FAILED;
1360
- if (peg$silentFails === 0) { peg$fail(peg$e20); }
1842
+ if (peg$silentFails === 0) { peg$fail(peg$e25); }
1361
1843
  }
1362
1844
  if (s0 === peg$FAILED) {
1363
- if (input.substr(peg$currPos, 2) === peg$c14) {
1364
- s0 = peg$c14;
1845
+ if (input.substr(peg$currPos, 2) === peg$c18) {
1846
+ s0 = peg$c18;
1365
1847
  peg$currPos += 2;
1366
1848
  } else {
1367
1849
  s0 = peg$FAILED;
1368
- if (peg$silentFails === 0) { peg$fail(peg$e21); }
1850
+ if (peg$silentFails === 0) { peg$fail(peg$e26); }
1369
1851
  }
1370
1852
  if (s0 === peg$FAILED) {
1371
- if (input.substr(peg$currPos, 2) === peg$c15) {
1372
- s0 = peg$c15;
1853
+ if (input.substr(peg$currPos, 2) === peg$c19) {
1854
+ s0 = peg$c19;
1373
1855
  peg$currPos += 2;
1374
1856
  } else {
1375
1857
  s0 = peg$FAILED;
1376
- if (peg$silentFails === 0) { peg$fail(peg$e22); }
1858
+ if (peg$silentFails === 0) { peg$fail(peg$e27); }
1377
1859
  }
1378
1860
  }
1379
1861
  }
@@ -1387,110 +1869,110 @@ function peg$parse(input, options) {
1387
1869
 
1388
1870
  peg$silentFails++;
1389
1871
  s0 = peg$currPos;
1390
- if (input.substr(peg$currPos, 2) === peg$c16) {
1391
- s1 = peg$c16;
1872
+ if (input.substr(peg$currPos, 2) === peg$c20) {
1873
+ s1 = peg$c20;
1392
1874
  peg$currPos += 2;
1393
1875
  } else {
1394
1876
  s1 = peg$FAILED;
1395
- if (peg$silentFails === 0) { peg$fail(peg$e24); }
1877
+ if (peg$silentFails === 0) { peg$fail(peg$e29); }
1396
1878
  }
1397
1879
  if (s1 !== peg$FAILED) {
1398
1880
  peg$savedPos = s0;
1399
- s1 = peg$f11();
1881
+ s1 = peg$f18();
1400
1882
  }
1401
1883
  s0 = s1;
1402
1884
  if (s0 === peg$FAILED) {
1403
1885
  s0 = peg$currPos;
1404
- if (input.substr(peg$currPos, 2) === peg$c17) {
1405
- s1 = peg$c17;
1886
+ if (input.substr(peg$currPos, 2) === peg$c21) {
1887
+ s1 = peg$c21;
1406
1888
  peg$currPos += 2;
1407
1889
  } else {
1408
1890
  s1 = peg$FAILED;
1409
- if (peg$silentFails === 0) { peg$fail(peg$e25); }
1891
+ if (peg$silentFails === 0) { peg$fail(peg$e30); }
1410
1892
  }
1411
1893
  if (s1 !== peg$FAILED) {
1412
1894
  peg$savedPos = s0;
1413
- s1 = peg$f12();
1895
+ s1 = peg$f19();
1414
1896
  }
1415
1897
  s0 = s1;
1416
1898
  if (s0 === peg$FAILED) {
1417
1899
  s0 = peg$currPos;
1418
- if (input.substr(peg$currPos, 2) === peg$c18) {
1419
- s1 = peg$c18;
1900
+ if (input.substr(peg$currPos, 2) === peg$c22) {
1901
+ s1 = peg$c22;
1420
1902
  peg$currPos += 2;
1421
1903
  } else {
1422
1904
  s1 = peg$FAILED;
1423
- if (peg$silentFails === 0) { peg$fail(peg$e26); }
1905
+ if (peg$silentFails === 0) { peg$fail(peg$e31); }
1424
1906
  }
1425
1907
  if (s1 !== peg$FAILED) {
1426
1908
  peg$savedPos = s0;
1427
- s1 = peg$f13();
1909
+ s1 = peg$f20();
1428
1910
  }
1429
1911
  s0 = s1;
1430
1912
  if (s0 === peg$FAILED) {
1431
1913
  s0 = peg$currPos;
1432
- if (input.substr(peg$currPos, 2) === peg$c19) {
1433
- s1 = peg$c19;
1914
+ if (input.substr(peg$currPos, 2) === peg$c23) {
1915
+ s1 = peg$c23;
1434
1916
  peg$currPos += 2;
1435
1917
  } else {
1436
1918
  s1 = peg$FAILED;
1437
- if (peg$silentFails === 0) { peg$fail(peg$e27); }
1919
+ if (peg$silentFails === 0) { peg$fail(peg$e32); }
1438
1920
  }
1439
1921
  if (s1 !== peg$FAILED) {
1440
1922
  peg$savedPos = s0;
1441
- s1 = peg$f14();
1923
+ s1 = peg$f21();
1442
1924
  }
1443
1925
  s0 = s1;
1444
1926
  if (s0 === peg$FAILED) {
1445
1927
  s0 = peg$currPos;
1446
- if (input.substr(peg$currPos, 2) === peg$c20) {
1447
- s1 = peg$c20;
1928
+ if (input.substr(peg$currPos, 2) === peg$c24) {
1929
+ s1 = peg$c24;
1448
1930
  peg$currPos += 2;
1449
1931
  } else {
1450
1932
  s1 = peg$FAILED;
1451
- if (peg$silentFails === 0) { peg$fail(peg$e28); }
1933
+ if (peg$silentFails === 0) { peg$fail(peg$e33); }
1452
1934
  }
1453
1935
  if (s1 !== peg$FAILED) {
1454
1936
  peg$savedPos = s0;
1455
- s1 = peg$f15();
1937
+ s1 = peg$f22();
1456
1938
  }
1457
1939
  s0 = s1;
1458
1940
  if (s0 === peg$FAILED) {
1459
1941
  s0 = peg$currPos;
1460
- if (input.substr(peg$currPos, 2) === peg$c21) {
1461
- s1 = peg$c21;
1942
+ if (input.substr(peg$currPos, 2) === peg$c25) {
1943
+ s1 = peg$c25;
1462
1944
  peg$currPos += 2;
1463
1945
  } else {
1464
1946
  s1 = peg$FAILED;
1465
- if (peg$silentFails === 0) { peg$fail(peg$e29); }
1947
+ if (peg$silentFails === 0) { peg$fail(peg$e34); }
1466
1948
  }
1467
1949
  if (s1 !== peg$FAILED) {
1468
1950
  peg$savedPos = s0;
1469
- s1 = peg$f16();
1951
+ s1 = peg$f23();
1470
1952
  }
1471
1953
  s0 = s1;
1472
1954
  if (s0 === peg$FAILED) {
1473
1955
  s0 = peg$currPos;
1474
- if (input.substr(peg$currPos, 2) === peg$c22) {
1475
- s1 = peg$c22;
1956
+ if (input.substr(peg$currPos, 2) === peg$c26) {
1957
+ s1 = peg$c26;
1476
1958
  peg$currPos += 2;
1477
1959
  } else {
1478
1960
  s1 = peg$FAILED;
1479
- if (peg$silentFails === 0) { peg$fail(peg$e30); }
1961
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
1480
1962
  }
1481
1963
  if (s1 !== peg$FAILED) {
1482
1964
  peg$savedPos = s0;
1483
- s1 = peg$f17();
1965
+ s1 = peg$f24();
1484
1966
  }
1485
1967
  s0 = s1;
1486
1968
  if (s0 === peg$FAILED) {
1487
1969
  s0 = peg$currPos;
1488
1970
  if (input.charCodeAt(peg$currPos) === 92) {
1489
- s1 = peg$c23;
1971
+ s1 = peg$c27;
1490
1972
  peg$currPos++;
1491
1973
  } else {
1492
1974
  s1 = peg$FAILED;
1493
- if (peg$silentFails === 0) { peg$fail(peg$e31); }
1975
+ if (peg$silentFails === 0) { peg$fail(peg$e36); }
1494
1976
  }
1495
1977
  if (s1 !== peg$FAILED) {
1496
1978
  if (input.length > peg$currPos) {
@@ -1498,7 +1980,7 @@ function peg$parse(input, options) {
1498
1980
  peg$currPos++;
1499
1981
  } else {
1500
1982
  s2 = peg$FAILED;
1501
- if (peg$silentFails === 0) { peg$fail(peg$e7); }
1983
+ if (peg$silentFails === 0) { peg$fail(peg$e12); }
1502
1984
  }
1503
1985
  if (s2 !== peg$FAILED) {
1504
1986
  s0 = s2;
@@ -1520,7 +2002,46 @@ function peg$parse(input, options) {
1520
2002
  peg$silentFails--;
1521
2003
  if (s0 === peg$FAILED) {
1522
2004
  s1 = peg$FAILED;
1523
- if (peg$silentFails === 0) { peg$fail(peg$e23); }
2005
+ if (peg$silentFails === 0) { peg$fail(peg$e28); }
2006
+ }
2007
+
2008
+ return s0;
2009
+ }
2010
+
2011
+ function peg$parseexponentiationExpression() {
2012
+ var s0, s1, s2, s3, s4, s5;
2013
+
2014
+ s0 = peg$currPos;
2015
+ s1 = peg$parseunaryExpression();
2016
+ if (s1 !== peg$FAILED) {
2017
+ s2 = peg$parse__();
2018
+ if (input.substr(peg$currPos, 2) === peg$c28) {
2019
+ s3 = peg$c28;
2020
+ peg$currPos += 2;
2021
+ } else {
2022
+ s3 = peg$FAILED;
2023
+ if (peg$silentFails === 0) { peg$fail(peg$e37); }
2024
+ }
2025
+ if (s3 !== peg$FAILED) {
2026
+ s4 = peg$parse__();
2027
+ s5 = peg$parseexponentiationExpression();
2028
+ if (s5 !== peg$FAILED) {
2029
+ peg$savedPos = s0;
2030
+ s0 = peg$f25(s1, s5);
2031
+ } else {
2032
+ peg$currPos = s0;
2033
+ s0 = peg$FAILED;
2034
+ }
2035
+ } else {
2036
+ peg$currPos = s0;
2037
+ s0 = peg$FAILED;
2038
+ }
2039
+ } else {
2040
+ peg$currPos = s0;
2041
+ s0 = peg$FAILED;
2042
+ }
2043
+ if (s0 === peg$FAILED) {
2044
+ s0 = peg$parseunaryExpression();
1524
2045
  }
1525
2046
 
1526
2047
  return s0;
@@ -1531,7 +2052,7 @@ function peg$parse(input, options) {
1531
2052
 
1532
2053
  s0 = peg$currPos;
1533
2054
  s1 = peg$parse__();
1534
- s2 = peg$parsepipelineExpression();
2055
+ s2 = peg$parsecommaExpression();
1535
2056
  if (s2 !== peg$FAILED) {
1536
2057
  s3 = peg$parse__();
1537
2058
  s0 = s2;
@@ -1544,30 +2065,26 @@ function peg$parse(input, options) {
1544
2065
  }
1545
2066
 
1546
2067
  function peg$parsefloatLiteral() {
1547
- var s0, s1, s2, s3, s4;
2068
+ var s0, s1, s2, s3;
1548
2069
 
1549
2070
  peg$silentFails++;
1550
2071
  s0 = peg$currPos;
1551
- s1 = peg$parsesign();
2072
+ s1 = peg$parsedigits();
1552
2073
  if (s1 === peg$FAILED) {
1553
2074
  s1 = null;
1554
2075
  }
1555
- s2 = peg$parsedigits();
1556
- if (s2 === peg$FAILED) {
1557
- s2 = null;
1558
- }
1559
2076
  if (input.charCodeAt(peg$currPos) === 46) {
1560
- s3 = peg$c24;
2077
+ s2 = peg$c29;
1561
2078
  peg$currPos++;
1562
2079
  } else {
1563
- s3 = peg$FAILED;
1564
- if (peg$silentFails === 0) { peg$fail(peg$e33); }
2080
+ s2 = peg$FAILED;
2081
+ if (peg$silentFails === 0) { peg$fail(peg$e39); }
1565
2082
  }
1566
- if (s3 !== peg$FAILED) {
1567
- s4 = peg$parsedigits();
1568
- if (s4 !== peg$FAILED) {
2083
+ if (s2 !== peg$FAILED) {
2084
+ s3 = peg$parsedigits();
2085
+ if (s3 !== peg$FAILED) {
1569
2086
  peg$savedPos = s0;
1570
- s0 = peg$f18();
2087
+ s0 = peg$f26();
1571
2088
  } else {
1572
2089
  peg$currPos = s0;
1573
2090
  s0 = peg$FAILED;
@@ -1579,7 +2096,7 @@ function peg$parse(input, options) {
1579
2096
  peg$silentFails--;
1580
2097
  if (s0 === peg$FAILED) {
1581
2098
  s1 = peg$FAILED;
1582
- if (peg$silentFails === 0) { peg$fail(peg$e32); }
2099
+ if (peg$silentFails === 0) { peg$fail(peg$e38); }
1583
2100
  }
1584
2101
 
1585
2102
  return s0;
@@ -1591,11 +2108,11 @@ function peg$parse(input, options) {
1591
2108
  peg$silentFails++;
1592
2109
  s0 = peg$currPos;
1593
2110
  if (input.charCodeAt(peg$currPos) === 40) {
1594
- s1 = peg$c1;
2111
+ s1 = peg$c2;
1595
2112
  peg$currPos++;
1596
2113
  } else {
1597
2114
  s1 = peg$FAILED;
1598
- if (peg$silentFails === 0) { peg$fail(peg$e3); }
2115
+ if (peg$silentFails === 0) { peg$fail(peg$e5); }
1599
2116
  }
1600
2117
  if (s1 !== peg$FAILED) {
1601
2118
  s2 = peg$parseexpression();
@@ -1603,7 +2120,7 @@ function peg$parse(input, options) {
1603
2120
  s3 = peg$parseclosingParenthesis();
1604
2121
  if (s3 !== peg$FAILED) {
1605
2122
  peg$savedPos = s0;
1606
- s0 = peg$f19(s2);
2123
+ s0 = peg$f27(s2);
1607
2124
  } else {
1608
2125
  peg$currPos = s0;
1609
2126
  s0 = peg$FAILED;
@@ -1619,7 +2136,7 @@ function peg$parse(input, options) {
1619
2136
  peg$silentFails--;
1620
2137
  if (s0 === peg$FAILED) {
1621
2138
  s1 = peg$FAILED;
1622
- if (peg$silentFails === 0) { peg$fail(peg$e34); }
2139
+ if (peg$silentFails === 0) { peg$fail(peg$e40); }
1623
2140
  }
1624
2141
 
1625
2142
  return s0;
@@ -1631,11 +2148,11 @@ function peg$parse(input, options) {
1631
2148
  peg$silentFails++;
1632
2149
  s0 = peg$currPos;
1633
2150
  if (input.charCodeAt(peg$currPos) === 171) {
1634
- s1 = peg$c25;
2151
+ s1 = peg$c30;
1635
2152
  peg$currPos++;
1636
2153
  } else {
1637
2154
  s1 = peg$FAILED;
1638
- if (peg$silentFails === 0) { peg$fail(peg$e36); }
2155
+ if (peg$silentFails === 0) { peg$fail(peg$e42); }
1639
2156
  }
1640
2157
  if (s1 !== peg$FAILED) {
1641
2158
  s2 = [];
@@ -1645,15 +2162,15 @@ function peg$parse(input, options) {
1645
2162
  s3 = peg$parseguillemetStringChar();
1646
2163
  }
1647
2164
  if (input.charCodeAt(peg$currPos) === 187) {
1648
- s3 = peg$c26;
2165
+ s3 = peg$c31;
1649
2166
  peg$currPos++;
1650
2167
  } else {
1651
2168
  s3 = peg$FAILED;
1652
- if (peg$silentFails === 0) { peg$fail(peg$e37); }
2169
+ if (peg$silentFails === 0) { peg$fail(peg$e43); }
1653
2170
  }
1654
2171
  if (s3 !== peg$FAILED) {
1655
2172
  peg$savedPos = s0;
1656
- s0 = peg$f20(s2);
2173
+ s0 = peg$f28(s2);
1657
2174
  } else {
1658
2175
  peg$currPos = s0;
1659
2176
  s0 = peg$FAILED;
@@ -1665,7 +2182,7 @@ function peg$parse(input, options) {
1665
2182
  peg$silentFails--;
1666
2183
  if (s0 === peg$FAILED) {
1667
2184
  s1 = peg$FAILED;
1668
- if (peg$silentFails === 0) { peg$fail(peg$e35); }
2185
+ if (peg$silentFails === 0) { peg$fail(peg$e41); }
1669
2186
  }
1670
2187
 
1671
2188
  return s0;
@@ -1678,11 +2195,11 @@ function peg$parse(input, options) {
1678
2195
  s1 = peg$currPos;
1679
2196
  peg$silentFails++;
1680
2197
  if (input.charCodeAt(peg$currPos) === 187) {
1681
- s2 = peg$c26;
2198
+ s2 = peg$c31;
1682
2199
  peg$currPos++;
1683
2200
  } else {
1684
2201
  s2 = peg$FAILED;
1685
- if (peg$silentFails === 0) { peg$fail(peg$e37); }
2202
+ if (peg$silentFails === 0) { peg$fail(peg$e43); }
1686
2203
  }
1687
2204
  if (s2 === peg$FAILED) {
1688
2205
  s2 = peg$parsenewLine();
@@ -1715,15 +2232,15 @@ function peg$parse(input, options) {
1715
2232
 
1716
2233
  s0 = peg$currPos;
1717
2234
  if (input.charCodeAt(peg$currPos) === 126) {
1718
- s1 = peg$c27;
2235
+ s1 = peg$c32;
1719
2236
  peg$currPos++;
1720
2237
  } else {
1721
2238
  s1 = peg$FAILED;
1722
- if (peg$silentFails === 0) { peg$fail(peg$e38); }
2239
+ if (peg$silentFails === 0) { peg$fail(peg$e44); }
1723
2240
  }
1724
2241
  if (s1 !== peg$FAILED) {
1725
2242
  peg$savedPos = s0;
1726
- s1 = peg$f21();
2243
+ s1 = peg$f29();
1727
2244
  }
1728
2245
  s0 = s1;
1729
2246
 
@@ -1739,11 +2256,11 @@ function peg$parse(input, options) {
1739
2256
  if (s1 !== peg$FAILED) {
1740
2257
  s2 = peg$currPos;
1741
2258
  if (input.charCodeAt(peg$currPos) === 58) {
1742
- s3 = peg$c6;
2259
+ s3 = peg$c10;
1743
2260
  peg$currPos++;
1744
2261
  } else {
1745
2262
  s3 = peg$FAILED;
1746
- if (peg$silentFails === 0) { peg$fail(peg$e11); }
2263
+ if (peg$silentFails === 0) { peg$fail(peg$e16); }
1747
2264
  }
1748
2265
  if (s3 !== peg$FAILED) {
1749
2266
  s4 = peg$parseintegerLiteral();
@@ -1765,7 +2282,7 @@ function peg$parse(input, options) {
1765
2282
  s3 = null;
1766
2283
  }
1767
2284
  peg$savedPos = s0;
1768
- s0 = peg$f22(s1, s2, s3);
2285
+ s0 = peg$f30(s1, s2, s3);
1769
2286
  } else {
1770
2287
  peg$currPos = s0;
1771
2288
  s0 = peg$FAILED;
@@ -1773,7 +2290,7 @@ function peg$parse(input, options) {
1773
2290
  peg$silentFails--;
1774
2291
  if (s0 === peg$FAILED) {
1775
2292
  s1 = peg$FAILED;
1776
- if (peg$silentFails === 0) { peg$fail(peg$e39); }
2293
+ if (peg$silentFails === 0) { peg$fail(peg$e45); }
1777
2294
  }
1778
2295
 
1779
2296
  return s0;
@@ -1796,13 +2313,13 @@ function peg$parse(input, options) {
1796
2313
  }
1797
2314
  if (s1 !== peg$FAILED) {
1798
2315
  peg$savedPos = s0;
1799
- s1 = peg$f23(s1);
2316
+ s1 = peg$f31(s1);
1800
2317
  }
1801
2318
  s0 = s1;
1802
2319
  peg$silentFails--;
1803
2320
  if (s0 === peg$FAILED) {
1804
2321
  s1 = peg$FAILED;
1805
- if (peg$silentFails === 0) { peg$fail(peg$e40); }
2322
+ if (peg$silentFails === 0) { peg$fail(peg$e46); }
1806
2323
  }
1807
2324
 
1808
2325
  return s0;
@@ -1812,30 +2329,30 @@ function peg$parse(input, options) {
1812
2329
  var s0, s1, s2, s3;
1813
2330
 
1814
2331
  s0 = input.charAt(peg$currPos);
1815
- if (peg$r1.test(s0)) {
2332
+ if (peg$r2.test(s0)) {
1816
2333
  peg$currPos++;
1817
2334
  } else {
1818
2335
  s0 = peg$FAILED;
1819
- if (peg$silentFails === 0) { peg$fail(peg$e41); }
2336
+ if (peg$silentFails === 0) { peg$fail(peg$e47); }
1820
2337
  }
1821
2338
  if (s0 === peg$FAILED) {
1822
2339
  s0 = peg$currPos;
1823
2340
  if (input.charCodeAt(peg$currPos) === 45) {
1824
- s1 = peg$c28;
2341
+ s1 = peg$c33;
1825
2342
  peg$currPos++;
1826
2343
  } else {
1827
2344
  s1 = peg$FAILED;
1828
- if (peg$silentFails === 0) { peg$fail(peg$e42); }
2345
+ if (peg$silentFails === 0) { peg$fail(peg$e48); }
1829
2346
  }
1830
2347
  if (s1 !== peg$FAILED) {
1831
2348
  s2 = peg$currPos;
1832
2349
  peg$silentFails++;
1833
2350
  if (input.charCodeAt(peg$currPos) === 62) {
1834
- s3 = peg$c29;
2351
+ s3 = peg$c34;
1835
2352
  peg$currPos++;
1836
2353
  } else {
1837
2354
  s3 = peg$FAILED;
1838
- if (peg$silentFails === 0) { peg$fail(peg$e43); }
2355
+ if (peg$silentFails === 0) { peg$fail(peg$e49); }
1839
2356
  }
1840
2357
  peg$silentFails--;
1841
2358
  if (s3 === peg$FAILED) {
@@ -1897,7 +2414,7 @@ function peg$parse(input, options) {
1897
2414
  s2 = null;
1898
2415
  }
1899
2416
  peg$savedPos = s0;
1900
- s0 = peg$f24(s1);
2417
+ s0 = peg$f32(s1);
1901
2418
  } else {
1902
2419
  peg$currPos = s0;
1903
2420
  s0 = peg$FAILED;
@@ -1940,7 +2457,7 @@ function peg$parse(input, options) {
1940
2457
  s2 = null;
1941
2458
  }
1942
2459
  peg$savedPos = s0;
1943
- s0 = peg$f25(s1, s2);
2460
+ s0 = peg$f33(s1, s2);
1944
2461
  } else {
1945
2462
  peg$currPos = s0;
1946
2463
  s0 = peg$FAILED;
@@ -1948,7 +2465,7 @@ function peg$parse(input, options) {
1948
2465
  peg$silentFails--;
1949
2466
  if (s0 === peg$FAILED) {
1950
2467
  s1 = peg$FAILED;
1951
- if (peg$silentFails === 0) { peg$fail(peg$e44); }
2468
+ if (peg$silentFails === 0) { peg$fail(peg$e50); }
1952
2469
  }
1953
2470
 
1954
2471
  return s0;
@@ -1989,7 +2506,7 @@ function peg$parse(input, options) {
1989
2506
  s2 = null;
1990
2507
  }
1991
2508
  peg$savedPos = s0;
1992
- s0 = peg$f26(s1);
2509
+ s0 = peg$f34(s1);
1993
2510
  } else {
1994
2511
  peg$currPos = s0;
1995
2512
  s0 = peg$FAILED;
@@ -2002,37 +2519,31 @@ function peg$parse(input, options) {
2002
2519
  var s0;
2003
2520
 
2004
2521
  s0 = input.charAt(peg$currPos);
2005
- if (peg$r2.test(s0)) {
2522
+ if (peg$r3.test(s0)) {
2006
2523
  peg$currPos++;
2007
2524
  } else {
2008
2525
  s0 = peg$FAILED;
2009
- if (peg$silentFails === 0) { peg$fail(peg$e45); }
2526
+ if (peg$silentFails === 0) { peg$fail(peg$e51); }
2010
2527
  }
2011
2528
 
2012
2529
  return s0;
2013
2530
  }
2014
2531
 
2015
2532
  function peg$parseintegerLiteral() {
2016
- var s0, s1, s2;
2533
+ var s0, s1;
2017
2534
 
2018
2535
  peg$silentFails++;
2019
2536
  s0 = peg$currPos;
2020
- s1 = peg$parsesign();
2021
- if (s1 === peg$FAILED) {
2022
- s1 = null;
2023
- }
2024
- s2 = peg$parsedigits();
2025
- if (s2 !== peg$FAILED) {
2537
+ s1 = peg$parsedigits();
2538
+ if (s1 !== peg$FAILED) {
2026
2539
  peg$savedPos = s0;
2027
- s0 = peg$f27();
2028
- } else {
2029
- peg$currPos = s0;
2030
- s0 = peg$FAILED;
2540
+ s1 = peg$f35();
2031
2541
  }
2542
+ s0 = s1;
2032
2543
  peg$silentFails--;
2033
2544
  if (s0 === peg$FAILED) {
2034
2545
  s1 = peg$FAILED;
2035
- if (peg$silentFails === 0) { peg$fail(peg$e46); }
2546
+ if (peg$silentFails === 0) { peg$fail(peg$e52); }
2036
2547
  }
2037
2548
 
2038
2549
  return s0;
@@ -2074,7 +2585,7 @@ function peg$parse(input, options) {
2074
2585
  s2 = null;
2075
2586
  }
2076
2587
  peg$savedPos = s0;
2077
- s0 = peg$f28(s1);
2588
+ s0 = peg$f36(s1);
2078
2589
  } else {
2079
2590
  peg$currPos = s0;
2080
2591
  s0 = peg$FAILED;
@@ -2082,7 +2593,7 @@ function peg$parse(input, options) {
2082
2593
  peg$silentFails--;
2083
2594
  if (s0 === peg$FAILED) {
2084
2595
  s1 = peg$FAILED;
2085
- if (peg$silentFails === 0) { peg$fail(peg$e47); }
2596
+ if (peg$silentFails === 0) { peg$fail(peg$e53); }
2086
2597
  }
2087
2598
 
2088
2599
  return s0;
@@ -2103,21 +2614,21 @@ function peg$parse(input, options) {
2103
2614
  var s0, s1, s2, s3, s4, s5, s6, s7;
2104
2615
 
2105
2616
  s0 = peg$currPos;
2106
- s1 = peg$parseequalityExpression();
2617
+ s1 = peg$parsebitwiseOrExpression();
2107
2618
  if (s1 !== peg$FAILED) {
2108
2619
  s2 = [];
2109
2620
  s3 = peg$currPos;
2110
2621
  s4 = peg$parse__();
2111
- if (input.substr(peg$currPos, 2) === peg$c30) {
2112
- s5 = peg$c30;
2622
+ if (input.substr(peg$currPos, 2) === peg$c35) {
2623
+ s5 = peg$c35;
2113
2624
  peg$currPos += 2;
2114
2625
  } else {
2115
2626
  s5 = peg$FAILED;
2116
- if (peg$silentFails === 0) { peg$fail(peg$e48); }
2627
+ if (peg$silentFails === 0) { peg$fail(peg$e54); }
2117
2628
  }
2118
2629
  if (s5 !== peg$FAILED) {
2119
2630
  s6 = peg$parse__();
2120
- s7 = peg$parseequalityExpression();
2631
+ s7 = peg$parsebitwiseOrExpression();
2121
2632
  if (s7 !== peg$FAILED) {
2122
2633
  s3 = s7;
2123
2634
  } else {
@@ -2132,16 +2643,16 @@ function peg$parse(input, options) {
2132
2643
  s2.push(s3);
2133
2644
  s3 = peg$currPos;
2134
2645
  s4 = peg$parse__();
2135
- if (input.substr(peg$currPos, 2) === peg$c30) {
2136
- s5 = peg$c30;
2646
+ if (input.substr(peg$currPos, 2) === peg$c35) {
2647
+ s5 = peg$c35;
2137
2648
  peg$currPos += 2;
2138
2649
  } else {
2139
2650
  s5 = peg$FAILED;
2140
- if (peg$silentFails === 0) { peg$fail(peg$e48); }
2651
+ if (peg$silentFails === 0) { peg$fail(peg$e54); }
2141
2652
  }
2142
2653
  if (s5 !== peg$FAILED) {
2143
2654
  s6 = peg$parse__();
2144
- s7 = peg$parseequalityExpression();
2655
+ s7 = peg$parsebitwiseOrExpression();
2145
2656
  if (s7 !== peg$FAILED) {
2146
2657
  s3 = s7;
2147
2658
  } else {
@@ -2154,7 +2665,7 @@ function peg$parse(input, options) {
2154
2665
  }
2155
2666
  }
2156
2667
  peg$savedPos = s0;
2157
- s0 = peg$f29(s1, s2);
2668
+ s0 = peg$f37(s1, s2);
2158
2669
  } else {
2159
2670
  peg$currPos = s0;
2160
2671
  s0 = peg$FAILED;
@@ -2172,12 +2683,12 @@ function peg$parse(input, options) {
2172
2683
  s2 = [];
2173
2684
  s3 = peg$currPos;
2174
2685
  s4 = peg$parse__();
2175
- if (input.substr(peg$currPos, 2) === peg$c31) {
2176
- s5 = peg$c31;
2686
+ if (input.substr(peg$currPos, 2) === peg$c36) {
2687
+ s5 = peg$c36;
2177
2688
  peg$currPos += 2;
2178
2689
  } else {
2179
2690
  s5 = peg$FAILED;
2180
- if (peg$silentFails === 0) { peg$fail(peg$e49); }
2691
+ if (peg$silentFails === 0) { peg$fail(peg$e55); }
2181
2692
  }
2182
2693
  if (s5 !== peg$FAILED) {
2183
2694
  s6 = peg$parse__();
@@ -2196,12 +2707,12 @@ function peg$parse(input, options) {
2196
2707
  s2.push(s3);
2197
2708
  s3 = peg$currPos;
2198
2709
  s4 = peg$parse__();
2199
- if (input.substr(peg$currPos, 2) === peg$c31) {
2200
- s5 = peg$c31;
2710
+ if (input.substr(peg$currPos, 2) === peg$c36) {
2711
+ s5 = peg$c36;
2201
2712
  peg$currPos += 2;
2202
2713
  } else {
2203
2714
  s5 = peg$FAILED;
2204
- if (peg$silentFails === 0) { peg$fail(peg$e49); }
2715
+ if (peg$silentFails === 0) { peg$fail(peg$e55); }
2205
2716
  }
2206
2717
  if (s5 !== peg$FAILED) {
2207
2718
  s6 = peg$parse__();
@@ -2218,7 +2729,7 @@ function peg$parse(input, options) {
2218
2729
  }
2219
2730
  }
2220
2731
  peg$savedPos = s0;
2221
- s0 = peg$f30(s1, s2);
2732
+ s0 = peg$f38(s1, s2);
2222
2733
  } else {
2223
2734
  peg$currPos = s0;
2224
2735
  s0 = peg$FAILED;
@@ -2231,24 +2742,24 @@ function peg$parse(input, options) {
2231
2742
  var s0, s1, s2, s3, s4, s5;
2232
2743
 
2233
2744
  s0 = peg$currPos;
2234
- if (input.substr(peg$currPos, 2) === peg$c32) {
2235
- s1 = peg$c32;
2745
+ if (input.substr(peg$currPos, 2) === peg$c37) {
2746
+ s1 = peg$c37;
2236
2747
  peg$currPos += 2;
2237
2748
  } else {
2238
2749
  s1 = peg$FAILED;
2239
- if (peg$silentFails === 0) { peg$fail(peg$e50); }
2750
+ if (peg$silentFails === 0) { peg$fail(peg$e56); }
2240
2751
  }
2241
2752
  if (s1 !== peg$FAILED) {
2242
2753
  s2 = [];
2243
2754
  s3 = peg$currPos;
2244
2755
  s4 = peg$currPos;
2245
2756
  peg$silentFails++;
2246
- if (input.substr(peg$currPos, 2) === peg$c33) {
2247
- s5 = peg$c33;
2757
+ if (input.substr(peg$currPos, 2) === peg$c38) {
2758
+ s5 = peg$c38;
2248
2759
  peg$currPos += 2;
2249
2760
  } else {
2250
2761
  s5 = peg$FAILED;
2251
- if (peg$silentFails === 0) { peg$fail(peg$e51); }
2762
+ if (peg$silentFails === 0) { peg$fail(peg$e57); }
2252
2763
  }
2253
2764
  peg$silentFails--;
2254
2765
  if (s5 === peg$FAILED) {
@@ -2263,7 +2774,7 @@ function peg$parse(input, options) {
2263
2774
  peg$currPos++;
2264
2775
  } else {
2265
2776
  s5 = peg$FAILED;
2266
- if (peg$silentFails === 0) { peg$fail(peg$e7); }
2777
+ if (peg$silentFails === 0) { peg$fail(peg$e12); }
2267
2778
  }
2268
2779
  if (s5 !== peg$FAILED) {
2269
2780
  s4 = [s4, s5];
@@ -2281,12 +2792,12 @@ function peg$parse(input, options) {
2281
2792
  s3 = peg$currPos;
2282
2793
  s4 = peg$currPos;
2283
2794
  peg$silentFails++;
2284
- if (input.substr(peg$currPos, 2) === peg$c33) {
2285
- s5 = peg$c33;
2795
+ if (input.substr(peg$currPos, 2) === peg$c38) {
2796
+ s5 = peg$c38;
2286
2797
  peg$currPos += 2;
2287
2798
  } else {
2288
2799
  s5 = peg$FAILED;
2289
- if (peg$silentFails === 0) { peg$fail(peg$e51); }
2800
+ if (peg$silentFails === 0) { peg$fail(peg$e57); }
2290
2801
  }
2291
2802
  peg$silentFails--;
2292
2803
  if (s5 === peg$FAILED) {
@@ -2301,7 +2812,7 @@ function peg$parse(input, options) {
2301
2812
  peg$currPos++;
2302
2813
  } else {
2303
2814
  s5 = peg$FAILED;
2304
- if (peg$silentFails === 0) { peg$fail(peg$e7); }
2815
+ if (peg$silentFails === 0) { peg$fail(peg$e12); }
2305
2816
  }
2306
2817
  if (s5 !== peg$FAILED) {
2307
2818
  s4 = [s4, s5];
@@ -2315,16 +2826,16 @@ function peg$parse(input, options) {
2315
2826
  s3 = peg$FAILED;
2316
2827
  }
2317
2828
  }
2318
- if (input.substr(peg$currPos, 2) === peg$c33) {
2319
- s3 = peg$c33;
2829
+ if (input.substr(peg$currPos, 2) === peg$c38) {
2830
+ s3 = peg$c38;
2320
2831
  peg$currPos += 2;
2321
2832
  } else {
2322
2833
  s3 = peg$FAILED;
2323
- if (peg$silentFails === 0) { peg$fail(peg$e51); }
2834
+ if (peg$silentFails === 0) { peg$fail(peg$e57); }
2324
2835
  }
2325
2836
  if (s3 !== peg$FAILED) {
2326
2837
  peg$savedPos = s0;
2327
- s0 = peg$f31();
2838
+ s0 = peg$f39();
2328
2839
  } else {
2329
2840
  peg$currPos = s0;
2330
2841
  s0 = peg$FAILED;
@@ -2337,37 +2848,103 @@ function peg$parse(input, options) {
2337
2848
  return s0;
2338
2849
  }
2339
2850
 
2851
+ function peg$parsemultiplicativeExpression() {
2852
+ var s0, s1, s2, s3, s4, s5, s6, s7;
2853
+
2854
+ s0 = peg$currPos;
2855
+ s1 = peg$parseexponentiationExpression();
2856
+ if (s1 !== peg$FAILED) {
2857
+ s2 = [];
2858
+ s3 = peg$currPos;
2859
+ s4 = peg$parse__();
2860
+ s5 = peg$parsemultiplicativeOperator();
2861
+ if (s5 !== peg$FAILED) {
2862
+ s6 = peg$parse__();
2863
+ s7 = peg$parseexponentiationExpression();
2864
+ if (s7 !== peg$FAILED) {
2865
+ s3 = [ s5, s7 ];
2866
+ } else {
2867
+ peg$currPos = s3;
2868
+ s3 = peg$FAILED;
2869
+ }
2870
+ } else {
2871
+ peg$currPos = s3;
2872
+ s3 = peg$FAILED;
2873
+ }
2874
+ while (s3 !== peg$FAILED) {
2875
+ s2.push(s3);
2876
+ s3 = peg$currPos;
2877
+ s4 = peg$parse__();
2878
+ s5 = peg$parsemultiplicativeOperator();
2879
+ if (s5 !== peg$FAILED) {
2880
+ s6 = peg$parse__();
2881
+ s7 = peg$parseexponentiationExpression();
2882
+ if (s7 !== peg$FAILED) {
2883
+ s3 = [ s5, s7 ];
2884
+ } else {
2885
+ peg$currPos = s3;
2886
+ s3 = peg$FAILED;
2887
+ }
2888
+ } else {
2889
+ peg$currPos = s3;
2890
+ s3 = peg$FAILED;
2891
+ }
2892
+ }
2893
+ peg$savedPos = s0;
2894
+ s0 = peg$f40(s1, s2);
2895
+ } else {
2896
+ peg$currPos = s0;
2897
+ s0 = peg$FAILED;
2898
+ }
2899
+
2900
+ return s0;
2901
+ }
2902
+
2903
+ function peg$parsemultiplicativeOperator() {
2904
+ var s0;
2905
+
2906
+ s0 = input.charAt(peg$currPos);
2907
+ if (peg$r4.test(s0)) {
2908
+ peg$currPos++;
2909
+ } else {
2910
+ s0 = peg$FAILED;
2911
+ if (peg$silentFails === 0) { peg$fail(peg$e58); }
2912
+ }
2913
+
2914
+ return s0;
2915
+ }
2916
+
2340
2917
  function peg$parsenamespace() {
2341
2918
  var s0, s1, s2, s3;
2342
2919
 
2343
2920
  s0 = peg$currPos;
2344
2921
  if (input.charCodeAt(peg$currPos) === 64) {
2345
- s1 = peg$c34;
2922
+ s1 = peg$c39;
2346
2923
  peg$currPos++;
2347
2924
  } else {
2348
2925
  s1 = peg$FAILED;
2349
- if (peg$silentFails === 0) { peg$fail(peg$e52); }
2926
+ if (peg$silentFails === 0) { peg$fail(peg$e59); }
2350
2927
  }
2351
2928
  if (s1 === peg$FAILED) {
2352
2929
  s1 = null;
2353
2930
  }
2354
2931
  s2 = [];
2355
2932
  s3 = input.charAt(peg$currPos);
2356
- if (peg$r3.test(s3)) {
2933
+ if (peg$r5.test(s3)) {
2357
2934
  peg$currPos++;
2358
2935
  } else {
2359
2936
  s3 = peg$FAILED;
2360
- if (peg$silentFails === 0) { peg$fail(peg$e53); }
2937
+ if (peg$silentFails === 0) { peg$fail(peg$e60); }
2361
2938
  }
2362
2939
  if (s3 !== peg$FAILED) {
2363
2940
  while (s3 !== peg$FAILED) {
2364
2941
  s2.push(s3);
2365
2942
  s3 = input.charAt(peg$currPos);
2366
- if (peg$r3.test(s3)) {
2943
+ if (peg$r5.test(s3)) {
2367
2944
  peg$currPos++;
2368
2945
  } else {
2369
2946
  s3 = peg$FAILED;
2370
- if (peg$silentFails === 0) { peg$fail(peg$e53); }
2947
+ if (peg$silentFails === 0) { peg$fail(peg$e60); }
2371
2948
  }
2372
2949
  }
2373
2950
  } else {
@@ -2375,15 +2952,15 @@ function peg$parse(input, options) {
2375
2952
  }
2376
2953
  if (s2 !== peg$FAILED) {
2377
2954
  if (input.charCodeAt(peg$currPos) === 58) {
2378
- s3 = peg$c6;
2955
+ s3 = peg$c10;
2379
2956
  peg$currPos++;
2380
2957
  } else {
2381
2958
  s3 = peg$FAILED;
2382
- if (peg$silentFails === 0) { peg$fail(peg$e11); }
2959
+ if (peg$silentFails === 0) { peg$fail(peg$e16); }
2383
2960
  }
2384
2961
  if (s3 !== peg$FAILED) {
2385
2962
  peg$savedPos = s0;
2386
- s0 = peg$f32(s1, s2);
2963
+ s0 = peg$f41(s1, s2);
2387
2964
  } else {
2388
2965
  peg$currPos = s0;
2389
2966
  s0 = peg$FAILED;
@@ -2400,27 +2977,27 @@ function peg$parse(input, options) {
2400
2977
  var s0;
2401
2978
 
2402
2979
  if (input.charCodeAt(peg$currPos) === 10) {
2403
- s0 = peg$c35;
2980
+ s0 = peg$c40;
2404
2981
  peg$currPos++;
2405
2982
  } else {
2406
2983
  s0 = peg$FAILED;
2407
- if (peg$silentFails === 0) { peg$fail(peg$e54); }
2984
+ if (peg$silentFails === 0) { peg$fail(peg$e61); }
2408
2985
  }
2409
2986
  if (s0 === peg$FAILED) {
2410
- if (input.substr(peg$currPos, 2) === peg$c36) {
2411
- s0 = peg$c36;
2987
+ if (input.substr(peg$currPos, 2) === peg$c41) {
2988
+ s0 = peg$c41;
2412
2989
  peg$currPos += 2;
2413
2990
  } else {
2414
2991
  s0 = peg$FAILED;
2415
- if (peg$silentFails === 0) { peg$fail(peg$e55); }
2992
+ if (peg$silentFails === 0) { peg$fail(peg$e62); }
2416
2993
  }
2417
2994
  if (s0 === peg$FAILED) {
2418
2995
  if (input.charCodeAt(peg$currPos) === 13) {
2419
- s0 = peg$c37;
2996
+ s0 = peg$c42;
2420
2997
  peg$currPos++;
2421
2998
  } else {
2422
2999
  s0 = peg$FAILED;
2423
- if (peg$silentFails === 0) { peg$fail(peg$e56); }
3000
+ if (peg$silentFails === 0) { peg$fail(peg$e63); }
2424
3001
  }
2425
3002
  }
2426
3003
  }
@@ -2439,7 +3016,7 @@ function peg$parse(input, options) {
2439
3016
  peg$silentFails--;
2440
3017
  if (s0 === peg$FAILED) {
2441
3018
  s1 = peg$FAILED;
2442
- if (peg$silentFails === 0) { peg$fail(peg$e57); }
3019
+ if (peg$silentFails === 0) { peg$fail(peg$e64); }
2443
3020
  }
2444
3021
 
2445
3022
  return s0;
@@ -2454,12 +3031,12 @@ function peg$parse(input, options) {
2454
3031
  s2 = [];
2455
3032
  s3 = peg$currPos;
2456
3033
  s4 = peg$parse__();
2457
- if (input.substr(peg$currPos, 2) === peg$c38) {
2458
- s5 = peg$c38;
3034
+ if (input.substr(peg$currPos, 2) === peg$c43) {
3035
+ s5 = peg$c43;
2459
3036
  peg$currPos += 2;
2460
3037
  } else {
2461
3038
  s5 = peg$FAILED;
2462
- if (peg$silentFails === 0) { peg$fail(peg$e58); }
3039
+ if (peg$silentFails === 0) { peg$fail(peg$e65); }
2463
3040
  }
2464
3041
  if (s5 !== peg$FAILED) {
2465
3042
  s6 = peg$parse__();
@@ -2478,12 +3055,12 @@ function peg$parse(input, options) {
2478
3055
  s2.push(s3);
2479
3056
  s3 = peg$currPos;
2480
3057
  s4 = peg$parse__();
2481
- if (input.substr(peg$currPos, 2) === peg$c38) {
2482
- s5 = peg$c38;
3058
+ if (input.substr(peg$currPos, 2) === peg$c43) {
3059
+ s5 = peg$c43;
2483
3060
  peg$currPos += 2;
2484
3061
  } else {
2485
3062
  s5 = peg$FAILED;
2486
- if (peg$silentFails === 0) { peg$fail(peg$e58); }
3063
+ if (peg$silentFails === 0) { peg$fail(peg$e65); }
2487
3064
  }
2488
3065
  if (s5 !== peg$FAILED) {
2489
3066
  s6 = peg$parse__();
@@ -2500,7 +3077,7 @@ function peg$parse(input, options) {
2500
3077
  }
2501
3078
  }
2502
3079
  peg$savedPos = s0;
2503
- s0 = peg$f33(s1, s2);
3080
+ s0 = peg$f42(s1, s2);
2504
3081
  } else {
2505
3082
  peg$currPos = s0;
2506
3083
  s0 = peg$FAILED;
@@ -2515,11 +3092,11 @@ function peg$parse(input, options) {
2515
3092
  peg$silentFails++;
2516
3093
  s0 = peg$currPos;
2517
3094
  if (input.charCodeAt(peg$currPos) === 123) {
2518
- s1 = peg$c39;
3095
+ s1 = peg$c44;
2519
3096
  peg$currPos++;
2520
3097
  } else {
2521
3098
  s1 = peg$FAILED;
2522
- if (peg$silentFails === 0) { peg$fail(peg$e60); }
3099
+ if (peg$silentFails === 0) { peg$fail(peg$e67); }
2523
3100
  }
2524
3101
  if (s1 !== peg$FAILED) {
2525
3102
  s2 = peg$parse__();
@@ -2531,7 +3108,7 @@ function peg$parse(input, options) {
2531
3108
  s5 = peg$parseclosingBrace();
2532
3109
  if (s5 !== peg$FAILED) {
2533
3110
  peg$savedPos = s0;
2534
- s0 = peg$f34(s3);
3111
+ s0 = peg$f43(s3);
2535
3112
  } else {
2536
3113
  peg$currPos = s0;
2537
3114
  s0 = peg$FAILED;
@@ -2543,7 +3120,7 @@ function peg$parse(input, options) {
2543
3120
  peg$silentFails--;
2544
3121
  if (s0 === peg$FAILED) {
2545
3122
  s1 = peg$FAILED;
2546
- if (peg$silentFails === 0) { peg$fail(peg$e59); }
3123
+ if (peg$silentFails === 0) { peg$fail(peg$e66); }
2547
3124
  }
2548
3125
 
2549
3126
  return s0;
@@ -2584,7 +3161,7 @@ function peg$parse(input, options) {
2584
3161
  s2 = null;
2585
3162
  }
2586
3163
  peg$savedPos = s0;
2587
- s0 = peg$f35(s1);
3164
+ s0 = peg$f44(s1);
2588
3165
  } else {
2589
3166
  peg$currPos = s0;
2590
3167
  s0 = peg$FAILED;
@@ -2619,18 +3196,18 @@ function peg$parse(input, options) {
2619
3196
  if (s1 !== peg$FAILED) {
2620
3197
  s2 = peg$parse__();
2621
3198
  if (input.charCodeAt(peg$currPos) === 61) {
2622
- s3 = peg$c40;
3199
+ s3 = peg$c45;
2623
3200
  peg$currPos++;
2624
3201
  } else {
2625
3202
  s3 = peg$FAILED;
2626
- if (peg$silentFails === 0) { peg$fail(peg$e62); }
3203
+ if (peg$silentFails === 0) { peg$fail(peg$e69); }
2627
3204
  }
2628
3205
  if (s3 !== peg$FAILED) {
2629
3206
  s4 = peg$parse__();
2630
3207
  s5 = peg$parsepipelineExpression();
2631
3208
  if (s5 !== peg$FAILED) {
2632
3209
  peg$savedPos = s0;
2633
- s0 = peg$f36(s1, s5);
3210
+ s0 = peg$f45(s1, s5);
2634
3211
  } else {
2635
3212
  peg$currPos = s0;
2636
3213
  s0 = peg$FAILED;
@@ -2646,7 +3223,7 @@ function peg$parse(input, options) {
2646
3223
  peg$silentFails--;
2647
3224
  if (s0 === peg$FAILED) {
2648
3225
  s1 = peg$FAILED;
2649
- if (peg$silentFails === 0) { peg$fail(peg$e61); }
3226
+ if (peg$silentFails === 0) { peg$fail(peg$e68); }
2650
3227
  }
2651
3228
 
2652
3229
  return s0;
@@ -2658,21 +3235,21 @@ function peg$parse(input, options) {
2658
3235
  s0 = peg$currPos;
2659
3236
  s1 = peg$currPos;
2660
3237
  if (input.charCodeAt(peg$currPos) === 40) {
2661
- s2 = peg$c1;
3238
+ s2 = peg$c2;
2662
3239
  peg$currPos++;
2663
3240
  } else {
2664
3241
  s2 = peg$FAILED;
2665
- if (peg$silentFails === 0) { peg$fail(peg$e3); }
3242
+ if (peg$silentFails === 0) { peg$fail(peg$e5); }
2666
3243
  }
2667
3244
  if (s2 !== peg$FAILED) {
2668
3245
  s3 = peg$parseobjectPublicKey();
2669
3246
  if (s3 !== peg$FAILED) {
2670
3247
  if (input.charCodeAt(peg$currPos) === 41) {
2671
- s4 = peg$c2;
3248
+ s4 = peg$c3;
2672
3249
  peg$currPos++;
2673
3250
  } else {
2674
3251
  s4 = peg$FAILED;
2675
- if (peg$silentFails === 0) { peg$fail(peg$e4); }
3252
+ if (peg$silentFails === 0) { peg$fail(peg$e6); }
2676
3253
  }
2677
3254
  if (s4 !== peg$FAILED) {
2678
3255
  s2 = [s2, s3, s4];
@@ -2691,7 +3268,7 @@ function peg$parse(input, options) {
2691
3268
  }
2692
3269
  if (s1 !== peg$FAILED) {
2693
3270
  peg$savedPos = s0;
2694
- s1 = peg$f37(s1);
3271
+ s1 = peg$f46(s1);
2695
3272
  }
2696
3273
  s0 = s1;
2697
3274
 
@@ -2709,7 +3286,7 @@ function peg$parse(input, options) {
2709
3286
  peg$silentFails--;
2710
3287
  if (s0 === peg$FAILED) {
2711
3288
  s1 = peg$FAILED;
2712
- if (peg$silentFails === 0) { peg$fail(peg$e63); }
3289
+ if (peg$silentFails === 0) { peg$fail(peg$e70); }
2713
3290
  }
2714
3291
 
2715
3292
  return s0;
@@ -2724,18 +3301,18 @@ function peg$parse(input, options) {
2724
3301
  if (s1 !== peg$FAILED) {
2725
3302
  s2 = peg$parse__();
2726
3303
  if (input.charCodeAt(peg$currPos) === 58) {
2727
- s3 = peg$c6;
3304
+ s3 = peg$c10;
2728
3305
  peg$currPos++;
2729
3306
  } else {
2730
3307
  s3 = peg$FAILED;
2731
- if (peg$silentFails === 0) { peg$fail(peg$e11); }
3308
+ if (peg$silentFails === 0) { peg$fail(peg$e16); }
2732
3309
  }
2733
3310
  if (s3 !== peg$FAILED) {
2734
3311
  s4 = peg$parse__();
2735
3312
  s5 = peg$parsepipelineExpression();
2736
3313
  if (s5 !== peg$FAILED) {
2737
3314
  peg$savedPos = s0;
2738
- s0 = peg$f38(s1, s5);
3315
+ s0 = peg$f47(s1, s5);
2739
3316
  } else {
2740
3317
  peg$currPos = s0;
2741
3318
  s0 = peg$FAILED;
@@ -2751,7 +3328,7 @@ function peg$parse(input, options) {
2751
3328
  peg$silentFails--;
2752
3329
  if (s0 === peg$FAILED) {
2753
3330
  s1 = peg$FAILED;
2754
- if (peg$silentFails === 0) { peg$fail(peg$e64); }
3331
+ if (peg$silentFails === 0) { peg$fail(peg$e71); }
2755
3332
  }
2756
3333
 
2757
3334
  return s0;
@@ -2765,13 +3342,13 @@ function peg$parse(input, options) {
2765
3342
  s1 = peg$parseobjectPublicKey();
2766
3343
  if (s1 !== peg$FAILED) {
2767
3344
  peg$savedPos = s0;
2768
- s1 = peg$f39(s1);
3345
+ s1 = peg$f48(s1);
2769
3346
  }
2770
3347
  s0 = s1;
2771
3348
  peg$silentFails--;
2772
3349
  if (s0 === peg$FAILED) {
2773
3350
  s1 = peg$FAILED;
2774
- if (peg$silentFails === 0) { peg$fail(peg$e65); }
3351
+ if (peg$silentFails === 0) { peg$fail(peg$e72); }
2775
3352
  }
2776
3353
 
2777
3354
  return s0;
@@ -2784,17 +3361,17 @@ function peg$parse(input, options) {
2784
3361
  s1 = peg$parseidentifier();
2785
3362
  if (s1 !== peg$FAILED) {
2786
3363
  if (input.charCodeAt(peg$currPos) === 47) {
2787
- s2 = peg$c41;
3364
+ s2 = peg$c46;
2788
3365
  peg$currPos++;
2789
3366
  } else {
2790
3367
  s2 = peg$FAILED;
2791
- if (peg$silentFails === 0) { peg$fail(peg$e66); }
3368
+ if (peg$silentFails === 0) { peg$fail(peg$e73); }
2792
3369
  }
2793
3370
  if (s2 === peg$FAILED) {
2794
3371
  s2 = null;
2795
3372
  }
2796
3373
  peg$savedPos = s0;
2797
- s0 = peg$f40(s1, s2);
3374
+ s0 = peg$f49(s1, s2);
2798
3375
  } else {
2799
3376
  peg$currPos = s0;
2800
3377
  s0 = peg$FAILED;
@@ -2804,7 +3381,7 @@ function peg$parse(input, options) {
2804
3381
  s1 = peg$parsestringLiteral();
2805
3382
  if (s1 !== peg$FAILED) {
2806
3383
  peg$savedPos = s0;
2807
- s1 = peg$f41(s1);
3384
+ s1 = peg$f50(s1);
2808
3385
  }
2809
3386
  s0 = s1;
2810
3387
  }
@@ -2818,11 +3395,11 @@ function peg$parse(input, options) {
2818
3395
  peg$silentFails++;
2819
3396
  s0 = peg$currPos;
2820
3397
  if (input.charCodeAt(peg$currPos) === 40) {
2821
- s1 = peg$c1;
3398
+ s1 = peg$c2;
2822
3399
  peg$currPos++;
2823
3400
  } else {
2824
3401
  s1 = peg$FAILED;
2825
- if (peg$silentFails === 0) { peg$fail(peg$e3); }
3402
+ if (peg$silentFails === 0) { peg$fail(peg$e5); }
2826
3403
  }
2827
3404
  if (s1 !== peg$FAILED) {
2828
3405
  s2 = peg$parse__();
@@ -2832,15 +3409,15 @@ function peg$parse(input, options) {
2832
3409
  }
2833
3410
  s4 = peg$parse__();
2834
3411
  if (input.charCodeAt(peg$currPos) === 41) {
2835
- s5 = peg$c2;
3412
+ s5 = peg$c3;
2836
3413
  peg$currPos++;
2837
3414
  } else {
2838
3415
  s5 = peg$FAILED;
2839
- if (peg$silentFails === 0) { peg$fail(peg$e4); }
3416
+ if (peg$silentFails === 0) { peg$fail(peg$e6); }
2840
3417
  }
2841
3418
  if (s5 !== peg$FAILED) {
2842
3419
  peg$savedPos = s0;
2843
- s0 = peg$f42(s3);
3420
+ s0 = peg$f51(s3);
2844
3421
  } else {
2845
3422
  peg$currPos = s0;
2846
3423
  s0 = peg$FAILED;
@@ -2852,7 +3429,7 @@ function peg$parse(input, options) {
2852
3429
  peg$silentFails--;
2853
3430
  if (s0 === peg$FAILED) {
2854
3431
  s1 = peg$FAILED;
2855
- if (peg$silentFails === 0) { peg$fail(peg$e67); }
3432
+ if (peg$silentFails === 0) { peg$fail(peg$e74); }
2856
3433
  }
2857
3434
 
2858
3435
  return s0;
@@ -2878,13 +3455,13 @@ function peg$parse(input, options) {
2878
3455
  }
2879
3456
  if (s1 !== peg$FAILED) {
2880
3457
  peg$savedPos = s0;
2881
- s1 = peg$f43(s1);
3458
+ s1 = peg$f52(s1);
2882
3459
  }
2883
3460
  s0 = s1;
2884
3461
  peg$silentFails--;
2885
3462
  if (s0 === peg$FAILED) {
2886
3463
  s1 = peg$FAILED;
2887
- if (peg$silentFails === 0) { peg$fail(peg$e68); }
3464
+ if (peg$silentFails === 0) { peg$fail(peg$e75); }
2888
3465
  }
2889
3466
 
2890
3467
  return s0;
@@ -2897,7 +3474,7 @@ function peg$parse(input, options) {
2897
3474
  s1 = peg$parsepath();
2898
3475
  if (s1 !== peg$FAILED) {
2899
3476
  peg$savedPos = s0;
2900
- s1 = peg$f44(s1);
3477
+ s1 = peg$f53(s1);
2901
3478
  }
2902
3479
  s0 = s1;
2903
3480
 
@@ -2924,7 +3501,7 @@ function peg$parse(input, options) {
2924
3501
  s2 = null;
2925
3502
  }
2926
3503
  peg$savedPos = s0;
2927
- s0 = peg$f45(s1, s2);
3504
+ s0 = peg$f54(s1, s2);
2928
3505
  } else {
2929
3506
  peg$currPos = s0;
2930
3507
  s0 = peg$FAILED;
@@ -2938,11 +3515,11 @@ function peg$parse(input, options) {
2938
3515
 
2939
3516
  s0 = peg$currPos;
2940
3517
  if (input.charCodeAt(peg$currPos) === 47) {
2941
- s1 = peg$c41;
3518
+ s1 = peg$c46;
2942
3519
  peg$currPos++;
2943
3520
  } else {
2944
3521
  s1 = peg$FAILED;
2945
- if (peg$silentFails === 0) { peg$fail(peg$e66); }
3522
+ if (peg$silentFails === 0) { peg$fail(peg$e73); }
2946
3523
  }
2947
3524
  if (s1 !== peg$FAILED) {
2948
3525
  s2 = peg$parsepathKey();
@@ -2962,11 +3539,11 @@ function peg$parse(input, options) {
2962
3539
  var s0;
2963
3540
 
2964
3541
  s0 = input.charAt(peg$currPos);
2965
- if (peg$r4.test(s0)) {
3542
+ if (peg$r6.test(s0)) {
2966
3543
  peg$currPos++;
2967
3544
  } else {
2968
3545
  s0 = peg$FAILED;
2969
- if (peg$silentFails === 0) { peg$fail(peg$e69); }
3546
+ if (peg$silentFails === 0) { peg$fail(peg$e76); }
2970
3547
  }
2971
3548
  if (s0 === peg$FAILED) {
2972
3549
  s0 = peg$parseescapedChar();
@@ -3018,7 +3595,7 @@ function peg$parse(input, options) {
3018
3595
  }
3019
3596
  }
3020
3597
  peg$savedPos = s0;
3021
- s0 = peg$f46(s1, s2);
3598
+ s0 = peg$f55(s1, s2);
3022
3599
  } else {
3023
3600
  peg$currPos = s0;
3024
3601
  s0 = peg$FAILED;
@@ -3069,7 +3646,7 @@ function peg$parse(input, options) {
3069
3646
  peg$silentFails--;
3070
3647
  if (s0 === peg$FAILED) {
3071
3648
  s1 = peg$FAILED;
3072
- if (peg$silentFails === 0) { peg$fail(peg$e70); }
3649
+ if (peg$silentFails === 0) { peg$fail(peg$e77); }
3073
3650
  }
3074
3651
 
3075
3652
  return s0;
@@ -3081,12 +3658,12 @@ function peg$parse(input, options) {
3081
3658
  s0 = peg$currPos;
3082
3659
  s1 = peg$parsenamespace();
3083
3660
  if (s1 !== peg$FAILED) {
3084
- if (input.substr(peg$currPos, 2) === peg$c42) {
3085
- s2 = peg$c42;
3661
+ if (input.substr(peg$currPos, 2) === peg$c47) {
3662
+ s2 = peg$c47;
3086
3663
  peg$currPos += 2;
3087
3664
  } else {
3088
3665
  s2 = peg$FAILED;
3089
- if (peg$silentFails === 0) { peg$fail(peg$e71); }
3666
+ if (peg$silentFails === 0) { peg$fail(peg$e78); }
3090
3667
  }
3091
3668
  if (s2 !== peg$FAILED) {
3092
3669
  s3 = peg$parsehost();
@@ -3096,7 +3673,7 @@ function peg$parse(input, options) {
3096
3673
  s4 = null;
3097
3674
  }
3098
3675
  peg$savedPos = s0;
3099
- s0 = peg$f47(s1, s3, s4);
3676
+ s0 = peg$f56(s1, s3, s4);
3100
3677
  } else {
3101
3678
  peg$currPos = s0;
3102
3679
  s0 = peg$FAILED;
@@ -3125,7 +3702,7 @@ function peg$parse(input, options) {
3125
3702
  s2 = peg$parsescopeReference();
3126
3703
  if (s2 !== peg$FAILED) {
3127
3704
  peg$savedPos = s0;
3128
- s0 = peg$f48(s1, s2);
3705
+ s0 = peg$f57(s1, s2);
3129
3706
  } else {
3130
3707
  peg$currPos = s0;
3131
3708
  s0 = peg$FAILED;
@@ -3158,22 +3735,115 @@ function peg$parse(input, options) {
3158
3735
  return s0;
3159
3736
  }
3160
3737
 
3738
+ function peg$parserelationalExpression() {
3739
+ var s0, s1, s2, s3, s4, s5, s6, s7;
3740
+
3741
+ s0 = peg$currPos;
3742
+ s1 = peg$parseshiftExpression();
3743
+ if (s1 !== peg$FAILED) {
3744
+ s2 = [];
3745
+ s3 = peg$currPos;
3746
+ s4 = peg$parse__();
3747
+ s5 = peg$parserelationalOperator();
3748
+ if (s5 !== peg$FAILED) {
3749
+ s6 = peg$parse__();
3750
+ s7 = peg$parseshiftExpression();
3751
+ if (s7 !== peg$FAILED) {
3752
+ s3 = [ s5, s7 ];
3753
+ } else {
3754
+ peg$currPos = s3;
3755
+ s3 = peg$FAILED;
3756
+ }
3757
+ } else {
3758
+ peg$currPos = s3;
3759
+ s3 = peg$FAILED;
3760
+ }
3761
+ while (s3 !== peg$FAILED) {
3762
+ s2.push(s3);
3763
+ s3 = peg$currPos;
3764
+ s4 = peg$parse__();
3765
+ s5 = peg$parserelationalOperator();
3766
+ if (s5 !== peg$FAILED) {
3767
+ s6 = peg$parse__();
3768
+ s7 = peg$parseshiftExpression();
3769
+ if (s7 !== peg$FAILED) {
3770
+ s3 = [ s5, s7 ];
3771
+ } else {
3772
+ peg$currPos = s3;
3773
+ s3 = peg$FAILED;
3774
+ }
3775
+ } else {
3776
+ peg$currPos = s3;
3777
+ s3 = peg$FAILED;
3778
+ }
3779
+ }
3780
+ peg$savedPos = s0;
3781
+ s0 = peg$f58(s1, s2);
3782
+ } else {
3783
+ peg$currPos = s0;
3784
+ s0 = peg$FAILED;
3785
+ }
3786
+
3787
+ return s0;
3788
+ }
3789
+
3790
+ function peg$parserelationalOperator() {
3791
+ var s0;
3792
+
3793
+ if (input.substr(peg$currPos, 2) === peg$c48) {
3794
+ s0 = peg$c48;
3795
+ peg$currPos += 2;
3796
+ } else {
3797
+ s0 = peg$FAILED;
3798
+ if (peg$silentFails === 0) { peg$fail(peg$e79); }
3799
+ }
3800
+ if (s0 === peg$FAILED) {
3801
+ if (input.charCodeAt(peg$currPos) === 60) {
3802
+ s0 = peg$c49;
3803
+ peg$currPos++;
3804
+ } else {
3805
+ s0 = peg$FAILED;
3806
+ if (peg$silentFails === 0) { peg$fail(peg$e80); }
3807
+ }
3808
+ if (s0 === peg$FAILED) {
3809
+ if (input.substr(peg$currPos, 2) === peg$c50) {
3810
+ s0 = peg$c50;
3811
+ peg$currPos += 2;
3812
+ } else {
3813
+ s0 = peg$FAILED;
3814
+ if (peg$silentFails === 0) { peg$fail(peg$e81); }
3815
+ }
3816
+ if (s0 === peg$FAILED) {
3817
+ if (input.charCodeAt(peg$currPos) === 62) {
3818
+ s0 = peg$c34;
3819
+ peg$currPos++;
3820
+ } else {
3821
+ s0 = peg$FAILED;
3822
+ if (peg$silentFails === 0) { peg$fail(peg$e49); }
3823
+ }
3824
+ }
3825
+ }
3826
+ }
3827
+
3828
+ return s0;
3829
+ }
3830
+
3161
3831
  function peg$parserootDirectory() {
3162
3832
  var s0, s1, s2, s3;
3163
3833
 
3164
3834
  s0 = peg$currPos;
3165
3835
  if (input.charCodeAt(peg$currPos) === 47) {
3166
- s1 = peg$c41;
3836
+ s1 = peg$c46;
3167
3837
  peg$currPos++;
3168
3838
  } else {
3169
3839
  s1 = peg$FAILED;
3170
- if (peg$silentFails === 0) { peg$fail(peg$e66); }
3840
+ if (peg$silentFails === 0) { peg$fail(peg$e73); }
3171
3841
  }
3172
3842
  if (s1 !== peg$FAILED) {
3173
3843
  s2 = peg$parsepathKey();
3174
3844
  if (s2 !== peg$FAILED) {
3175
3845
  peg$savedPos = s0;
3176
- s0 = peg$f49(s2);
3846
+ s0 = peg$f59(s2);
3177
3847
  } else {
3178
3848
  peg$currPos = s0;
3179
3849
  s0 = peg$FAILED;
@@ -3185,21 +3855,21 @@ function peg$parse(input, options) {
3185
3855
  if (s0 === peg$FAILED) {
3186
3856
  s0 = peg$currPos;
3187
3857
  if (input.charCodeAt(peg$currPos) === 47) {
3188
- s1 = peg$c41;
3858
+ s1 = peg$c46;
3189
3859
  peg$currPos++;
3190
3860
  } else {
3191
3861
  s1 = peg$FAILED;
3192
- if (peg$silentFails === 0) { peg$fail(peg$e66); }
3862
+ if (peg$silentFails === 0) { peg$fail(peg$e73); }
3193
3863
  }
3194
3864
  if (s1 !== peg$FAILED) {
3195
3865
  s2 = peg$currPos;
3196
3866
  peg$silentFails++;
3197
3867
  if (input.charCodeAt(peg$currPos) === 47) {
3198
- s3 = peg$c41;
3868
+ s3 = peg$c46;
3199
3869
  peg$currPos++;
3200
3870
  } else {
3201
3871
  s3 = peg$FAILED;
3202
- if (peg$silentFails === 0) { peg$fail(peg$e66); }
3872
+ if (peg$silentFails === 0) { peg$fail(peg$e73); }
3203
3873
  }
3204
3874
  peg$silentFails--;
3205
3875
  if (s3 === peg$FAILED) {
@@ -3210,7 +3880,7 @@ function peg$parse(input, options) {
3210
3880
  }
3211
3881
  if (s2 !== peg$FAILED) {
3212
3882
  peg$savedPos = s0;
3213
- s0 = peg$f50();
3883
+ s0 = peg$f60();
3214
3884
  } else {
3215
3885
  peg$currPos = s0;
3216
3886
  s0 = peg$FAILED;
@@ -3236,7 +3906,7 @@ function peg$parse(input, options) {
3236
3906
  s2 = null;
3237
3907
  }
3238
3908
  peg$savedPos = s0;
3239
- s0 = peg$f51(s1, s2);
3909
+ s0 = peg$f61(s1, s2);
3240
3910
  } else {
3241
3911
  peg$currPos = s0;
3242
3912
  s0 = peg$FAILED;
@@ -3244,7 +3914,7 @@ function peg$parse(input, options) {
3244
3914
  peg$silentFails--;
3245
3915
  if (s0 === peg$FAILED) {
3246
3916
  s1 = peg$FAILED;
3247
- if (peg$silentFails === 0) { peg$fail(peg$e72); }
3917
+ if (peg$silentFails === 0) { peg$fail(peg$e82); }
3248
3918
  }
3249
3919
 
3250
3920
  return s0;
@@ -3256,11 +3926,11 @@ function peg$parse(input, options) {
3256
3926
  s0 = peg$currPos;
3257
3927
  s1 = peg$parse__();
3258
3928
  if (input.charCodeAt(peg$currPos) === 44) {
3259
- s2 = peg$c43;
3929
+ s2 = peg$c8;
3260
3930
  peg$currPos++;
3261
3931
  } else {
3262
3932
  s2 = peg$FAILED;
3263
- if (peg$silentFails === 0) { peg$fail(peg$e73); }
3933
+ if (peg$silentFails === 0) { peg$fail(peg$e13); }
3264
3934
  }
3265
3935
  if (s2 !== peg$FAILED) {
3266
3936
  s3 = peg$parse__();
@@ -3284,11 +3954,11 @@ function peg$parse(input, options) {
3284
3954
  s1 = peg$currPos;
3285
3955
  peg$silentFails++;
3286
3956
  if (input.charCodeAt(peg$currPos) === 47) {
3287
- s2 = peg$c41;
3957
+ s2 = peg$c46;
3288
3958
  peg$currPos++;
3289
3959
  } else {
3290
3960
  s2 = peg$FAILED;
3291
- if (peg$silentFails === 0) { peg$fail(peg$e66); }
3961
+ if (peg$silentFails === 0) { peg$fail(peg$e73); }
3292
3962
  }
3293
3963
  peg$silentFails--;
3294
3964
  if (s2 !== peg$FAILED) {
@@ -3299,7 +3969,7 @@ function peg$parse(input, options) {
3299
3969
  }
3300
3970
  if (s1 !== peg$FAILED) {
3301
3971
  peg$savedPos = s0;
3302
- s1 = peg$f52();
3972
+ s1 = peg$f62();
3303
3973
  }
3304
3974
  s0 = s1;
3305
3975
 
@@ -3310,34 +3980,86 @@ function peg$parse(input, options) {
3310
3980
  var s0, s1, s2, s3;
3311
3981
 
3312
3982
  s0 = peg$currPos;
3313
- if (input.substr(peg$currPos, 2) === peg$c44) {
3314
- s1 = peg$c44;
3983
+ if (input.substr(peg$currPos, 2) === peg$c51) {
3984
+ s1 = peg$c51;
3315
3985
  peg$currPos += 2;
3316
3986
  } else {
3317
3987
  s1 = peg$FAILED;
3318
- if (peg$silentFails === 0) { peg$fail(peg$e74); }
3988
+ if (peg$silentFails === 0) { peg$fail(peg$e83); }
3319
3989
  }
3320
3990
  if (s1 !== peg$FAILED) {
3321
3991
  s2 = [];
3322
3992
  s3 = input.charAt(peg$currPos);
3323
- if (peg$r5.test(s3)) {
3993
+ if (peg$r7.test(s3)) {
3324
3994
  peg$currPos++;
3325
3995
  } else {
3326
3996
  s3 = peg$FAILED;
3327
- if (peg$silentFails === 0) { peg$fail(peg$e75); }
3997
+ if (peg$silentFails === 0) { peg$fail(peg$e84); }
3328
3998
  }
3329
3999
  while (s3 !== peg$FAILED) {
3330
4000
  s2.push(s3);
3331
4001
  s3 = input.charAt(peg$currPos);
3332
- if (peg$r5.test(s3)) {
4002
+ if (peg$r7.test(s3)) {
3333
4003
  peg$currPos++;
3334
4004
  } else {
3335
4005
  s3 = peg$FAILED;
3336
- if (peg$silentFails === 0) { peg$fail(peg$e75); }
4006
+ if (peg$silentFails === 0) { peg$fail(peg$e84); }
4007
+ }
4008
+ }
4009
+ peg$savedPos = s0;
4010
+ s0 = peg$f63();
4011
+ } else {
4012
+ peg$currPos = s0;
4013
+ s0 = peg$FAILED;
4014
+ }
4015
+
4016
+ return s0;
4017
+ }
4018
+
4019
+ function peg$parseshiftExpression() {
4020
+ var s0, s1, s2, s3, s4, s5, s6, s7;
4021
+
4022
+ s0 = peg$currPos;
4023
+ s1 = peg$parseadditiveExpression();
4024
+ if (s1 !== peg$FAILED) {
4025
+ s2 = [];
4026
+ s3 = peg$currPos;
4027
+ s4 = peg$parse__();
4028
+ s5 = peg$parseshiftOperator();
4029
+ if (s5 !== peg$FAILED) {
4030
+ s6 = peg$parse__();
4031
+ s7 = peg$parseadditiveExpression();
4032
+ if (s7 !== peg$FAILED) {
4033
+ s3 = [ s5, s7 ];
4034
+ } else {
4035
+ peg$currPos = s3;
4036
+ s3 = peg$FAILED;
4037
+ }
4038
+ } else {
4039
+ peg$currPos = s3;
4040
+ s3 = peg$FAILED;
4041
+ }
4042
+ while (s3 !== peg$FAILED) {
4043
+ s2.push(s3);
4044
+ s3 = peg$currPos;
4045
+ s4 = peg$parse__();
4046
+ s5 = peg$parseshiftOperator();
4047
+ if (s5 !== peg$FAILED) {
4048
+ s6 = peg$parse__();
4049
+ s7 = peg$parseadditiveExpression();
4050
+ if (s7 !== peg$FAILED) {
4051
+ s3 = [ s5, s7 ];
4052
+ } else {
4053
+ peg$currPos = s3;
4054
+ s3 = peg$FAILED;
4055
+ }
4056
+ } else {
4057
+ peg$currPos = s3;
4058
+ s3 = peg$FAILED;
3337
4059
  }
3338
4060
  }
3339
4061
  peg$savedPos = s0;
3340
- s0 = peg$f53();
4062
+ s0 = peg$f64(s1, s2);
3341
4063
  } else {
3342
4064
  peg$currPos = s0;
3343
4065
  s0 = peg$FAILED;
@@ -3346,27 +4068,59 @@ function peg$parse(input, options) {
3346
4068
  return s0;
3347
4069
  }
3348
4070
 
4071
+ function peg$parseshiftOperator() {
4072
+ var s0;
4073
+
4074
+ if (input.substr(peg$currPos, 2) === peg$c52) {
4075
+ s0 = peg$c52;
4076
+ peg$currPos += 2;
4077
+ } else {
4078
+ s0 = peg$FAILED;
4079
+ if (peg$silentFails === 0) { peg$fail(peg$e85); }
4080
+ }
4081
+ if (s0 === peg$FAILED) {
4082
+ if (input.substr(peg$currPos, 3) === peg$c53) {
4083
+ s0 = peg$c53;
4084
+ peg$currPos += 3;
4085
+ } else {
4086
+ s0 = peg$FAILED;
4087
+ if (peg$silentFails === 0) { peg$fail(peg$e86); }
4088
+ }
4089
+ if (s0 === peg$FAILED) {
4090
+ if (input.substr(peg$currPos, 2) === peg$c54) {
4091
+ s0 = peg$c54;
4092
+ peg$currPos += 2;
4093
+ } else {
4094
+ s0 = peg$FAILED;
4095
+ if (peg$silentFails === 0) { peg$fail(peg$e87); }
4096
+ }
4097
+ }
4098
+ }
4099
+
4100
+ return s0;
4101
+ }
4102
+
3349
4103
  function peg$parseshorthandFunction() {
3350
4104
  var s0, s1, s2, s3, s4;
3351
4105
 
3352
4106
  peg$silentFails++;
3353
4107
  s0 = peg$currPos;
3354
4108
  if (input.charCodeAt(peg$currPos) === 61) {
3355
- s1 = peg$c40;
4109
+ s1 = peg$c45;
3356
4110
  peg$currPos++;
3357
4111
  } else {
3358
4112
  s1 = peg$FAILED;
3359
- if (peg$silentFails === 0) { peg$fail(peg$e62); }
4113
+ if (peg$silentFails === 0) { peg$fail(peg$e69); }
3360
4114
  }
3361
4115
  if (s1 !== peg$FAILED) {
3362
4116
  s2 = peg$currPos;
3363
4117
  peg$silentFails++;
3364
4118
  if (input.charCodeAt(peg$currPos) === 61) {
3365
- s3 = peg$c40;
4119
+ s3 = peg$c45;
3366
4120
  peg$currPos++;
3367
4121
  } else {
3368
4122
  s3 = peg$FAILED;
3369
- if (peg$silentFails === 0) { peg$fail(peg$e62); }
4123
+ if (peg$silentFails === 0) { peg$fail(peg$e69); }
3370
4124
  }
3371
4125
  peg$silentFails--;
3372
4126
  if (s3 === peg$FAILED) {
@@ -3380,7 +4134,7 @@ function peg$parse(input, options) {
3380
4134
  s4 = peg$parseimplicitParenthesesCallExpression();
3381
4135
  if (s4 !== peg$FAILED) {
3382
4136
  peg$savedPos = s0;
3383
- s0 = peg$f54(s4);
4137
+ s0 = peg$f65(s4);
3384
4138
  } else {
3385
4139
  peg$currPos = s0;
3386
4140
  s0 = peg$FAILED;
@@ -3399,21 +4153,7 @@ function peg$parse(input, options) {
3399
4153
  peg$silentFails--;
3400
4154
  if (s0 === peg$FAILED) {
3401
4155
  s1 = peg$FAILED;
3402
- if (peg$silentFails === 0) { peg$fail(peg$e76); }
3403
- }
3404
-
3405
- return s0;
3406
- }
3407
-
3408
- function peg$parsesign() {
3409
- var s0;
3410
-
3411
- s0 = input.charAt(peg$currPos);
3412
- if (peg$r6.test(s0)) {
3413
- peg$currPos++;
3414
- } else {
3415
- s0 = peg$FAILED;
3416
- if (peg$silentFails === 0) { peg$fail(peg$e77); }
4156
+ if (peg$silentFails === 0) { peg$fail(peg$e88); }
3417
4157
  }
3418
4158
 
3419
4159
  return s0;
@@ -3423,19 +4163,19 @@ function peg$parse(input, options) {
3423
4163
  var s0;
3424
4164
 
3425
4165
  if (input.charCodeAt(peg$currPos) === 8594) {
3426
- s0 = peg$c45;
4166
+ s0 = peg$c55;
3427
4167
  peg$currPos++;
3428
4168
  } else {
3429
4169
  s0 = peg$FAILED;
3430
- if (peg$silentFails === 0) { peg$fail(peg$e78); }
4170
+ if (peg$silentFails === 0) { peg$fail(peg$e89); }
3431
4171
  }
3432
4172
  if (s0 === peg$FAILED) {
3433
- if (input.substr(peg$currPos, 2) === peg$c46) {
3434
- s0 = peg$c46;
4173
+ if (input.substr(peg$currPos, 2) === peg$c56) {
4174
+ s0 = peg$c56;
3435
4175
  peg$currPos += 2;
3436
4176
  } else {
3437
4177
  s0 = peg$FAILED;
3438
- if (peg$silentFails === 0) { peg$fail(peg$e79); }
4178
+ if (peg$silentFails === 0) { peg$fail(peg$e90); }
3439
4179
  }
3440
4180
  }
3441
4181
 
@@ -3446,34 +4186,34 @@ function peg$parse(input, options) {
3446
4186
  var s0, s1, s2, s3;
3447
4187
 
3448
4188
  s0 = peg$currPos;
3449
- if (input.substr(peg$currPos, 2) === peg$c42) {
3450
- s1 = peg$c42;
4189
+ if (input.substr(peg$currPos, 2) === peg$c47) {
4190
+ s1 = peg$c47;
3451
4191
  peg$currPos += 2;
3452
4192
  } else {
3453
4193
  s1 = peg$FAILED;
3454
- if (peg$silentFails === 0) { peg$fail(peg$e71); }
4194
+ if (peg$silentFails === 0) { peg$fail(peg$e78); }
3455
4195
  }
3456
4196
  if (s1 !== peg$FAILED) {
3457
4197
  s2 = [];
3458
4198
  s3 = input.charAt(peg$currPos);
3459
- if (peg$r5.test(s3)) {
4199
+ if (peg$r7.test(s3)) {
3460
4200
  peg$currPos++;
3461
4201
  } else {
3462
4202
  s3 = peg$FAILED;
3463
- if (peg$silentFails === 0) { peg$fail(peg$e75); }
4203
+ if (peg$silentFails === 0) { peg$fail(peg$e84); }
3464
4204
  }
3465
4205
  while (s3 !== peg$FAILED) {
3466
4206
  s2.push(s3);
3467
4207
  s3 = input.charAt(peg$currPos);
3468
- if (peg$r5.test(s3)) {
4208
+ if (peg$r7.test(s3)) {
3469
4209
  peg$currPos++;
3470
4210
  } else {
3471
4211
  s3 = peg$FAILED;
3472
- if (peg$silentFails === 0) { peg$fail(peg$e75); }
4212
+ if (peg$silentFails === 0) { peg$fail(peg$e84); }
3473
4213
  }
3474
4214
  }
3475
4215
  peg$savedPos = s0;
3476
- s0 = peg$f55();
4216
+ s0 = peg$f66();
3477
4217
  } else {
3478
4218
  peg$currPos = s0;
3479
4219
  s0 = peg$FAILED;
@@ -3488,11 +4228,11 @@ function peg$parse(input, options) {
3488
4228
  peg$silentFails++;
3489
4229
  s0 = peg$currPos;
3490
4230
  if (input.charCodeAt(peg$currPos) === 39) {
3491
- s1 = peg$c47;
4231
+ s1 = peg$c57;
3492
4232
  peg$currPos++;
3493
4233
  } else {
3494
4234
  s1 = peg$FAILED;
3495
- if (peg$silentFails === 0) { peg$fail(peg$e81); }
4235
+ if (peg$silentFails === 0) { peg$fail(peg$e92); }
3496
4236
  }
3497
4237
  if (s1 !== peg$FAILED) {
3498
4238
  s2 = [];
@@ -3502,15 +4242,15 @@ function peg$parse(input, options) {
3502
4242
  s3 = peg$parsesingleQuoteStringChar();
3503
4243
  }
3504
4244
  if (input.charCodeAt(peg$currPos) === 39) {
3505
- s3 = peg$c47;
4245
+ s3 = peg$c57;
3506
4246
  peg$currPos++;
3507
4247
  } else {
3508
4248
  s3 = peg$FAILED;
3509
- if (peg$silentFails === 0) { peg$fail(peg$e81); }
4249
+ if (peg$silentFails === 0) { peg$fail(peg$e92); }
3510
4250
  }
3511
4251
  if (s3 !== peg$FAILED) {
3512
4252
  peg$savedPos = s0;
3513
- s0 = peg$f56(s2);
4253
+ s0 = peg$f67(s2);
3514
4254
  } else {
3515
4255
  peg$currPos = s0;
3516
4256
  s0 = peg$FAILED;
@@ -3522,7 +4262,7 @@ function peg$parse(input, options) {
3522
4262
  peg$silentFails--;
3523
4263
  if (s0 === peg$FAILED) {
3524
4264
  s1 = peg$FAILED;
3525
- if (peg$silentFails === 0) { peg$fail(peg$e80); }
4265
+ if (peg$silentFails === 0) { peg$fail(peg$e91); }
3526
4266
  }
3527
4267
 
3528
4268
  return s0;
@@ -3535,11 +4275,11 @@ function peg$parse(input, options) {
3535
4275
  s1 = peg$currPos;
3536
4276
  peg$silentFails++;
3537
4277
  if (input.charCodeAt(peg$currPos) === 39) {
3538
- s2 = peg$c47;
4278
+ s2 = peg$c57;
3539
4279
  peg$currPos++;
3540
4280
  } else {
3541
4281
  s2 = peg$FAILED;
3542
- if (peg$silentFails === 0) { peg$fail(peg$e81); }
4282
+ if (peg$silentFails === 0) { peg$fail(peg$e92); }
3543
4283
  }
3544
4284
  if (s2 === peg$FAILED) {
3545
4285
  s2 = peg$parsenewLine();
@@ -3577,7 +4317,7 @@ function peg$parse(input, options) {
3577
4317
  s3 = peg$parseconditionalExpression();
3578
4318
  if (s3 !== peg$FAILED) {
3579
4319
  peg$savedPos = s0;
3580
- s0 = peg$f57(s3);
4320
+ s0 = peg$f68(s3);
3581
4321
  } else {
3582
4322
  peg$currPos = s0;
3583
4323
  s0 = peg$FAILED;
@@ -3604,7 +4344,7 @@ function peg$parse(input, options) {
3604
4344
  peg$silentFails--;
3605
4345
  if (s0 === peg$FAILED) {
3606
4346
  s1 = peg$FAILED;
3607
- if (peg$silentFails === 0) { peg$fail(peg$e82); }
4347
+ if (peg$silentFails === 0) { peg$fail(peg$e93); }
3608
4348
  }
3609
4349
 
3610
4350
  return s0;
@@ -3617,11 +4357,11 @@ function peg$parse(input, options) {
3617
4357
  s0 = peg$currPos;
3618
4358
  s1 = peg$parsetemplateDocumentContents();
3619
4359
  peg$savedPos = s0;
3620
- s1 = peg$f58(s1);
4360
+ s1 = peg$f69(s1);
3621
4361
  s0 = s1;
3622
4362
  peg$silentFails--;
3623
4363
  s1 = peg$FAILED;
3624
- if (peg$silentFails === 0) { peg$fail(peg$e83); }
4364
+ if (peg$silentFails === 0) { peg$fail(peg$e94); }
3625
4365
 
3626
4366
  return s0;
3627
4367
  }
@@ -3632,12 +4372,12 @@ function peg$parse(input, options) {
3632
4372
  s0 = peg$currPos;
3633
4373
  s1 = peg$currPos;
3634
4374
  peg$silentFails++;
3635
- if (input.substr(peg$currPos, 2) === peg$c48) {
3636
- s2 = peg$c48;
4375
+ if (input.substr(peg$currPos, 2) === peg$c58) {
4376
+ s2 = peg$c58;
3637
4377
  peg$currPos += 2;
3638
4378
  } else {
3639
4379
  s2 = peg$FAILED;
3640
- if (peg$silentFails === 0) { peg$fail(peg$e84); }
4380
+ if (peg$silentFails === 0) { peg$fail(peg$e95); }
3641
4381
  }
3642
4382
  peg$silentFails--;
3643
4383
  if (s2 === peg$FAILED) {
@@ -3692,7 +4432,7 @@ function peg$parse(input, options) {
3692
4432
  }
3693
4433
  }
3694
4434
  peg$savedPos = s0;
3695
- s0 = peg$f59(s1, s2);
4435
+ s0 = peg$f70(s1, s2);
3696
4436
 
3697
4437
  return s0;
3698
4438
  }
@@ -3709,11 +4449,11 @@ function peg$parse(input, options) {
3709
4449
  s2 = peg$parsetemplateDocumentChar();
3710
4450
  }
3711
4451
  peg$savedPos = s0;
3712
- s1 = peg$f60(s1);
4452
+ s1 = peg$f71(s1);
3713
4453
  s0 = s1;
3714
4454
  peg$silentFails--;
3715
4455
  s1 = peg$FAILED;
3716
- if (peg$silentFails === 0) { peg$fail(peg$e85); }
4456
+ if (peg$silentFails === 0) { peg$fail(peg$e96); }
3717
4457
 
3718
4458
  return s0;
3719
4459
  }
@@ -3724,24 +4464,24 @@ function peg$parse(input, options) {
3724
4464
  peg$silentFails++;
3725
4465
  s0 = peg$currPos;
3726
4466
  if (input.charCodeAt(peg$currPos) === 96) {
3727
- s1 = peg$c49;
4467
+ s1 = peg$c59;
3728
4468
  peg$currPos++;
3729
4469
  } else {
3730
4470
  s1 = peg$FAILED;
3731
- if (peg$silentFails === 0) { peg$fail(peg$e87); }
4471
+ if (peg$silentFails === 0) { peg$fail(peg$e98); }
3732
4472
  }
3733
4473
  if (s1 !== peg$FAILED) {
3734
4474
  s2 = peg$parsetemplateLiteralContents();
3735
4475
  if (input.charCodeAt(peg$currPos) === 96) {
3736
- s3 = peg$c49;
4476
+ s3 = peg$c59;
3737
4477
  peg$currPos++;
3738
4478
  } else {
3739
4479
  s3 = peg$FAILED;
3740
- if (peg$silentFails === 0) { peg$fail(peg$e87); }
4480
+ if (peg$silentFails === 0) { peg$fail(peg$e98); }
3741
4481
  }
3742
4482
  if (s3 !== peg$FAILED) {
3743
4483
  peg$savedPos = s0;
3744
- s0 = peg$f61(s2);
4484
+ s0 = peg$f72(s2);
3745
4485
  } else {
3746
4486
  peg$currPos = s0;
3747
4487
  s0 = peg$FAILED;
@@ -3753,7 +4493,7 @@ function peg$parse(input, options) {
3753
4493
  peg$silentFails--;
3754
4494
  if (s0 === peg$FAILED) {
3755
4495
  s1 = peg$FAILED;
3756
- if (peg$silentFails === 0) { peg$fail(peg$e86); }
4496
+ if (peg$silentFails === 0) { peg$fail(peg$e97); }
3757
4497
  }
3758
4498
 
3759
4499
  return s0;
@@ -3766,19 +4506,19 @@ function peg$parse(input, options) {
3766
4506
  s1 = peg$currPos;
3767
4507
  peg$silentFails++;
3768
4508
  if (input.charCodeAt(peg$currPos) === 96) {
3769
- s2 = peg$c49;
4509
+ s2 = peg$c59;
3770
4510
  peg$currPos++;
3771
4511
  } else {
3772
4512
  s2 = peg$FAILED;
3773
- if (peg$silentFails === 0) { peg$fail(peg$e87); }
4513
+ if (peg$silentFails === 0) { peg$fail(peg$e98); }
3774
4514
  }
3775
4515
  if (s2 === peg$FAILED) {
3776
- if (input.substr(peg$currPos, 2) === peg$c48) {
3777
- s2 = peg$c48;
4516
+ if (input.substr(peg$currPos, 2) === peg$c58) {
4517
+ s2 = peg$c58;
3778
4518
  peg$currPos += 2;
3779
4519
  } else {
3780
4520
  s2 = peg$FAILED;
3781
- if (peg$silentFails === 0) { peg$fail(peg$e84); }
4521
+ if (peg$silentFails === 0) { peg$fail(peg$e95); }
3782
4522
  }
3783
4523
  }
3784
4524
  peg$silentFails--;
@@ -3850,7 +4590,7 @@ function peg$parse(input, options) {
3850
4590
  s2 = peg$parsetemplateLiteralChar();
3851
4591
  }
3852
4592
  peg$savedPos = s0;
3853
- s1 = peg$f62(s1);
4593
+ s1 = peg$f73(s1);
3854
4594
  s0 = s1;
3855
4595
 
3856
4596
  return s0;
@@ -3861,26 +4601,26 @@ function peg$parse(input, options) {
3861
4601
 
3862
4602
  peg$silentFails++;
3863
4603
  s0 = peg$currPos;
3864
- if (input.substr(peg$currPos, 2) === peg$c48) {
3865
- s1 = peg$c48;
4604
+ if (input.substr(peg$currPos, 2) === peg$c58) {
4605
+ s1 = peg$c58;
3866
4606
  peg$currPos += 2;
3867
4607
  } else {
3868
4608
  s1 = peg$FAILED;
3869
- if (peg$silentFails === 0) { peg$fail(peg$e84); }
4609
+ if (peg$silentFails === 0) { peg$fail(peg$e95); }
3870
4610
  }
3871
4611
  if (s1 !== peg$FAILED) {
3872
4612
  s2 = peg$parseexpression();
3873
4613
  if (s2 !== peg$FAILED) {
3874
4614
  if (input.charCodeAt(peg$currPos) === 125) {
3875
- s3 = peg$c3;
4615
+ s3 = peg$c7;
3876
4616
  peg$currPos++;
3877
4617
  } else {
3878
4618
  s3 = peg$FAILED;
3879
- if (peg$silentFails === 0) { peg$fail(peg$e6); }
4619
+ if (peg$silentFails === 0) { peg$fail(peg$e11); }
3880
4620
  }
3881
4621
  if (s3 !== peg$FAILED) {
3882
4622
  peg$savedPos = s0;
3883
- s0 = peg$f63(s2);
4623
+ s0 = peg$f74(s2);
3884
4624
  } else {
3885
4625
  peg$currPos = s0;
3886
4626
  s0 = peg$FAILED;
@@ -3896,7 +4636,7 @@ function peg$parse(input, options) {
3896
4636
  peg$silentFails--;
3897
4637
  if (s0 === peg$FAILED) {
3898
4638
  s1 = peg$FAILED;
3899
- if (peg$silentFails === 0) { peg$fail(peg$e88); }
4639
+ if (peg$silentFails === 0) { peg$fail(peg$e99); }
3900
4640
  }
3901
4641
 
3902
4642
  return s0;
@@ -3912,7 +4652,7 @@ function peg$parse(input, options) {
3912
4652
  peg$currPos++;
3913
4653
  } else {
3914
4654
  s0 = peg$FAILED;
3915
- if (peg$silentFails === 0) { peg$fail(peg$e7); }
4655
+ if (peg$silentFails === 0) { peg$fail(peg$e12); }
3916
4656
  }
3917
4657
  }
3918
4658
 
@@ -3929,7 +4669,7 @@ function peg$parse(input, options) {
3929
4669
  s3 = peg$parseunaryExpression();
3930
4670
  if (s3 !== peg$FAILED) {
3931
4671
  peg$savedPos = s0;
3932
- s0 = peg$f64(s1, s3);
4672
+ s0 = peg$f75(s1, s3);
3933
4673
  } else {
3934
4674
  peg$currPos = s0;
3935
4675
  s0 = peg$FAILED;
@@ -3948,12 +4688,12 @@ function peg$parse(input, options) {
3948
4688
  function peg$parseunaryOperator() {
3949
4689
  var s0;
3950
4690
 
3951
- if (input.charCodeAt(peg$currPos) === 33) {
3952
- s0 = peg$c50;
4691
+ s0 = input.charAt(peg$currPos);
4692
+ if (peg$r8.test(s0)) {
3953
4693
  peg$currPos++;
3954
4694
  } else {
3955
4695
  s0 = peg$FAILED;
3956
- if (peg$silentFails === 0) { peg$fail(peg$e89); }
4696
+ if (peg$silentFails === 0) { peg$fail(peg$e100); }
3957
4697
  }
3958
4698
 
3959
4699
  return s0;
@@ -4016,15 +4756,24 @@ function peg$parse(input, options) {
4016
4756
 
4017
4757
  const peg$allowedStartRules = [
4018
4758
  "__",
4759
+ "additiveExpression",
4760
+ "additiveOperator",
4019
4761
  "arguments",
4020
4762
  "arrayLiteral",
4021
4763
  "arrayEntries",
4022
4764
  "arrayEntry",
4023
4765
  "arrowFunction",
4766
+ "bitwiseAndExpression",
4767
+ "bitwiseAndOperator",
4768
+ "bitwiseOrExpression",
4769
+ "bitwiseOrOperator",
4770
+ "bitwiseXorExpression",
4771
+ "bitwiseXorOperator",
4024
4772
  "callExpression",
4025
4773
  "closingBrace",
4026
4774
  "closingBracket",
4027
4775
  "closingParenthesis",
4776
+ "commaExpression",
4028
4777
  "comment",
4029
4778
  "conditionalExpression",
4030
4779
  "digits",
@@ -4035,6 +4784,7 @@ const peg$allowedStartRules = [
4035
4784
  "equalityExpression",
4036
4785
  "equalityOperator",
4037
4786
  "escapedChar",
4787
+ "exponentiationExpression",
4038
4788
  "expression",
4039
4789
  "floatLiteral",
4040
4790
  "group",
@@ -4054,6 +4804,8 @@ const peg$allowedStartRules = [
4054
4804
  "logicalAndExpression",
4055
4805
  "logicalOrExpression",
4056
4806
  "multiLineComment",
4807
+ "multiplicativeExpression",
4808
+ "multiplicativeOperator",
4057
4809
  "namespace",
4058
4810
  "newLine",
4059
4811
  "numericLiteral",
@@ -4079,13 +4831,16 @@ const peg$allowedStartRules = [
4079
4831
  "protocolExpression",
4080
4832
  "qualifiedReference",
4081
4833
  "reference",
4834
+ "relationalExpression",
4835
+ "relationalOperator",
4082
4836
  "rootDirectory",
4083
4837
  "scopeReference",
4084
4838
  "separator",
4085
4839
  "slashFollows",
4086
4840
  "shebang",
4841
+ "shiftExpression",
4842
+ "shiftOperator",
4087
4843
  "shorthandFunction",
4088
- "sign",
4089
4844
  "singleArrow",
4090
4845
  "singleLineComment",
4091
4846
  "singleQuoteString",