@weborigami/language 0.3.3-jse.3 → 0.3.3

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 (29) hide show
  1. package/main.js +1 -3
  2. package/package.json +3 -3
  3. package/src/compiler/compile.js +2 -10
  4. package/src/compiler/optimize.js +93 -147
  5. package/src/compiler/origami.pegjs +67 -171
  6. package/src/compiler/parse.js +946 -1810
  7. package/src/compiler/parserHelpers.js +58 -159
  8. package/src/runtime/HandleExtensionsTransform.js +1 -10
  9. package/src/runtime/evaluate.js +35 -28
  10. package/src/runtime/expressionObject.js +4 -4
  11. package/src/runtime/handlers.js +54 -18
  12. package/src/runtime/mergeTrees.js +5 -0
  13. package/src/runtime/ops.js +156 -101
  14. package/src/runtime/symbols.js +0 -1
  15. package/src/runtime/{templateIndent.js → taggedTemplateIndent.js} +2 -2
  16. package/test/compiler/codeHelpers.js +1 -3
  17. package/test/compiler/compile.test.js +27 -52
  18. package/test/compiler/optimize.test.js +23 -92
  19. package/test/compiler/parse.test.js +342 -574
  20. package/test/runtime/evaluate.test.js +20 -4
  21. package/test/runtime/expressionObject.test.js +4 -5
  22. package/test/runtime/handlers.test.js +10 -19
  23. package/test/runtime/mergeTrees.test.js +5 -0
  24. package/test/runtime/ops.test.js +82 -103
  25. package/test/runtime/taggedTemplateIndent.test.js +1 -1
  26. package/src/runtime/getHandlers.js +0 -10
  27. package/src/runtime/jsGlobals.js +0 -99
  28. package/src/runtime/templateStandard.js +0 -13
  29. package/test/runtime/templateText.test.js +0 -18
package/src/compiler/parse.js CHANGED
@@ -25,15 +25,14 @@ import {
25
25
  makeBinaryOperation,
26
26
  makeCall,
27
27
  makeDeferredArguments,
28
- makeDocument,
29
28
  makeJsPropertyAccess,
30
29
  makeObject,
31
30
  makePipeline,
32
31
  makeProperty,
32
+ makeReference,
33
33
  makeTemplate,
34
34
  makeUnaryOperation,
35
- makeYamlObject,
36
- markers,
35
+ makeYamlObject
37
36
  } from "./parserHelpers.js";
38
37
  import isOrigamiFrontMatter from "./isOrigamiFrontMatter.js";
39
38
 
@@ -207,200 +206,185 @@ function peg$parse(input, options) {
207
206
  var peg$FAILED = {};
208
207
  var peg$source = options.grammarSource;
209
208
 
210
- var peg$startRuleFunctions = { __: peg$parse__, additiveExpression: peg$parseadditiveExpression, additiveOperator: peg$parseadditiveOperator, angleBracketLiteral: peg$parseangleBracketLiteral, angleBracketPath: peg$parseangleBracketPath, angleBracketPathKey: peg$parseangleBracketPathKey, angleBracketPathChar: peg$parseangleBracketPathChar, angleBracketProtocol: peg$parseangleBracketProtocol, 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, commaExpression: peg$parsecommaExpression, comment: peg$parsecomment, computedPropertyAccess: peg$parsecomputedPropertyAccess, 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, expectBacktick: peg$parseexpectBacktick, expectClosingBrace: peg$parseexpectClosingBrace, expectClosingBracket: peg$parseexpectClosingBracket, expectClosingParenthesis: peg$parseexpectClosingParenthesis, expectDoubleQuote: peg$parseexpectDoubleQuote, expectExpression: peg$parseexpectExpression, expectFrontDelimiter: peg$parseexpectFrontDelimiter, expectGuillemet: peg$parseexpectGuillemet, expectSingleQuote: peg$parseexpectSingleQuote, expectPipelineExpression: peg$parseexpectPipelineExpression, exponentiationExpression: peg$parseexponentiationExpression, expression: peg$parseexpression, floatLiteral: peg$parsefloatLiteral, frontDelimiter: peg$parsefrontDelimiter, frontMatterExpression: peg$parsefrontMatterExpression, frontMatterText: peg$parsefrontMatterText, frontMatterYaml: peg$parsefrontMatterYaml, group: peg$parsegroup, guillemetString: peg$parseguillemetString, guillemetStringChar: peg$parseguillemetStringChar, homeDirectory: peg$parsehomeDirectory, host: peg$parsehost, identifier: peg$parseidentifier, identifierChar: peg$parseidentifierChar, implicitParenthesesCallExpression: peg$parseimplicitParenthesesCallExpression, implicitParensthesesArguments: peg$parseimplicitParensthesesArguments, inlineSpace: peg$parseinlineSpace, integerLiteral: peg$parseintegerLiteral, jseMode: peg$parsejseMode, jsIdentifier: peg$parsejsIdentifier, jsIdentifierPart: peg$parsejsIdentifierPart, jsIdentifierStart: peg$parsejsIdentifierStart, jsPropertyAccess: peg$parsejsPropertyAccess, jsReference: peg$parsejsReference, list: peg$parselist, logicalAndExpression: peg$parselogicalAndExpression, logicalOrExpression: peg$parselogicalOrExpression, multiLineComment: peg$parsemultiLineComment, multiplicativeExpression: peg$parsemultiplicativeExpression, multiplicativeOperator: peg$parsemultiplicativeOperator, namespace: peg$parsenamespace, newExpression: peg$parsenewExpression, 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, optionalChaining: peg$parseoptionalChaining, parameter: peg$parseparameter, parameterList: peg$parseparameterList, parameterSingleton: peg$parseparameterSingleton, parenthesesArguments: peg$parseparenthesesArguments, path: peg$parsepath, pathArguments: peg$parsepathArguments, pathKey: peg$parsepathKey, pathSegment: peg$parsepathSegment, pathSegmentChar: peg$parsepathSegmentChar, pipelineExpression: peg$parsepipelineExpression, primary: peg$parseprimary, primaryJse: peg$parseprimaryJse, primaryShell: peg$parseprimaryShell, program: peg$parseprogram, protocolExpression: peg$parseprotocolExpression, qualifiedReference: peg$parsequalifiedReference, regexFlags: peg$parseregexFlags, regexLiteral: peg$parseregexLiteral, regexLiteralChar: peg$parseregexLiteralChar, relationalExpression: peg$parserelationalExpression, relationalOperator: peg$parserelationalOperator, rootDirectory: peg$parserootDirectory, scopeReference: peg$parsescopeReference, separator: peg$parseseparator, shebang: peg$parseshebang, shellMode: peg$parseshellMode, shiftExpression: peg$parseshiftExpression, shiftOperator: peg$parseshiftOperator, shorthandFunction: peg$parseshorthandFunction, singleArrow: peg$parsesingleArrow, singleLineComment: peg$parsesingleLineComment, singleQuoteString: peg$parsesingleQuoteString, singleQuoteStringChar: peg$parsesingleQuoteStringChar, slash: peg$parseslash, slashFollows: peg$parseslashFollows, spreadElement: peg$parsespreadElement, stringLiteral: peg$parsestringLiteral, templateBody: peg$parsetemplateBody, templateBodyChar: peg$parsetemplateBodyChar, templateBodyText: peg$parsetemplateBodyText, templateDocument: peg$parsetemplateDocument, templateLiteral: peg$parsetemplateLiteral, templateLiteralChar: peg$parsetemplateLiteralChar, templateLiteralText: peg$parsetemplateLiteralText, templateSubstitution: peg$parsetemplateSubstitution, textChar: peg$parsetextChar, unaryExpression: peg$parseunaryExpression, unaryOperator: peg$parseunaryOperator, whitespace: peg$parsewhitespace, whitespaceShell: peg$parsewhitespaceShell, whitespaceWithNewLine: peg$parsewhitespaceWithNewLine };
209
+ 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, commaExpression: peg$parsecommaExpression, comment: peg$parsecomment, computedPropertyAccess: peg$parsecomputedPropertyAccess, 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, expectBacktick: peg$parseexpectBacktick, expectClosingBrace: peg$parseexpectClosingBrace, expectClosingBracket: peg$parseexpectClosingBracket, expectClosingParenthesis: peg$parseexpectClosingParenthesis, expectDoubleQuote: peg$parseexpectDoubleQuote, expectExpression: peg$parseexpectExpression, expectFrontDelimiter: peg$parseexpectFrontDelimiter, expectGuillemet: peg$parseexpectGuillemet, expectSingleQuote: peg$parseexpectSingleQuote, expectPipelineExpression: peg$parseexpectPipelineExpression, exponentiationExpression: peg$parseexponentiationExpression, expression: peg$parseexpression, floatLiteral: peg$parsefloatLiteral, frontDelimiter: peg$parsefrontDelimiter, frontMatterExpression: peg$parsefrontMatterExpression, frontMatterText: peg$parsefrontMatterText, frontMatterYaml: peg$parsefrontMatterYaml, group: peg$parsegroup, guillemetString: peg$parseguillemetString, guillemetStringChar: peg$parseguillemetStringChar, homeDirectory: peg$parsehomeDirectory, host: peg$parsehost, identifier: peg$parseidentifier, identifierChar: peg$parseidentifierChar, implicitParenthesesCallExpression: peg$parseimplicitParenthesesCallExpression, implicitParensthesesArguments: peg$parseimplicitParensthesesArguments, inherited: peg$parseinherited, inlineSpace: peg$parseinlineSpace, integerLiteral: peg$parseintegerLiteral, jsIdentifier: peg$parsejsIdentifier, jsIdentifierPart: peg$parsejsIdentifierPart, jsIdentifierStart: peg$parsejsIdentifierStart, jsPropertyAccess: peg$parsejsPropertyAccess, 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, parameter: peg$parseparameter, parameterList: peg$parseparameterList, parameterSingleton: peg$parseparameterSingleton, 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, relationalExpression: peg$parserelationalExpression, relationalOperator: peg$parserelationalOperator, rootDirectory: peg$parserootDirectory, scopeReference: peg$parsescopeReference, separator: peg$parseseparator, shebang: peg$parseshebang, shiftExpression: peg$parseshiftExpression, shiftOperator: peg$parseshiftOperator, shorthandFunction: peg$parseshorthandFunction, singleArrow: peg$parsesingleArrow, singleLineComment: peg$parsesingleLineComment, singleQuoteString: peg$parsesingleQuoteString, singleQuoteStringChar: peg$parsesingleQuoteStringChar, slash: peg$parseslash, slashFollows: peg$parseslashFollows, spreadElement: peg$parsespreadElement, stringLiteral: peg$parsestringLiteral, templateBody: peg$parsetemplateBody, templateBodyChar: peg$parsetemplateBodyChar, templateBodyText: peg$parsetemplateBodyText, templateDocument: peg$parsetemplateDocument, templateLiteral: peg$parsetemplateLiteral, templateLiteralChar: peg$parsetemplateLiteralChar, templateLiteralText: peg$parsetemplateLiteralText, templateSubstitution: peg$parsetemplateSubstitution, textChar: peg$parsetextChar, unaryExpression: peg$parseunaryExpression, unaryOperator: peg$parseunaryOperator, whitespace: peg$parsewhitespace, whitespaceWithNewLine: peg$parsewhitespaceWithNewLine };
211
210
  var peg$startRuleFunction = peg$parse__;
212
211
 
213
- var peg$c0 = "<";
214
- var peg$c1 = "//";
215
- var peg$c2 = ">";
216
- var peg$c3 = "/";
217
- var peg$c4 = "~";
218
- var peg$c5 = ":";
219
- var peg$c6 = "[";
220
- var peg$c7 = "]";
221
- var peg$c8 = "(";
222
- var peg$c9 = ")";
223
- var peg$c10 = "&";
224
- var peg$c11 = "|";
225
- var peg$c12 = "^";
226
- var peg$c13 = ",";
227
- var peg$c14 = "?";
228
- var peg$c15 = "\u21D2";
229
- var peg$c16 = "=>";
230
- var peg$c17 = "\"";
231
- var peg$c18 = "...";
232
- var peg$c19 = "\u2026";
233
- var peg$c20 = "===";
234
- var peg$c21 = "!==";
235
- var peg$c22 = "==";
236
- var peg$c23 = "!=";
237
- var peg$c24 = "\\0";
238
- var peg$c25 = "\\b";
239
- var peg$c26 = "\\f";
240
- var peg$c27 = "\\n";
241
- var peg$c28 = "\\r";
242
- var peg$c29 = "\\t";
243
- var peg$c30 = "\\v";
244
- var peg$c31 = "\\";
245
- var peg$c32 = "`";
246
- var peg$c33 = "}";
247
- var peg$c34 = "\xBB";
248
- var peg$c35 = "'";
249
- var peg$c36 = "**";
250
- var peg$c37 = ".";
251
- var peg$c38 = "---\n";
252
- var peg$c39 = "\xAB";
253
- var peg$c40 = "-";
254
- var peg$c41 = "&&";
255
- var peg$c42 = "||";
256
- var peg$c43 = "/*";
257
- var peg$c44 = "*/";
258
- var peg$c45 = "new";
259
- var peg$c46 = "new:";
260
- var peg$c47 = "\n";
261
- var peg$c48 = "\r\n";
262
- var peg$c49 = "\r";
263
- var peg$c50 = "??";
264
- var peg$c51 = "{";
265
- var peg$c52 = "=";
266
- var peg$c53 = "?.";
267
- var peg$c54 = "<=";
268
- var peg$c55 = ">=";
269
- var peg$c56 = "#!";
270
- var peg$c57 = "<<";
271
- var peg$c58 = ">>>";
272
- var peg$c59 = ">>";
273
- var peg$c60 = "\u2192";
274
- var peg$c61 = "->";
275
- var peg$c62 = "${";
276
- var peg$c63 = "-\n";
212
+ var peg$c0 = "[";
213
+ var peg$c1 = "]";
214
+ var peg$c2 = "(";
215
+ var peg$c3 = ")";
216
+ var peg$c4 = "&";
217
+ var peg$c5 = "|";
218
+ var peg$c6 = "^";
219
+ var peg$c7 = ",";
220
+ var peg$c8 = "?";
221
+ var peg$c9 = ":";
222
+ var peg$c10 = "\u21D2";
223
+ var peg$c11 = "=>";
224
+ var peg$c12 = "\"";
225
+ var peg$c13 = "...";
226
+ var peg$c14 = "\u2026";
227
+ var peg$c15 = "===";
228
+ var peg$c16 = "!==";
229
+ var peg$c17 = "==";
230
+ var peg$c18 = "!=";
231
+ var peg$c19 = "\\0";
232
+ var peg$c20 = "\\b";
233
+ var peg$c21 = "\\f";
234
+ var peg$c22 = "\\n";
235
+ var peg$c23 = "\\r";
236
+ var peg$c24 = "\\t";
237
+ var peg$c25 = "\\v";
238
+ var peg$c26 = "\\";
239
+ var peg$c27 = "`";
240
+ var peg$c28 = "}";
241
+ var peg$c29 = "\xBB";
242
+ var peg$c30 = "'";
243
+ var peg$c31 = "**";
244
+ var peg$c32 = ".";
245
+ var peg$c33 = "---\n";
246
+ var peg$c34 = "\xAB";
247
+ var peg$c35 = "~";
248
+ var peg$c36 = "-";
249
+ var peg$c37 = ">";
250
+ var peg$c38 = "&&";
251
+ var peg$c39 = "||";
252
+ var peg$c40 = "/*";
253
+ var peg$c41 = "*/";
254
+ var peg$c42 = "\n";
255
+ var peg$c43 = "\r\n";
256
+ var peg$c44 = "\r";
257
+ var peg$c45 = "??";
258
+ var peg$c46 = "{";
259
+ var peg$c47 = "=";
260
+ var peg$c48 = "/";
261
+ var peg$c49 = "//";
262
+ var peg$c50 = "<=";
263
+ var peg$c51 = "<";
264
+ var peg$c52 = ">=";
265
+ var peg$c53 = "#!";
266
+ var peg$c54 = "<<";
267
+ var peg$c55 = ">>>";
268
+ var peg$c56 = ">>";
269
+ var peg$c57 = "\u2192";
270
+ var peg$c58 = "->";
271
+ var peg$c59 = "${";
277
272
 
278
273
  var peg$r0 = /^[+\-]/;
279
- var peg$r1 = /^[^\/:<>]/;
280
- var peg$r2 = /^[0-9]/;
281
- var peg$r3 = /^[^(){}[\]<>?!|\-=,\/:`"'\xAB\xBB\\\u2192\u21D2\u2026 \t\n\r]/;
282
- var peg$r4 = /^[ \t]/;
283
- var peg$r5 = /^[%*\/]/;
284
- var peg$r6 = /^[A-Za-z]/;
285
- var peg$r7 = /^[^(){}[\],:\/\\ \t\n\r]/;
286
- var peg$r8 = /^[gimuy]/;
287
- var peg$r9 = /^[^\/\n\r]/;
288
- var peg$r10 = /^[^\n\r]/;
289
- var peg$r11 = /^[!+]/;
274
+ var peg$r1 = /^[0-9]/;
275
+ var peg$r2 = /^[^(){}[\]<>?!|\-=,\/:`"'\xAB\xBB\\\u2192\u21D2\u2026 \t\n\r]/;
276
+ var peg$r3 = /^[ \t]/;
277
+ var peg$r4 = /^[%*\/]/;
278
+ var peg$r5 = /^[A-Za-z]/;
279
+ var peg$r6 = /^[^(){}[\],:\/\\ \t\n\r]/;
280
+ var peg$r7 = /^[^\n\r]/;
281
+ var peg$r8 = /^[!+\-~]/;
290
282
 
291
283
  var peg$e0 = peg$classExpectation(["+", "-"], false, false);
292
- var peg$e1 = peg$literalExpectation("<", false);
293
- var peg$e2 = peg$literalExpectation("//", false);
294
- var peg$e3 = peg$literalExpectation(">", false);
295
- var peg$e4 = peg$literalExpectation("/", false);
296
- var peg$e5 = peg$literalExpectation("~", false);
297
- var peg$e6 = peg$classExpectation(["/", ":", "<", ">"], true, false);
298
- var peg$e7 = peg$literalExpectation(":", false);
299
- var peg$e8 = peg$otherExpectation("function arguments");
300
- var peg$e9 = peg$otherExpectation("array");
301
- var peg$e10 = peg$literalExpectation("[", false);
302
- var peg$e11 = peg$literalExpectation("]", false);
303
- var peg$e12 = peg$literalExpectation("(", false);
304
- var peg$e13 = peg$literalExpectation(")", false);
305
- var peg$e14 = peg$literalExpectation("&", false);
306
- var peg$e15 = peg$literalExpectation("|", false);
307
- var peg$e16 = peg$literalExpectation("^", false);
308
- var peg$e17 = peg$otherExpectation("function call");
309
- var peg$e18 = peg$literalExpectation(",", false);
310
- var peg$e19 = peg$otherExpectation("comment");
311
- var peg$e20 = peg$literalExpectation("?", false);
312
- var peg$e21 = peg$classExpectation([["0", "9"]], false, false);
313
- var peg$e22 = peg$literalExpectation("\u21D2", false);
314
- var peg$e23 = peg$literalExpectation("=>", false);
315
- var peg$e24 = peg$otherExpectation("double quote string");
316
- var peg$e25 = peg$literalExpectation("\"", false);
317
- var peg$e26 = peg$literalExpectation("...", false);
318
- var peg$e27 = peg$literalExpectation("\u2026", false);
319
- var peg$e28 = peg$literalExpectation("===", false);
320
- var peg$e29 = peg$literalExpectation("!==", false);
321
- var peg$e30 = peg$literalExpectation("==", false);
322
- var peg$e31 = peg$literalExpectation("!=", false);
323
- var peg$e32 = peg$otherExpectation("backslash-escaped character");
324
- var peg$e33 = peg$literalExpectation("\\0", false);
325
- var peg$e34 = peg$literalExpectation("\\b", false);
326
- var peg$e35 = peg$literalExpectation("\\f", false);
327
- var peg$e36 = peg$literalExpectation("\\n", false);
328
- var peg$e37 = peg$literalExpectation("\\r", false);
329
- var peg$e38 = peg$literalExpectation("\\t", false);
330
- var peg$e39 = peg$literalExpectation("\\v", false);
331
- var peg$e40 = peg$literalExpectation("\\", false);
332
- var peg$e41 = peg$anyExpectation();
333
- var peg$e42 = peg$literalExpectation("`", false);
334
- var peg$e43 = peg$literalExpectation("}", false);
335
- var peg$e44 = peg$literalExpectation("\xBB", false);
336
- var peg$e45 = peg$literalExpectation("'", false);
337
- var peg$e46 = peg$literalExpectation("**", false);
338
- var peg$e47 = peg$otherExpectation("floating-point number");
339
- var peg$e48 = peg$literalExpectation(".", false);
340
- var peg$e49 = peg$literalExpectation("---\n", false);
341
- var peg$e50 = peg$otherExpectation("YAML front matter");
342
- var peg$e51 = peg$otherExpectation("parenthetical group");
343
- var peg$e52 = peg$otherExpectation("guillemet string");
344
- var peg$e53 = peg$literalExpectation("\xAB", false);
345
- var peg$e54 = peg$otherExpectation("HTTP/HTTPS host");
346
- var peg$e55 = peg$otherExpectation("identifier");
347
- var peg$e56 = peg$classExpectation(["(", ")", "{", "}", "[", "]", "<", ">", "?", "!", "|", "-", "=", ",", "/", ":", "`", "\"", "'", "\xAB", "\xBB", "\\", "\u2192", "\u21D2", "\u2026", " ", "\t", "\n", "\r"], true, false);
348
- var peg$e57 = peg$literalExpectation("-", false);
349
- var peg$e58 = peg$otherExpectation("function call with implicit parentheses");
350
- var peg$e59 = peg$classExpectation([" ", "\t"], false, false);
351
- var peg$e60 = peg$otherExpectation("integer");
352
- var peg$e61 = peg$otherExpectation("JavaScript identifier continuation");
353
- var peg$e62 = peg$otherExpectation("JavaScript identifier start");
354
- var peg$e63 = peg$otherExpectation("identifier reference");
355
- var peg$e64 = peg$otherExpectation("list");
356
- var peg$e65 = peg$literalExpectation("&&", false);
357
- var peg$e66 = peg$literalExpectation("||", false);
358
- var peg$e67 = peg$literalExpectation("/*", false);
359
- var peg$e68 = peg$literalExpectation("*/", false);
360
- var peg$e69 = peg$classExpectation(["%", "*", "/"], false, false);
361
- var peg$e70 = peg$classExpectation([["A", "Z"], ["a", "z"]], false, false);
362
- var peg$e71 = peg$literalExpectation("new", false);
363
- var peg$e72 = peg$literalExpectation("new:", false);
364
- var peg$e73 = peg$literalExpectation("\n", false);
365
- var peg$e74 = peg$literalExpectation("\r\n", false);
366
- var peg$e75 = peg$literalExpectation("\r", false);
367
- var peg$e76 = peg$otherExpectation("number");
368
- var peg$e77 = peg$literalExpectation("??", false);
369
- var peg$e78 = peg$otherExpectation("object literal");
370
- var peg$e79 = peg$literalExpectation("{", false);
371
- var peg$e80 = peg$otherExpectation("object getter");
372
- var peg$e81 = peg$literalExpectation("=", false);
373
- var peg$e82 = peg$otherExpectation("object key");
374
- var peg$e83 = peg$otherExpectation("object property");
375
- var peg$e84 = peg$otherExpectation("object identifier");
376
- var peg$e85 = peg$literalExpectation("?.", false);
377
- var peg$e86 = peg$otherExpectation("function arguments in parentheses");
378
- var peg$e87 = peg$otherExpectation("slash-separated path");
379
- var peg$e88 = peg$classExpectation(["(", ")", "{", "}", "[", "]", ",", ":", "/", "\\", " ", "\t", "\n", "\r"], true, false);
380
- var peg$e89 = peg$otherExpectation("Origami program");
381
- var peg$e90 = peg$classExpectation(["g", "i", "m", "u", "y"], false, false);
382
- var peg$e91 = peg$classExpectation(["/", "\n", "\r"], true, false);
383
- var peg$e92 = peg$literalExpectation("<=", false);
384
- var peg$e93 = peg$literalExpectation(">=", false);
385
- var peg$e94 = peg$otherExpectation("scope reference");
386
- var peg$e95 = peg$literalExpectation("#!", false);
387
- var peg$e96 = peg$classExpectation(["\n", "\r"], true, false);
388
- var peg$e97 = peg$literalExpectation("<<", false);
389
- var peg$e98 = peg$literalExpectation(">>>", false);
390
- var peg$e99 = peg$literalExpectation(">>", false);
391
- var peg$e100 = peg$otherExpectation("lambda function");
392
- var peg$e101 = peg$literalExpectation("\u2192", false);
393
- var peg$e102 = peg$literalExpectation("->", false);
394
- var peg$e103 = peg$otherExpectation("single quote string");
395
- var peg$e104 = peg$otherExpectation("string");
396
- var peg$e105 = peg$otherExpectation("template");
397
- var peg$e106 = peg$literalExpectation("${", false);
398
- var peg$e107 = peg$otherExpectation("template text");
399
- var peg$e108 = peg$otherExpectation("template document");
400
- var peg$e109 = peg$otherExpectation("template literal");
401
- var peg$e110 = peg$otherExpectation("template substitution");
402
- var peg$e111 = peg$classExpectation(["!", "+"], false, false);
403
- var peg$e112 = peg$literalExpectation("-\n", false);
284
+ var peg$e1 = peg$otherExpectation("function arguments");
285
+ var peg$e2 = peg$otherExpectation("array");
286
+ var peg$e3 = peg$literalExpectation("[", false);
287
+ var peg$e4 = peg$literalExpectation("]", false);
288
+ var peg$e5 = peg$literalExpectation("(", false);
289
+ var peg$e6 = peg$literalExpectation(")", false);
290
+ var peg$e7 = peg$literalExpectation("&", false);
291
+ var peg$e8 = peg$literalExpectation("|", false);
292
+ var peg$e9 = peg$literalExpectation("^", false);
293
+ var peg$e10 = peg$otherExpectation("function call");
294
+ var peg$e11 = peg$literalExpectation(",", false);
295
+ var peg$e12 = peg$otherExpectation("comment");
296
+ var peg$e13 = peg$literalExpectation("?", false);
297
+ var peg$e14 = peg$literalExpectation(":", false);
298
+ var peg$e15 = peg$classExpectation([["0", "9"]], false, false);
299
+ var peg$e16 = peg$literalExpectation("\u21D2", false);
300
+ var peg$e17 = peg$literalExpectation("=>", false);
301
+ var peg$e18 = peg$otherExpectation("double quote string");
302
+ var peg$e19 = peg$literalExpectation("\"", false);
303
+ var peg$e20 = peg$literalExpectation("...", false);
304
+ var peg$e21 = peg$literalExpectation("\u2026", false);
305
+ var peg$e22 = peg$literalExpectation("===", false);
306
+ var peg$e23 = peg$literalExpectation("!==", false);
307
+ var peg$e24 = peg$literalExpectation("==", false);
308
+ var peg$e25 = peg$literalExpectation("!=", false);
309
+ var peg$e26 = peg$otherExpectation("backslash-escaped character");
310
+ var peg$e27 = peg$literalExpectation("\\0", false);
311
+ var peg$e28 = peg$literalExpectation("\\b", false);
312
+ var peg$e29 = peg$literalExpectation("\\f", false);
313
+ var peg$e30 = peg$literalExpectation("\\n", false);
314
+ var peg$e31 = peg$literalExpectation("\\r", false);
315
+ var peg$e32 = peg$literalExpectation("\\t", false);
316
+ var peg$e33 = peg$literalExpectation("\\v", false);
317
+ var peg$e34 = peg$literalExpectation("\\", false);
318
+ var peg$e35 = peg$anyExpectation();
319
+ var peg$e36 = peg$literalExpectation("`", false);
320
+ var peg$e37 = peg$literalExpectation("}", false);
321
+ var peg$e38 = peg$literalExpectation("\xBB", false);
322
+ var peg$e39 = peg$literalExpectation("'", false);
323
+ var peg$e40 = peg$literalExpectation("**", false);
324
+ var peg$e41 = peg$otherExpectation("floating-point number");
325
+ var peg$e42 = peg$literalExpectation(".", false);
326
+ var peg$e43 = peg$literalExpectation("---\n", false);
327
+ var peg$e44 = peg$otherExpectation("YAML front matter");
328
+ var peg$e45 = peg$otherExpectation("parenthetical group");
329
+ var peg$e46 = peg$otherExpectation("guillemet string");
330
+ var peg$e47 = peg$literalExpectation("\xAB", false);
331
+ var peg$e48 = peg$literalExpectation("~", false);
332
+ var peg$e49 = peg$otherExpectation("HTTP/HTTPS host");
333
+ var peg$e50 = peg$otherExpectation("identifier");
334
+ var peg$e51 = peg$classExpectation(["(", ")", "{", "}", "[", "]", "<", ">", "?", "!", "|", "-", "=", ",", "/", ":", "`", "\"", "'", "\xAB", "\xBB", "\\", "\u2192", "\u21D2", "\u2026", " ", "\t", "\n", "\r"], true, false);
335
+ var peg$e52 = peg$literalExpectation("-", false);
336
+ var peg$e53 = peg$literalExpectation(">", false);
337
+ var peg$e54 = peg$otherExpectation("function call with implicit parentheses");
338
+ var peg$e55 = peg$classExpectation([" ", "\t"], false, false);
339
+ var peg$e56 = peg$otherExpectation("integer");
340
+ var peg$e57 = peg$otherExpectation("JavaScript identifier continuation");
341
+ var peg$e58 = peg$otherExpectation("JavaScript identifier start");
342
+ var peg$e59 = peg$otherExpectation("list");
343
+ var peg$e60 = peg$literalExpectation("&&", false);
344
+ var peg$e61 = peg$literalExpectation("||", false);
345
+ var peg$e62 = peg$literalExpectation("/*", false);
346
+ var peg$e63 = peg$literalExpectation("*/", false);
347
+ var peg$e64 = peg$classExpectation(["%", "*", "/"], false, false);
348
+ var peg$e65 = peg$classExpectation([["A", "Z"], ["a", "z"]], false, false);
349
+ var peg$e66 = peg$literalExpectation("\n", false);
350
+ var peg$e67 = peg$literalExpectation("\r\n", false);
351
+ var peg$e68 = peg$literalExpectation("\r", false);
352
+ var peg$e69 = peg$otherExpectation("number");
353
+ var peg$e70 = peg$literalExpectation("??", false);
354
+ var peg$e71 = peg$otherExpectation("object literal");
355
+ var peg$e72 = peg$literalExpectation("{", false);
356
+ var peg$e73 = peg$otherExpectation("object getter");
357
+ var peg$e74 = peg$literalExpectation("=", false);
358
+ var peg$e75 = peg$otherExpectation("object key");
359
+ var peg$e76 = peg$otherExpectation("object property");
360
+ var peg$e77 = peg$otherExpectation("object identifier");
361
+ var peg$e78 = peg$literalExpectation("/", false);
362
+ var peg$e79 = peg$otherExpectation("function arguments in parentheses");
363
+ var peg$e80 = peg$otherExpectation("slash-separated path");
364
+ var peg$e81 = peg$classExpectation(["(", ")", "{", "}", "[", "]", ",", ":", "/", "\\", " ", "\t", "\n", "\r"], true, false);
365
+ var peg$e82 = peg$otherExpectation("Origami program");
366
+ var peg$e83 = peg$literalExpectation("//", false);
367
+ var peg$e84 = peg$literalExpectation("<=", false);
368
+ var peg$e85 = peg$literalExpectation("<", false);
369
+ var peg$e86 = peg$literalExpectation(">=", false);
370
+ var peg$e87 = peg$otherExpectation("scope reference");
371
+ var peg$e88 = peg$literalExpectation("#!", false);
372
+ var peg$e89 = peg$classExpectation(["\n", "\r"], true, false);
373
+ var peg$e90 = peg$literalExpectation("<<", false);
374
+ var peg$e91 = peg$literalExpectation(">>>", false);
375
+ var peg$e92 = peg$literalExpectation(">>", false);
376
+ var peg$e93 = peg$otherExpectation("lambda function");
377
+ var peg$e94 = peg$literalExpectation("\u2192", false);
378
+ var peg$e95 = peg$literalExpectation("->", false);
379
+ var peg$e96 = peg$otherExpectation("single quote string");
380
+ var peg$e97 = peg$otherExpectation("string");
381
+ var peg$e98 = peg$otherExpectation("template");
382
+ var peg$e99 = peg$literalExpectation("${", false);
383
+ var peg$e100 = peg$otherExpectation("template text");
384
+ var peg$e101 = peg$otherExpectation("template document");
385
+ var peg$e102 = peg$otherExpectation("template literal");
386
+ var peg$e103 = peg$otherExpectation("template substitution");
387
+ var peg$e104 = peg$classExpectation(["!", "+", "-", "~"], false, false);
404
388
 
405
389
  var peg$f0 = function() {
406
390
  return null;
@@ -408,67 +392,43 @@ function peg$parse(input, options) {
408
392
  var peg$f1 = function(head, tail) {
409
393
  return tail.reduce(makeBinaryOperation, head);
410
394
  };
411
- var peg$f2 = function(protocol, path) {
412
- return annotate([protocol, ...path], location());
413
- };
414
- var peg$f3 = function(path) {
415
- const root = annotate([ops.rootDirectory], location());
416
- return path.length > 0 ? annotate([root, ...path], location()) : root;
417
- };
418
- var peg$f4 = function(path) {
419
- const home = annotate([ops.homeDirectory], location());
420
- return path.length > 0 ? annotate([home, ...path], location()) : home;
421
- };
422
- var peg$f5 = function(path) {
423
- // Angle bracket paths always reference scope
424
- const scope = annotate([ops.scope], location());
425
- return annotate([scope, ...path], location());
426
- };
427
- var peg$f6 = function(chars, slashFollows) {
428
- // Append a trailing slash if one follows (but don't consume it)
429
- const key = chars.join("") + (slashFollows ? "/" : "");
430
- return annotate([ops.literal, key], location());
431
- };
432
- var peg$f7 = function(protocol) {
433
- return annotate([markers.global, `${protocol[1]}:`], location());
434
- };
435
- var peg$f8 = function(entries) {
395
+ var peg$f2 = function(entries) {
436
396
  return makeArray(entries ?? [], location());
437
397
  };
438
- var peg$f9 = function(entries) {
398
+ var peg$f3 = function(entries) {
439
399
  return annotate(entries, location());
440
400
  };
441
- var peg$f10 = function() {
401
+ var peg$f4 = function() {
442
402
  return annotate([ops.literal, undefined], location());
443
403
  };
444
- var peg$f11 = function(parameters, pipeline) {
404
+ var peg$f5 = function(parameters, pipeline) {
445
405
  const lambdaParameters = parameters ?? annotate([], location());
446
406
  return annotate([ops.lambda, lambdaParameters, pipeline], location());
447
407
  };
448
- var peg$f12 = function(parameter, pipeline) {
408
+ var peg$f6 = function(parameter, pipeline) {
449
409
  return annotate([ops.lambda, parameter, pipeline], location());
450
410
  };
451
- var peg$f13 = function(head, tail) {
411
+ var peg$f7 = function(head, tail) {
452
412
  return tail.reduce(makeBinaryOperation, head);
453
413
  };
454
- var peg$f14 = function(head, tail) {
414
+ var peg$f8 = function(head, tail) {
455
415
  return tail.reduce(makeBinaryOperation, head);
456
416
  };
457
- var peg$f15 = function(head, tail) {
417
+ var peg$f9 = function(head, tail) {
458
418
  return tail.reduce(makeBinaryOperation, head);
459
419
  };
460
- var peg$f16 = function(head, tail) {
461
- return tail.reduce((target, args) => makeCall(target, args, options.mode), head);
420
+ var peg$f10 = function(head, tail) {
421
+ return tail.reduce(makeCall, head);
462
422
  };
463
- var peg$f17 = function(list) {
423
+ var peg$f11 = function(list) {
464
424
  return list.length === 1
465
425
  ? list[0]
466
426
  : annotate([ops.comma, ...list], location());
467
427
  };
468
- var peg$f18 = function(expression) {
469
- return annotate([markers.traverse, expression], location());
428
+ var peg$f12 = function(expression) {
429
+ return annotate([ops.traverse, expression], location());
470
430
  };
471
- var peg$f19 = function(condition, tail) {
431
+ var peg$f13 = function(condition, tail) {
472
432
  if (!tail) {
473
433
  return condition;
474
434
  }
@@ -480,105 +440,99 @@ function peg$parse(input, options) {
480
440
  downgradeReference(deferred[1])
481
441
  ], location());
482
442
  };
483
- var peg$f20 = function(chars) {
443
+ var peg$f14 = function(chars) {
484
444
  return annotate([ops.literal, chars.join("")], location());
485
445
  };
486
- var peg$f21 = function(head, tail) {
446
+ var peg$f15 = function(head, tail) {
487
447
  return tail.reduce(makeBinaryOperation, head);
488
448
  };
489
- var peg$f22 = function() { return "\0"; };
490
- var peg$f23 = function() { return "\b"; };
491
- var peg$f24 = function() { return "\f"; };
492
- var peg$f25 = function() { return "\n"; };
493
- var peg$f26 = function() { return "\r"; };
494
- var peg$f27 = function() { return "\t"; };
495
- var peg$f28 = function() { return "\v"; };
496
- var peg$f29 = function() {
449
+ var peg$f16 = function() { return "\0"; };
450
+ var peg$f17 = function() { return "\b"; };
451
+ var peg$f18 = function() { return "\f"; };
452
+ var peg$f19 = function() { return "\n"; };
453
+ var peg$f20 = function() { return "\r"; };
454
+ var peg$f21 = function() { return "\t"; };
455
+ var peg$f22 = function() { return "\v"; };
456
+ var peg$f23 = function() {
497
457
  error("Expected closing backtick");
498
458
  };
499
- var peg$f30 = function() {
459
+ var peg$f24 = function() {
500
460
  error(`An object ended without a closing brace, or contained something that wasn't expected.\nThe top level of an object can only contain definitions ("a: b" or "a = b") or spreads ("...a").`);
501
461
  };
502
- var peg$f31 = function() {
462
+ var peg$f25 = function() {
503
463
  error("Expected right bracket");
504
464
  };
505
- var peg$f32 = function() {
465
+ var peg$f26 = function() {
506
466
  error("Expected right parenthesis");
507
467
  };
508
- var peg$f33 = function() {
468
+ var peg$f27 = function() {
509
469
  error("Expected closing quote");
510
470
  };
511
- var peg$f34 = function() {
471
+ var peg$f28 = function() {
512
472
  error("Expected an Origami expression");
513
473
  };
514
- var peg$f35 = function() {
474
+ var peg$f29 = function() {
515
475
  error("Expected \"---\"");
516
476
  };
517
- var peg$f36 = function() {
477
+ var peg$f30 = function() {
518
478
  error("Expected closing guillemet");
519
479
  };
520
- var peg$f37 = function() {
480
+ var peg$f31 = function() {
521
481
  error("Expected closing quote");
522
482
  };
523
- var peg$f38 = function() {
483
+ var peg$f32 = function() {
524
484
  error("Expected an expression");
525
485
  };
526
- var peg$f39 = function(left, right) {
486
+ var peg$f33 = function(left, right) {
527
487
  return right ? annotate([ops.exponentiation, left, right], location()) : left;
528
488
  };
529
- var peg$f40 = function() {
489
+ var peg$f34 = function() {
530
490
  return annotate([ops.literal, parseFloat(text())], location());
531
491
  };
532
- var peg$f41 = function() {
492
+ var peg$f35 = function() {
533
493
  return isOrigamiFrontMatter(input.slice(location().end.offset))
534
494
  };
535
- var peg$f42 = function(chars) {
495
+ var peg$f36 = function(chars) {
536
496
  return chars.join("");
537
497
  };
538
- var peg$f43 = function(yaml) {
498
+ var peg$f37 = function(yaml) {
539
499
  return makeYamlObject(yaml, location());
540
500
  };
541
- var peg$f44 = function(expression) {
501
+ var peg$f38 = function(expression) {
542
502
  return annotate(downgradeReference(expression), location());
543
503
  };
544
- var peg$f45 = function(chars) {
504
+ var peg$f39 = function(chars) {
545
505
  return annotate([ops.literal, chars.join("")], location());
546
506
  };
547
- var peg$f46 = function() {
507
+ var peg$f40 = function() {
548
508
  return annotate([ops.homeDirectory], location());
549
509
  };
550
- var peg$f47 = function(identifier, port, slashFollows) {
510
+ var peg$f41 = function(identifier, port, slashFollows) {
551
511
  const portText = port ? `:${port[1]}` : "";
552
512
  const slashText = slashFollows ? "/" : "";
553
513
  const hostText = identifier + portText + slashText;
554
514
  return annotate([ops.literal, hostText], location());
555
515
  };
556
- var peg$f48 = function(chars) { return chars.join(""); };
557
- var peg$f49 = function(head, args) {
558
- return args ? makeCall(head, args, options.mode) : head;
516
+ var peg$f42 = function(chars) { return chars.join(""); };
517
+ var peg$f43 = function(head, args) {
518
+ return args ? makeCall(head, args) : head;
559
519
  };
560
- var peg$f50 = function(values) {
520
+ var peg$f44 = function(values) {
561
521
  return annotate(values, location());
562
522
  };
563
- var peg$f51 = function() {
523
+ var peg$f45 = function() {
564
524
  return annotate([ops.literal, parseInt(text())], location());
565
525
  };
566
- var peg$f52 = function() { return options.mode === "jse" };
567
- var peg$f53 = function(id) {
568
- return annotate([ops.literal, id], location());
526
+ var peg$f46 = function(char) { return char.match(/[$_\p{ID_Continue}]/u) };
527
+ var peg$f47 = function(char) { return char.match(/[$_\p{ID_Start}]/u) };
528
+ var peg$f48 = function(property) {
529
+ const literal = annotate([ops.literal, property], location());
530
+ return annotate([ops.traverse, literal], location());
569
531
  };
570
- var peg$f54 = function(char) { return char.match(/[$_\p{ID_Continue}]/u) };
571
- var peg$f55 = function(char) { return char.match(/[$_\p{ID_Start}]/u) };
572
- var peg$f56 = function(property) {
573
- return annotate([markers.traverse, property], location());
574
- };
575
- var peg$f57 = function(id) {
576
- return annotate([markers.reference, id], location());
577
- };
578
- var peg$f58 = function(values) {
532
+ var peg$f49 = function(values) {
579
533
  return annotate(values, location());
580
534
  };
581
- var peg$f59 = function(head, tail) {
535
+ var peg$f50 = function(head, tail) {
582
536
  return tail.length === 0
583
537
  ? head
584
538
  : annotate(
@@ -586,7 +540,7 @@ function peg$parse(input, options) {
586
540
  location()
587
541
  );
588
542
  };
589
- var peg$f60 = function(head, tail) {
543
+ var peg$f51 = function(head, tail) {
590
544
  return tail.length === 0
591
545
  ? head
592
546
  : annotate(
@@ -594,22 +548,14 @@ function peg$parse(input, options) {
594
548
  location()
595
549
  );
596
550
  };
597
- var peg$f61 = function() { return null; };
598
- var peg$f62 = function(head, tail) {
551
+ var peg$f52 = function() { return null; };
552
+ var peg$f53 = function(head, tail) {
599
553
  return tail.reduce(makeBinaryOperation, head);
600
554
  };
601
- var peg$f63 = function(chars) {
602
- return annotate([markers.global, chars.join("") + ":"], location());
555
+ var peg$f54 = function(chars) {
556
+ return annotate([ops.builtin, chars.join("") + ":"], location());
603
557
  };
604
- var peg$f64 = function(head, tail) {
605
- const args = tail?.[0] !== undefined ? tail : [];
606
- return annotate([ops.construct, head, ...args], location());
607
- };
608
- var peg$f65 = function(head, tail) {
609
- const args = tail?.[0] !== undefined ? tail : [];
610
- return annotate([ops.construct, head, ...args], location());
611
- };
612
- var peg$f66 = function(head, tail) {
558
+ var peg$f55 = function(head, tail) {
613
559
  return tail.length === 0
614
560
  ? head
615
561
  : annotate(
@@ -617,158 +563,143 @@ function peg$parse(input, options) {
617
563
  location()
618
564
  );
619
565
  };
620
- var peg$f67 = function(entries) {
566
+ var peg$f56 = function(entries) {
621
567
  return makeObject(entries ?? [], location());
622
568
  };
623
- var peg$f68 = function(entries) {
569
+ var peg$f57 = function(entries) {
624
570
  return annotate(entries, location());
625
571
  };
626
- var peg$f69 = function(key, pipeline) {
572
+ var peg$f58 = function(key, pipeline) {
627
573
  return annotate(
628
574
  makeProperty(key, annotate([ops.getter, pipeline], location())),
629
575
  location()
630
576
  );
631
577
  };
632
- var peg$f70 = function(hiddenKey) { return hiddenKey.join(""); };
633
- var peg$f71 = function(key, pipeline) {
578
+ var peg$f59 = function(hiddenKey) { return hiddenKey.join(""); };
579
+ var peg$f60 = function(key, pipeline) {
634
580
  return annotate(makeProperty(key, pipeline), location());
635
581
  };
636
- var peg$f72 = function(key) {
637
- const reference = annotate([markers.reference, key], location());
638
- return annotate([key, reference], location());
582
+ var peg$f61 = function(key) {
583
+ const inherited = annotate([ops.inherited, key], location());
584
+ return annotate([key, inherited], location());
639
585
  };
640
- var peg$f73 = function(path) {
641
- let lastKey = path.at(-1);
642
- if (lastKey instanceof Array) {
643
- lastKey = lastKey[1]; // get scope identifier or literal
644
- }
645
- return annotate([lastKey, path], location());
586
+ var peg$f62 = function(identifier, slash) {
587
+ return identifier + (slash ?? "");
646
588
  };
647
- var peg$f74 = function(identifier, slash) {
648
- return identifier + (slash ?? "");
649
- };
650
- var peg$f75 = function(string) {
651
- // Remove `ops.literal` from the string code
652
- return string[1];
653
- };
654
- var peg$f76 = function(property) {
655
- return annotate([ops.optionalTraverse, property], location());
589
+ var peg$f63 = function(string) {
590
+ // Remove `ops.literal` from the string code
591
+ return string[1];
656
592
  };
657
- var peg$f77 = function(identifier) {
593
+ var peg$f64 = function(identifier) {
658
594
  return annotate([ops.literal, identifier], location());
659
595
  };
660
- var peg$f78 = function(list) {
596
+ var peg$f65 = function(list) {
661
597
  return annotate(list, location());
662
598
  };
663
- var peg$f79 = function(identifier) {
599
+ var peg$f66 = function(identifier) {
664
600
  return annotate(
665
601
  [annotate([ops.literal, identifier], location())],
666
602
  location()
667
603
  );
668
604
  };
669
- var peg$f80 = function(list) {
605
+ var peg$f67 = function(list) {
670
606
  return annotate(list ?? [undefined], location());
671
607
  };
672
- var peg$f81 = function(segments) {
608
+ var peg$f68 = function(segments) {
673
609
  // Drop empty segments that represent consecutive or final slashes
674
610
  segments = segments.filter(segment => segment);
675
611
  return annotate(segments, location());
676
612
  };
677
- var peg$f82 = function(path) {
678
- return annotate([markers.traverse, ...path], location());
613
+ var peg$f69 = function(path) {
614
+ return annotate([ops.traverse, ...path], location());
679
615
  };
680
- var peg$f83 = function(chars, slashFollows) {
616
+ var peg$f70 = function(chars, slashFollows) {
681
617
  // Append a trailing slash if one follows (but don't consume it)
682
618
  const key = chars.join("") + (slashFollows ? "/" : "");
683
619
  return annotate([ops.literal, key], location());
684
620
  };
685
- var peg$f84 = function(head, tail) {
621
+ var peg$f71 = function(head, tail) {
686
622
  return annotate(
687
- tail.reduce((arg, fn) => makePipeline(arg, fn, options.mode), downgradeReference(head)),
623
+ tail.reduce(makePipeline, downgradeReference(head)),
688
624
  location()
689
625
  );
690
626
  };
691
- var peg$f85 = function(fn, host, path) {
627
+ var peg$f72 = function(fn, host, path) {
692
628
  const keys = annotate([host, ...(path ?? [])], location());
693
- return makeCall(fn, keys, options.mode);
694
- };
695
- var peg$f86 = function(fn, reference) {
696
- return makeCall(fn, [reference[1]], options.mode);
629
+ return makeCall(fn, keys);
697
630
  };
698
- var peg$f87 = function(flags) {
699
- return flags.join("");
631
+ var peg$f73 = function(fn, reference) {
632
+ const literal = annotate([ops.literal, reference[1]], reference.location);
633
+ return makeCall(fn, [literal]);
700
634
  };
701
- var peg$f88 = function(chars, flags) {
702
- const regex = new RegExp(chars.join(""), flags);
703
- return annotate([ops.literal, regex], location());
704
- };
705
- var peg$f89 = function(head, tail) {
635
+ var peg$f74 = function(head, tail) {
706
636
  return tail.reduce(makeBinaryOperation, head);
707
637
  };
708
- var peg$f90 = function() {
638
+ var peg$f75 = function(key) {
639
+ return annotate([ops.rootDirectory, key], location());
640
+ };
641
+ var peg$f76 = function() {
709
642
  return annotate([ops.rootDirectory], location());
710
643
  };
711
- var peg$f91 = function(identifier, slashFollows) {
644
+ var peg$f77 = function(identifier, slashFollows) {
712
645
  const id = identifier + (slashFollows ? "/" : "");
713
- const idCode = annotate([ops.literal, identifier], location());
714
- return annotate([markers.reference, idCode], location());
646
+ return annotate(makeReference(id), location());
715
647
  };
716
- var peg$f92 = function() { return null; };
717
- var peg$f93 = function() { return options.mode === "shell" };
718
- var peg$f94 = function(head, tail) {
648
+ var peg$f78 = function() { return null; };
649
+ var peg$f79 = function(head, tail) {
719
650
  return tail.reduce(makeBinaryOperation, head);
720
651
  };
721
- var peg$f95 = function(definition) {
652
+ var peg$f80 = function(definition) {
722
653
  const lambdaParameters = annotate(
723
654
  [annotate([ops.literal, "_"], location())],
724
655
  location()
725
656
  );
726
657
  return annotate([ops.lambda, lambdaParameters, definition], location());
727
658
  };
728
- var peg$f96 = function() { return null; };
729
- var peg$f97 = function(chars) {
659
+ var peg$f81 = function() { return null; };
660
+ var peg$f82 = function(chars) {
730
661
  return annotate([ops.literal, chars.join("")], location());
731
662
  };
732
- var peg$f98 = function() {
663
+ var peg$f83 = function() {
733
664
  return annotate([ops.literal, "/"], location());
734
665
  };
735
- var peg$f99 = function() {
666
+ var peg$f84 = function() {
736
667
  return true;
737
668
  };
738
- var peg$f100 = function(value) {
669
+ var peg$f85 = function(value) {
739
670
  return annotate([ops.spread, value], location());
740
671
  };
741
- var peg$f101 = function(head, tail) {
742
- return makeTemplate(ops.templateIndent, head, tail, location());
743
- };
744
- var peg$f102 = function(chars) {
745
- return annotate([ops.literal, chars.join("")], location());
746
- };
747
- var peg$f103 = function(front, body) {
748
- const macroName = options.mode === "jse" ? "_template" : "@template";
749
- return annotate(applyMacro(front, macroName, body), location());
750
- };
751
- var peg$f104 = function(front, body) {
752
- return makeDocument(options.mode, front, body, location());
753
- };
754
- var peg$f105 = function(body) {
672
+ var peg$f86 = function(head, tail) {
755
673
  const lambdaParameters = annotate(
756
674
  [annotate([ops.literal, "_"], location())],
757
675
  location()
758
676
  );
759
- return annotate([ops.lambda, lambdaParameters, body], location());
677
+ return annotate(
678
+ [ops.lambda, lambdaParameters, makeTemplate(ops.templateIndent, head, tail, location())],
679
+ location()
680
+ );
760
681
  };
761
- var peg$f106 = function(head, tail) {
762
- const op = options.mode === "jse" ? ops.templateStandard : ops.templateTree;
763
- return makeTemplate(op, head, tail, location());
682
+ var peg$f87 = function(chars) {
683
+ return annotate([ops.literal, chars.join("")], location());
684
+ };
685
+ var peg$f88 = function(front, body) {
686
+ return annotate(applyMacro(front, "@template", body), location());
687
+ };
688
+ var peg$f89 = function(front, body) {
689
+ return front
690
+ ? annotate([ops.document, front, body], location())
691
+ : annotate(body, location());
692
+ };
693
+ var peg$f90 = function(head, tail) {
694
+ return makeTemplate(ops.template, head, tail, location());
764
695
  };
765
- var peg$f107 = function(chars) {
696
+ var peg$f91 = function(chars) {
766
697
  return annotate([ops.literal, chars.join("")], location());
767
698
  };
768
- var peg$f108 = function(expression) {
699
+ var peg$f92 = function(expression) {
769
700
  return annotate(expression, location());
770
701
  };
771
- var peg$f109 = function(operator, expression) {
702
+ var peg$f93 = function(operator, expression) {
772
703
  return makeUnaryOperation(operator, expression, location());
773
704
  };
774
705
  var peg$currPos = options.peg$currPos | 0;
@@ -958,11 +889,11 @@ function peg$parse(input, options) {
958
889
  if (s1 !== peg$FAILED) {
959
890
  s2 = [];
960
891
  s3 = peg$currPos;
961
- s4 = peg$parsewhitespaceShell();
892
+ s4 = peg$parsewhitespace();
962
893
  if (s4 !== peg$FAILED) {
963
894
  s5 = peg$parseadditiveOperator();
964
895
  if (s5 !== peg$FAILED) {
965
- s6 = peg$parsewhitespaceShell();
896
+ s6 = peg$parsewhitespace();
966
897
  if (s6 !== peg$FAILED) {
967
898
  s7 = peg$parsemultiplicativeExpression();
968
899
  if (s7 !== peg$FAILED) {
@@ -986,11 +917,11 @@ function peg$parse(input, options) {
986
917
  while (s3 !== peg$FAILED) {
987
918
  s2.push(s3);
988
919
  s3 = peg$currPos;
989
- s4 = peg$parsewhitespaceShell();
920
+ s4 = peg$parsewhitespace();
990
921
  if (s4 !== peg$FAILED) {
991
922
  s5 = peg$parseadditiveOperator();
992
923
  if (s5 !== peg$FAILED) {
993
- s6 = peg$parsewhitespaceShell();
924
+ s6 = peg$parsewhitespace();
994
925
  if (s6 !== peg$FAILED) {
995
926
  s7 = peg$parsemultiplicativeExpression();
996
927
  if (s7 !== peg$FAILED) {
@@ -1036,47 +967,55 @@ function peg$parse(input, options) {
1036
967
  return s0;
1037
968
  }
1038
969
 
1039
- function peg$parseangleBracketLiteral() {
1040
- var s0, s1, s2, s3, s4, s5, s6, s7;
970
+ function peg$parsearguments() {
971
+ var s0, s1;
972
+
973
+ peg$silentFails++;
974
+ s0 = peg$parseparenthesesArguments();
975
+ if (s0 === peg$FAILED) {
976
+ s0 = peg$parsepathArguments();
977
+ if (s0 === peg$FAILED) {
978
+ s0 = peg$parsejsPropertyAccess();
979
+ if (s0 === peg$FAILED) {
980
+ s0 = peg$parsecomputedPropertyAccess();
981
+ if (s0 === peg$FAILED) {
982
+ s0 = peg$parsetemplateLiteral();
983
+ }
984
+ }
985
+ }
986
+ }
987
+ peg$silentFails--;
988
+ if (s0 === peg$FAILED) {
989
+ s1 = peg$FAILED;
990
+ if (peg$silentFails === 0) { peg$fail(peg$e1); }
991
+ }
992
+
993
+ return s0;
994
+ }
1041
995
 
996
+ function peg$parsearrayLiteral() {
997
+ var s0, s1, s2, s3, s4, s5;
998
+
999
+ peg$silentFails++;
1042
1000
  s0 = peg$currPos;
1043
- if (input.charCodeAt(peg$currPos) === 60) {
1001
+ if (input.charCodeAt(peg$currPos) === 91) {
1044
1002
  s1 = peg$c0;
1045
1003
  peg$currPos++;
1046
1004
  } else {
1047
1005
  s1 = peg$FAILED;
1048
- if (peg$silentFails === 0) { peg$fail(peg$e1); }
1006
+ if (peg$silentFails === 0) { peg$fail(peg$e3); }
1049
1007
  }
1050
1008
  if (s1 !== peg$FAILED) {
1051
1009
  s2 = peg$parse__();
1052
- s3 = peg$parseangleBracketProtocol();
1053
- if (s3 !== peg$FAILED) {
1054
- if (input.substr(peg$currPos, 2) === peg$c1) {
1055
- s4 = peg$c1;
1056
- peg$currPos += 2;
1057
- } else {
1058
- s4 = peg$FAILED;
1059
- if (peg$silentFails === 0) { peg$fail(peg$e2); }
1060
- }
1061
- if (s4 === peg$FAILED) {
1062
- s4 = null;
1063
- }
1064
- s5 = peg$parseangleBracketPath();
1065
- s6 = peg$parse__();
1066
- if (input.charCodeAt(peg$currPos) === 62) {
1067
- s7 = peg$c2;
1068
- peg$currPos++;
1069
- } else {
1070
- s7 = peg$FAILED;
1071
- if (peg$silentFails === 0) { peg$fail(peg$e3); }
1072
- }
1073
- if (s7 !== peg$FAILED) {
1074
- peg$savedPos = s0;
1075
- s0 = peg$f2(s3, s5);
1076
- } else {
1077
- peg$currPos = s0;
1078
- s0 = peg$FAILED;
1079
- }
1010
+ s3 = peg$parsearrayEntries();
1011
+ if (s3 === peg$FAILED) {
1012
+ s3 = null;
1013
+ }
1014
+ s4 = peg$parse__();
1015
+ s5 = peg$parseexpectClosingBracket();
1016
+ if (s5 !== peg$FAILED) {
1017
+ peg$savedPos = s0;
1018
+ s0 = peg$f2(s3);
1080
1019
  } else {
1081
1020
  peg$currPos = s0;
1082
1021
  s0 = peg$FAILED;
@@ -1085,204 +1024,51 @@ function peg$parse(input, options) {
1085
1024
  peg$currPos = s0;
1086
1025
  s0 = peg$FAILED;
1087
1026
  }
1027
+ peg$silentFails--;
1088
1028
  if (s0 === peg$FAILED) {
1089
- s0 = peg$currPos;
1090
- if (input.charCodeAt(peg$currPos) === 60) {
1091
- s1 = peg$c0;
1092
- peg$currPos++;
1093
- } else {
1094
- s1 = peg$FAILED;
1095
- if (peg$silentFails === 0) { peg$fail(peg$e1); }
1096
- }
1097
- if (s1 !== peg$FAILED) {
1098
- s2 = peg$parse__();
1099
- if (input.charCodeAt(peg$currPos) === 47) {
1100
- s3 = peg$c3;
1101
- peg$currPos++;
1102
- } else {
1103
- s3 = peg$FAILED;
1104
- if (peg$silentFails === 0) { peg$fail(peg$e4); }
1105
- }
1106
- if (s3 !== peg$FAILED) {
1107
- s4 = peg$parseangleBracketPath();
1108
- s5 = peg$parse__();
1109
- if (input.charCodeAt(peg$currPos) === 62) {
1110
- s6 = peg$c2;
1111
- peg$currPos++;
1112
- } else {
1113
- s6 = peg$FAILED;
1114
- if (peg$silentFails === 0) { peg$fail(peg$e3); }
1115
- }
1116
- if (s6 !== peg$FAILED) {
1117
- peg$savedPos = s0;
1118
- s0 = peg$f3(s4);
1119
- } else {
1120
- peg$currPos = s0;
1121
- s0 = peg$FAILED;
1122
- }
1123
- } else {
1124
- peg$currPos = s0;
1125
- s0 = peg$FAILED;
1126
- }
1127
- } else {
1128
- peg$currPos = s0;
1129
- s0 = peg$FAILED;
1130
- }
1131
- if (s0 === peg$FAILED) {
1132
- s0 = peg$currPos;
1133
- if (input.charCodeAt(peg$currPos) === 60) {
1134
- s1 = peg$c0;
1135
- peg$currPos++;
1136
- } else {
1137
- s1 = peg$FAILED;
1138
- if (peg$silentFails === 0) { peg$fail(peg$e1); }
1139
- }
1140
- if (s1 !== peg$FAILED) {
1141
- s2 = peg$parse__();
1142
- if (input.charCodeAt(peg$currPos) === 126) {
1143
- s3 = peg$c4;
1144
- peg$currPos++;
1145
- } else {
1146
- s3 = peg$FAILED;
1147
- if (peg$silentFails === 0) { peg$fail(peg$e5); }
1148
- }
1149
- if (s3 !== peg$FAILED) {
1150
- if (input.charCodeAt(peg$currPos) === 47) {
1151
- s4 = peg$c3;
1152
- peg$currPos++;
1153
- } else {
1154
- s4 = peg$FAILED;
1155
- if (peg$silentFails === 0) { peg$fail(peg$e4); }
1156
- }
1157
- if (s4 === peg$FAILED) {
1158
- s4 = null;
1159
- }
1160
- s5 = peg$parseangleBracketPath();
1161
- s6 = peg$parse__();
1162
- if (input.charCodeAt(peg$currPos) === 62) {
1163
- s7 = peg$c2;
1164
- peg$currPos++;
1165
- } else {
1166
- s7 = peg$FAILED;
1167
- if (peg$silentFails === 0) { peg$fail(peg$e3); }
1168
- }
1169
- if (s7 !== peg$FAILED) {
1170
- peg$savedPos = s0;
1171
- s0 = peg$f4(s5);
1172
- } else {
1173
- peg$currPos = s0;
1174
- s0 = peg$FAILED;
1175
- }
1176
- } else {
1177
- peg$currPos = s0;
1178
- s0 = peg$FAILED;
1179
- }
1180
- } else {
1181
- peg$currPos = s0;
1182
- s0 = peg$FAILED;
1183
- }
1184
- if (s0 === peg$FAILED) {
1185
- s0 = peg$currPos;
1186
- if (input.charCodeAt(peg$currPos) === 60) {
1187
- s1 = peg$c0;
1188
- peg$currPos++;
1189
- } else {
1190
- s1 = peg$FAILED;
1191
- if (peg$silentFails === 0) { peg$fail(peg$e1); }
1192
- }
1193
- if (s1 !== peg$FAILED) {
1194
- s2 = peg$parse__();
1195
- s3 = peg$parseangleBracketPath();
1196
- s4 = peg$parse__();
1197
- if (input.charCodeAt(peg$currPos) === 62) {
1198
- s5 = peg$c2;
1199
- peg$currPos++;
1200
- } else {
1201
- s5 = peg$FAILED;
1202
- if (peg$silentFails === 0) { peg$fail(peg$e3); }
1203
- }
1204
- if (s5 !== peg$FAILED) {
1205
- peg$savedPos = s0;
1206
- s0 = peg$f5(s3);
1207
- } else {
1208
- peg$currPos = s0;
1209
- s0 = peg$FAILED;
1210
- }
1211
- } else {
1212
- peg$currPos = s0;
1213
- s0 = peg$FAILED;
1214
- }
1215
- }
1216
- }
1029
+ s1 = peg$FAILED;
1030
+ if (peg$silentFails === 0) { peg$fail(peg$e2); }
1217
1031
  }
1218
1032
 
1219
1033
  return s0;
1220
1034
  }
1221
1035
 
1222
- function peg$parseangleBracketPath() {
1223
- var s0, s1, s2, s3;
1036
+ function peg$parsearrayEntries() {
1037
+ var s0, s1, s2, s3, s4;
1224
1038
 
1225
1039
  s0 = peg$currPos;
1226
- s1 = [];
1227
- s2 = peg$parseangleBracketPathKey();
1228
- while (s2 !== peg$FAILED) {
1229
- s1.push(s2);
1230
- s2 = peg$currPos;
1231
- if (input.charCodeAt(peg$currPos) === 47) {
1232
- s3 = peg$c3;
1233
- peg$currPos++;
1234
- } else {
1235
- s3 = peg$FAILED;
1236
- if (peg$silentFails === 0) { peg$fail(peg$e4); }
1237
- }
1238
- if (s3 !== peg$FAILED) {
1239
- s3 = peg$parseangleBracketPathKey();
1240
- if (s3 === peg$FAILED) {
1241
- peg$currPos = s2;
1242
- s2 = peg$FAILED;
1040
+ s1 = peg$currPos;
1041
+ s2 = [];
1042
+ s3 = peg$parsearrayEntry();
1043
+ while (s3 !== peg$FAILED) {
1044
+ s2.push(s3);
1045
+ s3 = peg$currPos;
1046
+ s4 = peg$parseseparator();
1047
+ if (s4 !== peg$FAILED) {
1048
+ s4 = peg$parsearrayEntry();
1049
+ if (s4 === peg$FAILED) {
1050
+ peg$currPos = s3;
1051
+ s3 = peg$FAILED;
1243
1052
  } else {
1244
- s2 = s3;
1053
+ s3 = s4;
1245
1054
  }
1246
1055
  } else {
1247
- s2 = s3;
1056
+ s3 = s4;
1248
1057
  }
1249
1058
  }
1250
- if (input.charCodeAt(peg$currPos) === 47) {
1251
- s2 = peg$c3;
1252
- peg$currPos++;
1253
- } else {
1254
- s2 = peg$FAILED;
1255
- if (peg$silentFails === 0) { peg$fail(peg$e4); }
1256
- }
1257
- if (s2 === peg$FAILED) {
1258
- s2 = null;
1259
- }
1260
- s0 = s1;
1261
-
1262
- return s0;
1263
- }
1264
-
1265
- function peg$parseangleBracketPathKey() {
1266
- var s0, s1, s2;
1267
-
1268
- s0 = peg$currPos;
1269
- s1 = [];
1270
- s2 = peg$parseangleBracketPathChar();
1271
- if (s2 !== peg$FAILED) {
1272
- while (s2 !== peg$FAILED) {
1273
- s1.push(s2);
1274
- s2 = peg$parseangleBracketPathChar();
1275
- }
1276
- } else {
1059
+ if (s2.length < 1) {
1060
+ peg$currPos = s1;
1277
1061
  s1 = peg$FAILED;
1062
+ } else {
1063
+ s1 = s2;
1278
1064
  }
1279
1065
  if (s1 !== peg$FAILED) {
1280
- s2 = peg$parseslashFollows();
1066
+ s2 = peg$parseseparator();
1281
1067
  if (s2 === peg$FAILED) {
1282
1068
  s2 = null;
1283
1069
  }
1284
1070
  peg$savedPos = s0;
1285
- s0 = peg$f6(s1, s2);
1071
+ s0 = peg$f3(s1);
1286
1072
  } else {
1287
1073
  peg$currPos = s0;
1288
1074
  s0 = peg$FAILED;
@@ -1291,181 +1077,10 @@ function peg$parse(input, options) {
1291
1077
  return s0;
1292
1078
  }
1293
1079
 
1294
- function peg$parseangleBracketPathChar() {
1295
- var s0;
1080
+ function peg$parsearrayEntry() {
1081
+ var s0, s1, s2, s3;
1296
1082
 
1297
- s0 = input.charAt(peg$currPos);
1298
- if (peg$r1.test(s0)) {
1299
- peg$currPos++;
1300
- } else {
1301
- s0 = peg$FAILED;
1302
- if (peg$silentFails === 0) { peg$fail(peg$e6); }
1303
- }
1304
- if (s0 === peg$FAILED) {
1305
- s0 = peg$parseescapedChar();
1306
- }
1307
-
1308
- return s0;
1309
- }
1310
-
1311
- function peg$parseangleBracketProtocol() {
1312
- var s0, s1, s2;
1313
-
1314
- s0 = peg$currPos;
1315
- s1 = peg$parsejsIdentifier();
1316
- if (s1 !== peg$FAILED) {
1317
- if (input.charCodeAt(peg$currPos) === 58) {
1318
- s2 = peg$c5;
1319
- peg$currPos++;
1320
- } else {
1321
- s2 = peg$FAILED;
1322
- if (peg$silentFails === 0) { peg$fail(peg$e7); }
1323
- }
1324
- if (s2 !== peg$FAILED) {
1325
- peg$savedPos = s0;
1326
- s0 = peg$f7(s1);
1327
- } else {
1328
- peg$currPos = s0;
1329
- s0 = peg$FAILED;
1330
- }
1331
- } else {
1332
- peg$currPos = s0;
1333
- s0 = peg$FAILED;
1334
- }
1335
-
1336
- return s0;
1337
- }
1338
-
1339
- function peg$parsearguments() {
1340
- var s0, s1, s2;
1341
-
1342
- peg$silentFails++;
1343
- s0 = peg$parseparenthesesArguments();
1344
- if (s0 === peg$FAILED) {
1345
- s0 = peg$currPos;
1346
- s1 = peg$parseshellMode();
1347
- if (s1 !== peg$FAILED) {
1348
- s2 = peg$parsepathArguments();
1349
- if (s2 !== peg$FAILED) {
1350
- s0 = s2;
1351
- } else {
1352
- peg$currPos = s0;
1353
- s0 = peg$FAILED;
1354
- }
1355
- } else {
1356
- peg$currPos = s0;
1357
- s0 = peg$FAILED;
1358
- }
1359
- if (s0 === peg$FAILED) {
1360
- s0 = peg$parsejsPropertyAccess();
1361
- if (s0 === peg$FAILED) {
1362
- s0 = peg$parsecomputedPropertyAccess();
1363
- if (s0 === peg$FAILED) {
1364
- s0 = peg$parseoptionalChaining();
1365
- if (s0 === peg$FAILED) {
1366
- s0 = peg$parsetemplateLiteral();
1367
- }
1368
- }
1369
- }
1370
- }
1371
- }
1372
- peg$silentFails--;
1373
- if (s0 === peg$FAILED) {
1374
- s1 = peg$FAILED;
1375
- if (peg$silentFails === 0) { peg$fail(peg$e8); }
1376
- }
1377
-
1378
- return s0;
1379
- }
1380
-
1381
- function peg$parsearrayLiteral() {
1382
- var s0, s1, s2, s3, s4, s5;
1383
-
1384
- peg$silentFails++;
1385
- s0 = peg$currPos;
1386
- if (input.charCodeAt(peg$currPos) === 91) {
1387
- s1 = peg$c6;
1388
- peg$currPos++;
1389
- } else {
1390
- s1 = peg$FAILED;
1391
- if (peg$silentFails === 0) { peg$fail(peg$e10); }
1392
- }
1393
- if (s1 !== peg$FAILED) {
1394
- s2 = peg$parse__();
1395
- s3 = peg$parsearrayEntries();
1396
- if (s3 === peg$FAILED) {
1397
- s3 = null;
1398
- }
1399
- s4 = peg$parse__();
1400
- s5 = peg$parseexpectClosingBracket();
1401
- if (s5 !== peg$FAILED) {
1402
- peg$savedPos = s0;
1403
- s0 = peg$f8(s3);
1404
- } else {
1405
- peg$currPos = s0;
1406
- s0 = peg$FAILED;
1407
- }
1408
- } else {
1409
- peg$currPos = s0;
1410
- s0 = peg$FAILED;
1411
- }
1412
- peg$silentFails--;
1413
- if (s0 === peg$FAILED) {
1414
- s1 = peg$FAILED;
1415
- if (peg$silentFails === 0) { peg$fail(peg$e9); }
1416
- }
1417
-
1418
- return s0;
1419
- }
1420
-
1421
- function peg$parsearrayEntries() {
1422
- var s0, s1, s2, s3, s4;
1423
-
1424
- s0 = peg$currPos;
1425
- s1 = peg$currPos;
1426
- s2 = [];
1427
- s3 = peg$parsearrayEntry();
1428
- while (s3 !== peg$FAILED) {
1429
- s2.push(s3);
1430
- s3 = peg$currPos;
1431
- s4 = peg$parseseparator();
1432
- if (s4 !== peg$FAILED) {
1433
- s4 = peg$parsearrayEntry();
1434
- if (s4 === peg$FAILED) {
1435
- peg$currPos = s3;
1436
- s3 = peg$FAILED;
1437
- } else {
1438
- s3 = s4;
1439
- }
1440
- } else {
1441
- s3 = s4;
1442
- }
1443
- }
1444
- if (s2.length < 1) {
1445
- peg$currPos = s1;
1446
- s1 = peg$FAILED;
1447
- } else {
1448
- s1 = s2;
1449
- }
1450
- if (s1 !== peg$FAILED) {
1451
- s2 = peg$parseseparator();
1452
- if (s2 === peg$FAILED) {
1453
- s2 = null;
1454
- }
1455
- peg$savedPos = s0;
1456
- s0 = peg$f9(s1);
1457
- } else {
1458
- peg$currPos = s0;
1459
- s0 = peg$FAILED;
1460
- }
1461
-
1462
- return s0;
1463
- }
1464
-
1465
- function peg$parsearrayEntry() {
1466
- var s0, s1, s2, s3;
1467
-
1468
- s0 = peg$parsespreadElement();
1083
+ s0 = peg$parsespreadElement();
1469
1084
  if (s0 === peg$FAILED) {
1470
1085
  s0 = peg$parsepipelineExpression();
1471
1086
  if (s0 === peg$FAILED) {
@@ -1474,11 +1089,11 @@ function peg$parse(input, options) {
1474
1089
  s2 = peg$currPos;
1475
1090
  peg$silentFails++;
1476
1091
  if (input.charCodeAt(peg$currPos) === 93) {
1477
- s3 = peg$c7;
1092
+ s3 = peg$c1;
1478
1093
  peg$currPos++;
1479
1094
  } else {
1480
1095
  s3 = peg$FAILED;
1481
- if (peg$silentFails === 0) { peg$fail(peg$e11); }
1096
+ if (peg$silentFails === 0) { peg$fail(peg$e4); }
1482
1097
  }
1483
1098
  peg$silentFails--;
1484
1099
  if (s3 === peg$FAILED) {
@@ -1489,7 +1104,7 @@ function peg$parse(input, options) {
1489
1104
  }
1490
1105
  if (s2 !== peg$FAILED) {
1491
1106
  peg$savedPos = s0;
1492
- s0 = peg$f10();
1107
+ s0 = peg$f4();
1493
1108
  } else {
1494
1109
  peg$currPos = s0;
1495
1110
  s0 = peg$FAILED;
@@ -1505,11 +1120,11 @@ function peg$parse(input, options) {
1505
1120
 
1506
1121
  s0 = peg$currPos;
1507
1122
  if (input.charCodeAt(peg$currPos) === 40) {
1508
- s1 = peg$c8;
1123
+ s1 = peg$c2;
1509
1124
  peg$currPos++;
1510
1125
  } else {
1511
1126
  s1 = peg$FAILED;
1512
- if (peg$silentFails === 0) { peg$fail(peg$e12); }
1127
+ if (peg$silentFails === 0) { peg$fail(peg$e5); }
1513
1128
  }
1514
1129
  if (s1 !== peg$FAILED) {
1515
1130
  s2 = peg$parse__();
@@ -1519,11 +1134,11 @@ function peg$parse(input, options) {
1519
1134
  }
1520
1135
  s4 = peg$parse__();
1521
1136
  if (input.charCodeAt(peg$currPos) === 41) {
1522
- s5 = peg$c9;
1137
+ s5 = peg$c3;
1523
1138
  peg$currPos++;
1524
1139
  } else {
1525
1140
  s5 = peg$FAILED;
1526
- if (peg$silentFails === 0) { peg$fail(peg$e13); }
1141
+ if (peg$silentFails === 0) { peg$fail(peg$e6); }
1527
1142
  }
1528
1143
  if (s5 !== peg$FAILED) {
1529
1144
  s6 = peg$parse__();
@@ -1533,7 +1148,7 @@ function peg$parse(input, options) {
1533
1148
  s9 = peg$parseexpectPipelineExpression();
1534
1149
  if (s9 !== peg$FAILED) {
1535
1150
  peg$savedPos = s0;
1536
- s0 = peg$f11(s3, s9);
1151
+ s0 = peg$f5(s3, s9);
1537
1152
  } else {
1538
1153
  peg$currPos = s0;
1539
1154
  s0 = peg$FAILED;
@@ -1561,7 +1176,7 @@ function peg$parse(input, options) {
1561
1176
  s5 = peg$parseexpectPipelineExpression();
1562
1177
  if (s5 !== peg$FAILED) {
1563
1178
  peg$savedPos = s0;
1564
- s0 = peg$f12(s1, s5);
1179
+ s0 = peg$f6(s1, s5);
1565
1180
  } else {
1566
1181
  peg$currPos = s0;
1567
1182
  s0 = peg$FAILED;
@@ -1625,7 +1240,7 @@ function peg$parse(input, options) {
1625
1240
  }
1626
1241
  }
1627
1242
  peg$savedPos = s0;
1628
- s0 = peg$f13(s1, s2);
1243
+ s0 = peg$f7(s1, s2);
1629
1244
  } else {
1630
1245
  peg$currPos = s0;
1631
1246
  s0 = peg$FAILED;
@@ -1639,21 +1254,21 @@ function peg$parse(input, options) {
1639
1254
 
1640
1255
  s0 = peg$currPos;
1641
1256
  if (input.charCodeAt(peg$currPos) === 38) {
1642
- s1 = peg$c10;
1257
+ s1 = peg$c4;
1643
1258
  peg$currPos++;
1644
1259
  } else {
1645
1260
  s1 = peg$FAILED;
1646
- if (peg$silentFails === 0) { peg$fail(peg$e14); }
1261
+ if (peg$silentFails === 0) { peg$fail(peg$e7); }
1647
1262
  }
1648
1263
  if (s1 !== peg$FAILED) {
1649
1264
  s2 = peg$currPos;
1650
1265
  peg$silentFails++;
1651
1266
  if (input.charCodeAt(peg$currPos) === 38) {
1652
- s3 = peg$c10;
1267
+ s3 = peg$c4;
1653
1268
  peg$currPos++;
1654
1269
  } else {
1655
1270
  s3 = peg$FAILED;
1656
- if (peg$silentFails === 0) { peg$fail(peg$e14); }
1271
+ if (peg$silentFails === 0) { peg$fail(peg$e7); }
1657
1272
  }
1658
1273
  peg$silentFails--;
1659
1274
  if (s3 === peg$FAILED) {
@@ -1719,7 +1334,7 @@ function peg$parse(input, options) {
1719
1334
  }
1720
1335
  }
1721
1336
  peg$savedPos = s0;
1722
- s0 = peg$f14(s1, s2);
1337
+ s0 = peg$f8(s1, s2);
1723
1338
  } else {
1724
1339
  peg$currPos = s0;
1725
1340
  s0 = peg$FAILED;
@@ -1733,21 +1348,21 @@ function peg$parse(input, options) {
1733
1348
 
1734
1349
  s0 = peg$currPos;
1735
1350
  if (input.charCodeAt(peg$currPos) === 124) {
1736
- s1 = peg$c11;
1351
+ s1 = peg$c5;
1737
1352
  peg$currPos++;
1738
1353
  } else {
1739
1354
  s1 = peg$FAILED;
1740
- if (peg$silentFails === 0) { peg$fail(peg$e15); }
1355
+ if (peg$silentFails === 0) { peg$fail(peg$e8); }
1741
1356
  }
1742
1357
  if (s1 !== peg$FAILED) {
1743
1358
  s2 = peg$currPos;
1744
1359
  peg$silentFails++;
1745
1360
  if (input.charCodeAt(peg$currPos) === 124) {
1746
- s3 = peg$c11;
1361
+ s3 = peg$c5;
1747
1362
  peg$currPos++;
1748
1363
  } else {
1749
1364
  s3 = peg$FAILED;
1750
- if (peg$silentFails === 0) { peg$fail(peg$e15); }
1365
+ if (peg$silentFails === 0) { peg$fail(peg$e8); }
1751
1366
  }
1752
1367
  peg$silentFails--;
1753
1368
  if (s3 === peg$FAILED) {
@@ -1813,7 +1428,7 @@ function peg$parse(input, options) {
1813
1428
  }
1814
1429
  }
1815
1430
  peg$savedPos = s0;
1816
- s0 = peg$f15(s1, s2);
1431
+ s0 = peg$f9(s1, s2);
1817
1432
  } else {
1818
1433
  peg$currPos = s0;
1819
1434
  s0 = peg$FAILED;
@@ -1826,11 +1441,11 @@ function peg$parse(input, options) {
1826
1441
  var s0;
1827
1442
 
1828
1443
  if (input.charCodeAt(peg$currPos) === 94) {
1829
- s0 = peg$c12;
1444
+ s0 = peg$c6;
1830
1445
  peg$currPos++;
1831
1446
  } else {
1832
1447
  s0 = peg$FAILED;
1833
- if (peg$silentFails === 0) { peg$fail(peg$e16); }
1448
+ if (peg$silentFails === 0) { peg$fail(peg$e9); }
1834
1449
  }
1835
1450
 
1836
1451
  return s0;
@@ -1850,7 +1465,7 @@ function peg$parse(input, options) {
1850
1465
  s3 = peg$parsearguments();
1851
1466
  }
1852
1467
  peg$savedPos = s0;
1853
- s0 = peg$f16(s1, s2);
1468
+ s0 = peg$f10(s1, s2);
1854
1469
  } else {
1855
1470
  peg$currPos = s0;
1856
1471
  s0 = peg$FAILED;
@@ -1858,7 +1473,7 @@ function peg$parse(input, options) {
1858
1473
  peg$silentFails--;
1859
1474
  if (s0 === peg$FAILED) {
1860
1475
  s1 = peg$FAILED;
1861
- if (peg$silentFails === 0) { peg$fail(peg$e17); }
1476
+ if (peg$silentFails === 0) { peg$fail(peg$e10); }
1862
1477
  }
1863
1478
 
1864
1479
  return s0;
@@ -1877,11 +1492,11 @@ function peg$parse(input, options) {
1877
1492
  s4 = peg$currPos;
1878
1493
  s5 = peg$parse__();
1879
1494
  if (input.charCodeAt(peg$currPos) === 44) {
1880
- s6 = peg$c13;
1495
+ s6 = peg$c7;
1881
1496
  peg$currPos++;
1882
1497
  } else {
1883
1498
  s6 = peg$FAILED;
1884
- if (peg$silentFails === 0) { peg$fail(peg$e18); }
1499
+ if (peg$silentFails === 0) { peg$fail(peg$e11); }
1885
1500
  }
1886
1501
  if (s6 !== peg$FAILED) {
1887
1502
  s7 = peg$parse__();
@@ -1911,7 +1526,7 @@ function peg$parse(input, options) {
1911
1526
  }
1912
1527
  if (s1 !== peg$FAILED) {
1913
1528
  peg$savedPos = s0;
1914
- s1 = peg$f17(s1);
1529
+ s1 = peg$f11(s1);
1915
1530
  }
1916
1531
  s0 = s1;
1917
1532
 
@@ -1929,7 +1544,7 @@ function peg$parse(input, options) {
1929
1544
  peg$silentFails--;
1930
1545
  if (s0 === peg$FAILED) {
1931
1546
  s1 = peg$FAILED;
1932
- if (peg$silentFails === 0) { peg$fail(peg$e19); }
1547
+ if (peg$silentFails === 0) { peg$fail(peg$e12); }
1933
1548
  }
1934
1549
 
1935
1550
  return s0;
@@ -1941,11 +1556,11 @@ function peg$parse(input, options) {
1941
1556
  s0 = peg$currPos;
1942
1557
  s1 = peg$parse__();
1943
1558
  if (input.charCodeAt(peg$currPos) === 91) {
1944
- s2 = peg$c6;
1559
+ s2 = peg$c0;
1945
1560
  peg$currPos++;
1946
1561
  } else {
1947
1562
  s2 = peg$FAILED;
1948
- if (peg$silentFails === 0) { peg$fail(peg$e10); }
1563
+ if (peg$silentFails === 0) { peg$fail(peg$e3); }
1949
1564
  }
1950
1565
  if (s2 !== peg$FAILED) {
1951
1566
  s3 = peg$parseexpression();
@@ -1953,7 +1568,7 @@ function peg$parse(input, options) {
1953
1568
  s4 = peg$parseexpectClosingBracket();
1954
1569
  if (s4 !== peg$FAILED) {
1955
1570
  peg$savedPos = s0;
1956
- s0 = peg$f18(s3);
1571
+ s0 = peg$f12(s3);
1957
1572
  } else {
1958
1573
  peg$currPos = s0;
1959
1574
  s0 = peg$FAILED;
@@ -1979,11 +1594,11 @@ function peg$parse(input, options) {
1979
1594
  s2 = peg$currPos;
1980
1595
  s3 = peg$parse__();
1981
1596
  if (input.charCodeAt(peg$currPos) === 63) {
1982
- s4 = peg$c14;
1597
+ s4 = peg$c8;
1983
1598
  peg$currPos++;
1984
1599
  } else {
1985
1600
  s4 = peg$FAILED;
1986
- if (peg$silentFails === 0) { peg$fail(peg$e20); }
1601
+ if (peg$silentFails === 0) { peg$fail(peg$e13); }
1987
1602
  }
1988
1603
  if (s4 !== peg$FAILED) {
1989
1604
  s5 = peg$parse__();
@@ -1991,11 +1606,11 @@ function peg$parse(input, options) {
1991
1606
  if (s6 !== peg$FAILED) {
1992
1607
  s7 = peg$parse__();
1993
1608
  if (input.charCodeAt(peg$currPos) === 58) {
1994
- s8 = peg$c5;
1609
+ s8 = peg$c9;
1995
1610
  peg$currPos++;
1996
1611
  } else {
1997
1612
  s8 = peg$FAILED;
1998
- if (peg$silentFails === 0) { peg$fail(peg$e7); }
1613
+ if (peg$silentFails === 0) { peg$fail(peg$e14); }
1999
1614
  }
2000
1615
  if (s8 !== peg$FAILED) {
2001
1616
  s9 = peg$parse__();
@@ -2022,7 +1637,7 @@ function peg$parse(input, options) {
2022
1637
  s2 = null;
2023
1638
  }
2024
1639
  peg$savedPos = s0;
2025
- s0 = peg$f19(s1, s2);
1640
+ s0 = peg$f13(s1, s2);
2026
1641
  } else {
2027
1642
  peg$currPos = s0;
2028
1643
  s0 = peg$FAILED;
@@ -2037,21 +1652,21 @@ function peg$parse(input, options) {
2037
1652
  s0 = peg$currPos;
2038
1653
  s1 = [];
2039
1654
  s2 = input.charAt(peg$currPos);
2040
- if (peg$r2.test(s2)) {
1655
+ if (peg$r1.test(s2)) {
2041
1656
  peg$currPos++;
2042
1657
  } else {
2043
1658
  s2 = peg$FAILED;
2044
- if (peg$silentFails === 0) { peg$fail(peg$e21); }
1659
+ if (peg$silentFails === 0) { peg$fail(peg$e15); }
2045
1660
  }
2046
1661
  if (s2 !== peg$FAILED) {
2047
1662
  while (s2 !== peg$FAILED) {
2048
1663
  s1.push(s2);
2049
1664
  s2 = input.charAt(peg$currPos);
2050
- if (peg$r2.test(s2)) {
1665
+ if (peg$r1.test(s2)) {
2051
1666
  peg$currPos++;
2052
1667
  } else {
2053
1668
  s2 = peg$FAILED;
2054
- if (peg$silentFails === 0) { peg$fail(peg$e21); }
1669
+ if (peg$silentFails === 0) { peg$fail(peg$e15); }
2055
1670
  }
2056
1671
  }
2057
1672
  } else {
@@ -2071,19 +1686,19 @@ function peg$parse(input, options) {
2071
1686
  var s0;
2072
1687
 
2073
1688
  if (input.charCodeAt(peg$currPos) === 8658) {
2074
- s0 = peg$c15;
1689
+ s0 = peg$c10;
2075
1690
  peg$currPos++;
2076
1691
  } else {
2077
1692
  s0 = peg$FAILED;
2078
- if (peg$silentFails === 0) { peg$fail(peg$e22); }
1693
+ if (peg$silentFails === 0) { peg$fail(peg$e16); }
2079
1694
  }
2080
1695
  if (s0 === peg$FAILED) {
2081
- if (input.substr(peg$currPos, 2) === peg$c16) {
2082
- s0 = peg$c16;
1696
+ if (input.substr(peg$currPos, 2) === peg$c11) {
1697
+ s0 = peg$c11;
2083
1698
  peg$currPos += 2;
2084
1699
  } else {
2085
1700
  s0 = peg$FAILED;
2086
- if (peg$silentFails === 0) { peg$fail(peg$e23); }
1701
+ if (peg$silentFails === 0) { peg$fail(peg$e17); }
2087
1702
  }
2088
1703
  }
2089
1704
 
@@ -2096,11 +1711,11 @@ function peg$parse(input, options) {
2096
1711
  peg$silentFails++;
2097
1712
  s0 = peg$currPos;
2098
1713
  if (input.charCodeAt(peg$currPos) === 34) {
2099
- s1 = peg$c17;
1714
+ s1 = peg$c12;
2100
1715
  peg$currPos++;
2101
1716
  } else {
2102
1717
  s1 = peg$FAILED;
2103
- if (peg$silentFails === 0) { peg$fail(peg$e25); }
1718
+ if (peg$silentFails === 0) { peg$fail(peg$e19); }
2104
1719
  }
2105
1720
  if (s1 !== peg$FAILED) {
2106
1721
  s2 = [];
@@ -2112,7 +1727,7 @@ function peg$parse(input, options) {
2112
1727
  s3 = peg$parseexpectDoubleQuote();
2113
1728
  if (s3 !== peg$FAILED) {
2114
1729
  peg$savedPos = s0;
2115
- s0 = peg$f20(s2);
1730
+ s0 = peg$f14(s2);
2116
1731
  } else {
2117
1732
  peg$currPos = s0;
2118
1733
  s0 = peg$FAILED;
@@ -2124,7 +1739,7 @@ function peg$parse(input, options) {
2124
1739
  peg$silentFails--;
2125
1740
  if (s0 === peg$FAILED) {
2126
1741
  s1 = peg$FAILED;
2127
- if (peg$silentFails === 0) { peg$fail(peg$e24); }
1742
+ if (peg$silentFails === 0) { peg$fail(peg$e18); }
2128
1743
  }
2129
1744
 
2130
1745
  return s0;
@@ -2137,11 +1752,11 @@ function peg$parse(input, options) {
2137
1752
  s1 = peg$currPos;
2138
1753
  peg$silentFails++;
2139
1754
  if (input.charCodeAt(peg$currPos) === 34) {
2140
- s2 = peg$c17;
1755
+ s2 = peg$c12;
2141
1756
  peg$currPos++;
2142
1757
  } else {
2143
1758
  s2 = peg$FAILED;
2144
- if (peg$silentFails === 0) { peg$fail(peg$e25); }
1759
+ if (peg$silentFails === 0) { peg$fail(peg$e19); }
2145
1760
  }
2146
1761
  if (s2 === peg$FAILED) {
2147
1762
  s2 = peg$parsenewLine();
@@ -2172,20 +1787,20 @@ function peg$parse(input, options) {
2172
1787
  function peg$parseellipsis() {
2173
1788
  var s0;
2174
1789
 
2175
- if (input.substr(peg$currPos, 3) === peg$c18) {
2176
- s0 = peg$c18;
1790
+ if (input.substr(peg$currPos, 3) === peg$c13) {
1791
+ s0 = peg$c13;
2177
1792
  peg$currPos += 3;
2178
1793
  } else {
2179
1794
  s0 = peg$FAILED;
2180
- if (peg$silentFails === 0) { peg$fail(peg$e26); }
1795
+ if (peg$silentFails === 0) { peg$fail(peg$e20); }
2181
1796
  }
2182
1797
  if (s0 === peg$FAILED) {
2183
1798
  if (input.charCodeAt(peg$currPos) === 8230) {
2184
- s0 = peg$c19;
1799
+ s0 = peg$c14;
2185
1800
  peg$currPos++;
2186
1801
  } else {
2187
1802
  s0 = peg$FAILED;
2188
- if (peg$silentFails === 0) { peg$fail(peg$e27); }
1803
+ if (peg$silentFails === 0) { peg$fail(peg$e21); }
2189
1804
  }
2190
1805
  }
2191
1806
 
@@ -2235,7 +1850,7 @@ function peg$parse(input, options) {
2235
1850
  }
2236
1851
  }
2237
1852
  peg$savedPos = s0;
2238
- s0 = peg$f21(s1, s2);
1853
+ s0 = peg$f15(s1, s2);
2239
1854
  } else {
2240
1855
  peg$currPos = s0;
2241
1856
  s0 = peg$FAILED;
@@ -2247,36 +1862,36 @@ function peg$parse(input, options) {
2247
1862
  function peg$parseequalityOperator() {
2248
1863
  var s0;
2249
1864
 
2250
- if (input.substr(peg$currPos, 3) === peg$c20) {
2251
- s0 = peg$c20;
1865
+ if (input.substr(peg$currPos, 3) === peg$c15) {
1866
+ s0 = peg$c15;
2252
1867
  peg$currPos += 3;
2253
1868
  } else {
2254
1869
  s0 = peg$FAILED;
2255
- if (peg$silentFails === 0) { peg$fail(peg$e28); }
1870
+ if (peg$silentFails === 0) { peg$fail(peg$e22); }
2256
1871
  }
2257
1872
  if (s0 === peg$FAILED) {
2258
- if (input.substr(peg$currPos, 3) === peg$c21) {
2259
- s0 = peg$c21;
1873
+ if (input.substr(peg$currPos, 3) === peg$c16) {
1874
+ s0 = peg$c16;
2260
1875
  peg$currPos += 3;
2261
1876
  } else {
2262
1877
  s0 = peg$FAILED;
2263
- if (peg$silentFails === 0) { peg$fail(peg$e29); }
1878
+ if (peg$silentFails === 0) { peg$fail(peg$e23); }
2264
1879
  }
2265
1880
  if (s0 === peg$FAILED) {
2266
- if (input.substr(peg$currPos, 2) === peg$c22) {
2267
- s0 = peg$c22;
1881
+ if (input.substr(peg$currPos, 2) === peg$c17) {
1882
+ s0 = peg$c17;
2268
1883
  peg$currPos += 2;
2269
1884
  } else {
2270
1885
  s0 = peg$FAILED;
2271
- if (peg$silentFails === 0) { peg$fail(peg$e30); }
1886
+ if (peg$silentFails === 0) { peg$fail(peg$e24); }
2272
1887
  }
2273
1888
  if (s0 === peg$FAILED) {
2274
- if (input.substr(peg$currPos, 2) === peg$c23) {
2275
- s0 = peg$c23;
1889
+ if (input.substr(peg$currPos, 2) === peg$c18) {
1890
+ s0 = peg$c18;
2276
1891
  peg$currPos += 2;
2277
1892
  } else {
2278
1893
  s0 = peg$FAILED;
2279
- if (peg$silentFails === 0) { peg$fail(peg$e31); }
1894
+ if (peg$silentFails === 0) { peg$fail(peg$e25); }
2280
1895
  }
2281
1896
  }
2282
1897
  }
@@ -2290,110 +1905,110 @@ function peg$parse(input, options) {
2290
1905
 
2291
1906
  peg$silentFails++;
2292
1907
  s0 = peg$currPos;
2293
- if (input.substr(peg$currPos, 2) === peg$c24) {
2294
- s1 = peg$c24;
1908
+ if (input.substr(peg$currPos, 2) === peg$c19) {
1909
+ s1 = peg$c19;
2295
1910
  peg$currPos += 2;
2296
1911
  } else {
2297
1912
  s1 = peg$FAILED;
2298
- if (peg$silentFails === 0) { peg$fail(peg$e33); }
1913
+ if (peg$silentFails === 0) { peg$fail(peg$e27); }
2299
1914
  }
2300
1915
  if (s1 !== peg$FAILED) {
2301
1916
  peg$savedPos = s0;
2302
- s1 = peg$f22();
1917
+ s1 = peg$f16();
2303
1918
  }
2304
1919
  s0 = s1;
2305
1920
  if (s0 === peg$FAILED) {
2306
1921
  s0 = peg$currPos;
2307
- if (input.substr(peg$currPos, 2) === peg$c25) {
2308
- s1 = peg$c25;
1922
+ if (input.substr(peg$currPos, 2) === peg$c20) {
1923
+ s1 = peg$c20;
2309
1924
  peg$currPos += 2;
2310
1925
  } else {
2311
1926
  s1 = peg$FAILED;
2312
- if (peg$silentFails === 0) { peg$fail(peg$e34); }
1927
+ if (peg$silentFails === 0) { peg$fail(peg$e28); }
2313
1928
  }
2314
1929
  if (s1 !== peg$FAILED) {
2315
1930
  peg$savedPos = s0;
2316
- s1 = peg$f23();
1931
+ s1 = peg$f17();
2317
1932
  }
2318
1933
  s0 = s1;
2319
1934
  if (s0 === peg$FAILED) {
2320
1935
  s0 = peg$currPos;
2321
- if (input.substr(peg$currPos, 2) === peg$c26) {
2322
- s1 = peg$c26;
1936
+ if (input.substr(peg$currPos, 2) === peg$c21) {
1937
+ s1 = peg$c21;
2323
1938
  peg$currPos += 2;
2324
1939
  } else {
2325
1940
  s1 = peg$FAILED;
2326
- if (peg$silentFails === 0) { peg$fail(peg$e35); }
1941
+ if (peg$silentFails === 0) { peg$fail(peg$e29); }
2327
1942
  }
2328
1943
  if (s1 !== peg$FAILED) {
2329
1944
  peg$savedPos = s0;
2330
- s1 = peg$f24();
1945
+ s1 = peg$f18();
2331
1946
  }
2332
1947
  s0 = s1;
2333
1948
  if (s0 === peg$FAILED) {
2334
1949
  s0 = peg$currPos;
2335
- if (input.substr(peg$currPos, 2) === peg$c27) {
2336
- s1 = peg$c27;
1950
+ if (input.substr(peg$currPos, 2) === peg$c22) {
1951
+ s1 = peg$c22;
2337
1952
  peg$currPos += 2;
2338
1953
  } else {
2339
1954
  s1 = peg$FAILED;
2340
- if (peg$silentFails === 0) { peg$fail(peg$e36); }
1955
+ if (peg$silentFails === 0) { peg$fail(peg$e30); }
2341
1956
  }
2342
1957
  if (s1 !== peg$FAILED) {
2343
1958
  peg$savedPos = s0;
2344
- s1 = peg$f25();
1959
+ s1 = peg$f19();
2345
1960
  }
2346
1961
  s0 = s1;
2347
1962
  if (s0 === peg$FAILED) {
2348
1963
  s0 = peg$currPos;
2349
- if (input.substr(peg$currPos, 2) === peg$c28) {
2350
- s1 = peg$c28;
1964
+ if (input.substr(peg$currPos, 2) === peg$c23) {
1965
+ s1 = peg$c23;
2351
1966
  peg$currPos += 2;
2352
1967
  } else {
2353
1968
  s1 = peg$FAILED;
2354
- if (peg$silentFails === 0) { peg$fail(peg$e37); }
1969
+ if (peg$silentFails === 0) { peg$fail(peg$e31); }
2355
1970
  }
2356
1971
  if (s1 !== peg$FAILED) {
2357
1972
  peg$savedPos = s0;
2358
- s1 = peg$f26();
1973
+ s1 = peg$f20();
2359
1974
  }
2360
1975
  s0 = s1;
2361
1976
  if (s0 === peg$FAILED) {
2362
1977
  s0 = peg$currPos;
2363
- if (input.substr(peg$currPos, 2) === peg$c29) {
2364
- s1 = peg$c29;
1978
+ if (input.substr(peg$currPos, 2) === peg$c24) {
1979
+ s1 = peg$c24;
2365
1980
  peg$currPos += 2;
2366
1981
  } else {
2367
1982
  s1 = peg$FAILED;
2368
- if (peg$silentFails === 0) { peg$fail(peg$e38); }
1983
+ if (peg$silentFails === 0) { peg$fail(peg$e32); }
2369
1984
  }
2370
1985
  if (s1 !== peg$FAILED) {
2371
1986
  peg$savedPos = s0;
2372
- s1 = peg$f27();
1987
+ s1 = peg$f21();
2373
1988
  }
2374
1989
  s0 = s1;
2375
1990
  if (s0 === peg$FAILED) {
2376
1991
  s0 = peg$currPos;
2377
- if (input.substr(peg$currPos, 2) === peg$c30) {
2378
- s1 = peg$c30;
1992
+ if (input.substr(peg$currPos, 2) === peg$c25) {
1993
+ s1 = peg$c25;
2379
1994
  peg$currPos += 2;
2380
1995
  } else {
2381
1996
  s1 = peg$FAILED;
2382
- if (peg$silentFails === 0) { peg$fail(peg$e39); }
1997
+ if (peg$silentFails === 0) { peg$fail(peg$e33); }
2383
1998
  }
2384
1999
  if (s1 !== peg$FAILED) {
2385
2000
  peg$savedPos = s0;
2386
- s1 = peg$f28();
2001
+ s1 = peg$f22();
2387
2002
  }
2388
2003
  s0 = s1;
2389
2004
  if (s0 === peg$FAILED) {
2390
2005
  s0 = peg$currPos;
2391
2006
  if (input.charCodeAt(peg$currPos) === 92) {
2392
- s1 = peg$c31;
2007
+ s1 = peg$c26;
2393
2008
  peg$currPos++;
2394
2009
  } else {
2395
2010
  s1 = peg$FAILED;
2396
- if (peg$silentFails === 0) { peg$fail(peg$e40); }
2011
+ if (peg$silentFails === 0) { peg$fail(peg$e34); }
2397
2012
  }
2398
2013
  if (s1 !== peg$FAILED) {
2399
2014
  if (input.length > peg$currPos) {
@@ -2401,7 +2016,7 @@ function peg$parse(input, options) {
2401
2016
  peg$currPos++;
2402
2017
  } else {
2403
2018
  s2 = peg$FAILED;
2404
- if (peg$silentFails === 0) { peg$fail(peg$e41); }
2019
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
2405
2020
  }
2406
2021
  if (s2 !== peg$FAILED) {
2407
2022
  s0 = s2;
@@ -2423,7 +2038,7 @@ function peg$parse(input, options) {
2423
2038
  peg$silentFails--;
2424
2039
  if (s0 === peg$FAILED) {
2425
2040
  s1 = peg$FAILED;
2426
- if (peg$silentFails === 0) { peg$fail(peg$e32); }
2041
+ if (peg$silentFails === 0) { peg$fail(peg$e26); }
2427
2042
  }
2428
2043
 
2429
2044
  return s0;
@@ -2433,11 +2048,11 @@ function peg$parse(input, options) {
2433
2048
  var s0, s1;
2434
2049
 
2435
2050
  if (input.charCodeAt(peg$currPos) === 96) {
2436
- s0 = peg$c32;
2051
+ s0 = peg$c27;
2437
2052
  peg$currPos++;
2438
2053
  } else {
2439
2054
  s0 = peg$FAILED;
2440
- if (peg$silentFails === 0) { peg$fail(peg$e42); }
2055
+ if (peg$silentFails === 0) { peg$fail(peg$e36); }
2441
2056
  }
2442
2057
  if (s0 === peg$FAILED) {
2443
2058
  s0 = peg$currPos;
@@ -2446,13 +2061,13 @@ function peg$parse(input, options) {
2446
2061
  peg$currPos++;
2447
2062
  } else {
2448
2063
  s1 = peg$FAILED;
2449
- if (peg$silentFails === 0) { peg$fail(peg$e41); }
2064
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
2450
2065
  }
2451
2066
  if (s1 === peg$FAILED) {
2452
2067
  s1 = null;
2453
2068
  }
2454
2069
  peg$savedPos = s0;
2455
- s1 = peg$f29();
2070
+ s1 = peg$f23();
2456
2071
  s0 = s1;
2457
2072
  }
2458
2073
 
@@ -2463,11 +2078,11 @@ function peg$parse(input, options) {
2463
2078
  var s0, s1;
2464
2079
 
2465
2080
  if (input.charCodeAt(peg$currPos) === 125) {
2466
- s0 = peg$c33;
2081
+ s0 = peg$c28;
2467
2082
  peg$currPos++;
2468
2083
  } else {
2469
2084
  s0 = peg$FAILED;
2470
- if (peg$silentFails === 0) { peg$fail(peg$e43); }
2085
+ if (peg$silentFails === 0) { peg$fail(peg$e37); }
2471
2086
  }
2472
2087
  if (s0 === peg$FAILED) {
2473
2088
  s0 = peg$currPos;
@@ -2476,13 +2091,13 @@ function peg$parse(input, options) {
2476
2091
  peg$currPos++;
2477
2092
  } else {
2478
2093
  s1 = peg$FAILED;
2479
- if (peg$silentFails === 0) { peg$fail(peg$e41); }
2094
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
2480
2095
  }
2481
2096
  if (s1 === peg$FAILED) {
2482
2097
  s1 = null;
2483
2098
  }
2484
2099
  peg$savedPos = s0;
2485
- s1 = peg$f30();
2100
+ s1 = peg$f24();
2486
2101
  s0 = s1;
2487
2102
  }
2488
2103
 
@@ -2493,11 +2108,11 @@ function peg$parse(input, options) {
2493
2108
  var s0, s1;
2494
2109
 
2495
2110
  if (input.charCodeAt(peg$currPos) === 93) {
2496
- s0 = peg$c7;
2111
+ s0 = peg$c1;
2497
2112
  peg$currPos++;
2498
2113
  } else {
2499
2114
  s0 = peg$FAILED;
2500
- if (peg$silentFails === 0) { peg$fail(peg$e11); }
2115
+ if (peg$silentFails === 0) { peg$fail(peg$e4); }
2501
2116
  }
2502
2117
  if (s0 === peg$FAILED) {
2503
2118
  s0 = peg$currPos;
@@ -2506,13 +2121,13 @@ function peg$parse(input, options) {
2506
2121
  peg$currPos++;
2507
2122
  } else {
2508
2123
  s1 = peg$FAILED;
2509
- if (peg$silentFails === 0) { peg$fail(peg$e41); }
2124
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
2510
2125
  }
2511
2126
  if (s1 === peg$FAILED) {
2512
2127
  s1 = null;
2513
2128
  }
2514
2129
  peg$savedPos = s0;
2515
- s1 = peg$f31();
2130
+ s1 = peg$f25();
2516
2131
  s0 = s1;
2517
2132
  }
2518
2133
 
@@ -2523,11 +2138,11 @@ function peg$parse(input, options) {
2523
2138
  var s0, s1;
2524
2139
 
2525
2140
  if (input.charCodeAt(peg$currPos) === 41) {
2526
- s0 = peg$c9;
2141
+ s0 = peg$c3;
2527
2142
  peg$currPos++;
2528
2143
  } else {
2529
2144
  s0 = peg$FAILED;
2530
- if (peg$silentFails === 0) { peg$fail(peg$e13); }
2145
+ if (peg$silentFails === 0) { peg$fail(peg$e6); }
2531
2146
  }
2532
2147
  if (s0 === peg$FAILED) {
2533
2148
  s0 = peg$currPos;
@@ -2536,13 +2151,13 @@ function peg$parse(input, options) {
2536
2151
  peg$currPos++;
2537
2152
  } else {
2538
2153
  s1 = peg$FAILED;
2539
- if (peg$silentFails === 0) { peg$fail(peg$e41); }
2154
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
2540
2155
  }
2541
2156
  if (s1 === peg$FAILED) {
2542
2157
  s1 = null;
2543
2158
  }
2544
2159
  peg$savedPos = s0;
2545
- s1 = peg$f32();
2160
+ s1 = peg$f26();
2546
2161
  s0 = s1;
2547
2162
  }
2548
2163
 
@@ -2553,11 +2168,11 @@ function peg$parse(input, options) {
2553
2168
  var s0, s1;
2554
2169
 
2555
2170
  if (input.charCodeAt(peg$currPos) === 34) {
2556
- s0 = peg$c17;
2171
+ s0 = peg$c12;
2557
2172
  peg$currPos++;
2558
2173
  } else {
2559
2174
  s0 = peg$FAILED;
2560
- if (peg$silentFails === 0) { peg$fail(peg$e25); }
2175
+ if (peg$silentFails === 0) { peg$fail(peg$e19); }
2561
2176
  }
2562
2177
  if (s0 === peg$FAILED) {
2563
2178
  s0 = peg$currPos;
@@ -2566,13 +2181,13 @@ function peg$parse(input, options) {
2566
2181
  peg$currPos++;
2567
2182
  } else {
2568
2183
  s1 = peg$FAILED;
2569
- if (peg$silentFails === 0) { peg$fail(peg$e41); }
2184
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
2570
2185
  }
2571
2186
  if (s1 === peg$FAILED) {
2572
2187
  s1 = null;
2573
2188
  }
2574
2189
  peg$savedPos = s0;
2575
- s1 = peg$f33();
2190
+ s1 = peg$f27();
2576
2191
  s0 = s1;
2577
2192
  }
2578
2193
 
@@ -2590,13 +2205,13 @@ function peg$parse(input, options) {
2590
2205
  peg$currPos++;
2591
2206
  } else {
2592
2207
  s1 = peg$FAILED;
2593
- if (peg$silentFails === 0) { peg$fail(peg$e41); }
2208
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
2594
2209
  }
2595
2210
  if (s1 === peg$FAILED) {
2596
2211
  s1 = null;
2597
2212
  }
2598
2213
  peg$savedPos = s0;
2599
- s1 = peg$f34();
2214
+ s1 = peg$f28();
2600
2215
  s0 = s1;
2601
2216
  }
2602
2217
 
@@ -2614,13 +2229,13 @@ function peg$parse(input, options) {
2614
2229
  peg$currPos++;
2615
2230
  } else {
2616
2231
  s1 = peg$FAILED;
2617
- if (peg$silentFails === 0) { peg$fail(peg$e41); }
2232
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
2618
2233
  }
2619
2234
  if (s1 === peg$FAILED) {
2620
2235
  s1 = null;
2621
2236
  }
2622
2237
  peg$savedPos = s0;
2623
- s1 = peg$f35();
2238
+ s1 = peg$f29();
2624
2239
  s0 = s1;
2625
2240
  }
2626
2241
 
@@ -2631,11 +2246,11 @@ function peg$parse(input, options) {
2631
2246
  var s0, s1;
2632
2247
 
2633
2248
  if (input.charCodeAt(peg$currPos) === 187) {
2634
- s0 = peg$c34;
2249
+ s0 = peg$c29;
2635
2250
  peg$currPos++;
2636
2251
  } else {
2637
2252
  s0 = peg$FAILED;
2638
- if (peg$silentFails === 0) { peg$fail(peg$e44); }
2253
+ if (peg$silentFails === 0) { peg$fail(peg$e38); }
2639
2254
  }
2640
2255
  if (s0 === peg$FAILED) {
2641
2256
  s0 = peg$currPos;
@@ -2644,13 +2259,13 @@ function peg$parse(input, options) {
2644
2259
  peg$currPos++;
2645
2260
  } else {
2646
2261
  s1 = peg$FAILED;
2647
- if (peg$silentFails === 0) { peg$fail(peg$e41); }
2262
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
2648
2263
  }
2649
2264
  if (s1 === peg$FAILED) {
2650
2265
  s1 = null;
2651
2266
  }
2652
2267
  peg$savedPos = s0;
2653
- s1 = peg$f36();
2268
+ s1 = peg$f30();
2654
2269
  s0 = s1;
2655
2270
  }
2656
2271
 
@@ -2661,11 +2276,11 @@ function peg$parse(input, options) {
2661
2276
  var s0, s1;
2662
2277
 
2663
2278
  if (input.charCodeAt(peg$currPos) === 39) {
2664
- s0 = peg$c35;
2279
+ s0 = peg$c30;
2665
2280
  peg$currPos++;
2666
2281
  } else {
2667
2282
  s0 = peg$FAILED;
2668
- if (peg$silentFails === 0) { peg$fail(peg$e45); }
2283
+ if (peg$silentFails === 0) { peg$fail(peg$e39); }
2669
2284
  }
2670
2285
  if (s0 === peg$FAILED) {
2671
2286
  s0 = peg$currPos;
@@ -2674,13 +2289,13 @@ function peg$parse(input, options) {
2674
2289
  peg$currPos++;
2675
2290
  } else {
2676
2291
  s1 = peg$FAILED;
2677
- if (peg$silentFails === 0) { peg$fail(peg$e41); }
2292
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
2678
2293
  }
2679
2294
  if (s1 === peg$FAILED) {
2680
2295
  s1 = null;
2681
2296
  }
2682
2297
  peg$savedPos = s0;
2683
- s1 = peg$f37();
2298
+ s1 = peg$f31();
2684
2299
  s0 = s1;
2685
2300
  }
2686
2301
 
@@ -2698,13 +2313,13 @@ function peg$parse(input, options) {
2698
2313
  peg$currPos++;
2699
2314
  } else {
2700
2315
  s1 = peg$FAILED;
2701
- if (peg$silentFails === 0) { peg$fail(peg$e41); }
2316
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
2702
2317
  }
2703
2318
  if (s1 === peg$FAILED) {
2704
2319
  s1 = null;
2705
2320
  }
2706
2321
  peg$savedPos = s0;
2707
- s1 = peg$f38();
2322
+ s1 = peg$f32();
2708
2323
  s0 = s1;
2709
2324
  }
2710
2325
 
@@ -2719,12 +2334,12 @@ function peg$parse(input, options) {
2719
2334
  if (s1 !== peg$FAILED) {
2720
2335
  s2 = peg$currPos;
2721
2336
  s3 = peg$parse__();
2722
- if (input.substr(peg$currPos, 2) === peg$c36) {
2723
- s4 = peg$c36;
2337
+ if (input.substr(peg$currPos, 2) === peg$c31) {
2338
+ s4 = peg$c31;
2724
2339
  peg$currPos += 2;
2725
2340
  } else {
2726
2341
  s4 = peg$FAILED;
2727
- if (peg$silentFails === 0) { peg$fail(peg$e46); }
2342
+ if (peg$silentFails === 0) { peg$fail(peg$e40); }
2728
2343
  }
2729
2344
  if (s4 !== peg$FAILED) {
2730
2345
  s5 = peg$parse__();
@@ -2743,7 +2358,7 @@ function peg$parse(input, options) {
2743
2358
  s2 = null;
2744
2359
  }
2745
2360
  peg$savedPos = s0;
2746
- s0 = peg$f39(s1, s2);
2361
+ s0 = peg$f33(s1, s2);
2747
2362
  } else {
2748
2363
  peg$currPos = s0;
2749
2364
  s0 = peg$FAILED;
@@ -2779,17 +2394,17 @@ function peg$parse(input, options) {
2779
2394
  s1 = null;
2780
2395
  }
2781
2396
  if (input.charCodeAt(peg$currPos) === 46) {
2782
- s2 = peg$c37;
2397
+ s2 = peg$c32;
2783
2398
  peg$currPos++;
2784
2399
  } else {
2785
2400
  s2 = peg$FAILED;
2786
- if (peg$silentFails === 0) { peg$fail(peg$e48); }
2401
+ if (peg$silentFails === 0) { peg$fail(peg$e42); }
2787
2402
  }
2788
2403
  if (s2 !== peg$FAILED) {
2789
2404
  s3 = peg$parsedigits();
2790
2405
  if (s3 !== peg$FAILED) {
2791
2406
  peg$savedPos = s0;
2792
- s0 = peg$f40();
2407
+ s0 = peg$f34();
2793
2408
  } else {
2794
2409
  peg$currPos = s0;
2795
2410
  s0 = peg$FAILED;
@@ -2801,7 +2416,7 @@ function peg$parse(input, options) {
2801
2416
  peg$silentFails--;
2802
2417
  if (s0 === peg$FAILED) {
2803
2418
  s1 = peg$FAILED;
2804
- if (peg$silentFails === 0) { peg$fail(peg$e47); }
2419
+ if (peg$silentFails === 0) { peg$fail(peg$e41); }
2805
2420
  }
2806
2421
 
2807
2422
  return s0;
@@ -2810,12 +2425,12 @@ function peg$parse(input, options) {
2810
2425
  function peg$parsefrontDelimiter() {
2811
2426
  var s0;
2812
2427
 
2813
- if (input.substr(peg$currPos, 4) === peg$c38) {
2814
- s0 = peg$c38;
2428
+ if (input.substr(peg$currPos, 4) === peg$c33) {
2429
+ s0 = peg$c33;
2815
2430
  peg$currPos += 4;
2816
2431
  } else {
2817
2432
  s0 = peg$FAILED;
2818
- if (peg$silentFails === 0) { peg$fail(peg$e49); }
2433
+ if (peg$silentFails === 0) { peg$fail(peg$e43); }
2819
2434
  }
2820
2435
 
2821
2436
  return s0;
@@ -2828,7 +2443,7 @@ function peg$parse(input, options) {
2828
2443
  s1 = peg$parsefrontDelimiter();
2829
2444
  if (s1 !== peg$FAILED) {
2830
2445
  peg$savedPos = peg$currPos;
2831
- s2 = peg$f41();
2446
+ s2 = peg$f35();
2832
2447
  if (s2) {
2833
2448
  s2 = undefined;
2834
2449
  } else {
@@ -2882,7 +2497,7 @@ function peg$parse(input, options) {
2882
2497
  peg$currPos++;
2883
2498
  } else {
2884
2499
  s4 = peg$FAILED;
2885
- if (peg$silentFails === 0) { peg$fail(peg$e41); }
2500
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
2886
2501
  }
2887
2502
  if (s4 !== peg$FAILED) {
2888
2503
  s2 = s4;
@@ -2913,7 +2528,7 @@ function peg$parse(input, options) {
2913
2528
  peg$currPos++;
2914
2529
  } else {
2915
2530
  s4 = peg$FAILED;
2916
- if (peg$silentFails === 0) { peg$fail(peg$e41); }
2531
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
2917
2532
  }
2918
2533
  if (s4 !== peg$FAILED) {
2919
2534
  s2 = s4;
@@ -2927,7 +2542,7 @@ function peg$parse(input, options) {
2927
2542
  }
2928
2543
  }
2929
2544
  peg$savedPos = s0;
2930
- s1 = peg$f42(s1);
2545
+ s1 = peg$f36(s1);
2931
2546
  s0 = s1;
2932
2547
 
2933
2548
  return s0;
@@ -2944,7 +2559,7 @@ function peg$parse(input, options) {
2944
2559
  s3 = peg$parsefrontDelimiter();
2945
2560
  if (s3 !== peg$FAILED) {
2946
2561
  peg$savedPos = s0;
2947
- s0 = peg$f43(s2);
2562
+ s0 = peg$f37(s2);
2948
2563
  } else {
2949
2564
  peg$currPos = s0;
2950
2565
  s0 = peg$FAILED;
@@ -2956,7 +2571,7 @@ function peg$parse(input, options) {
2956
2571
  peg$silentFails--;
2957
2572
  if (s0 === peg$FAILED) {
2958
2573
  s1 = peg$FAILED;
2959
- if (peg$silentFails === 0) { peg$fail(peg$e50); }
2574
+ if (peg$silentFails === 0) { peg$fail(peg$e44); }
2960
2575
  }
2961
2576
 
2962
2577
  return s0;
@@ -2968,11 +2583,11 @@ function peg$parse(input, options) {
2968
2583
  peg$silentFails++;
2969
2584
  s0 = peg$currPos;
2970
2585
  if (input.charCodeAt(peg$currPos) === 40) {
2971
- s1 = peg$c8;
2586
+ s1 = peg$c2;
2972
2587
  peg$currPos++;
2973
2588
  } else {
2974
2589
  s1 = peg$FAILED;
2975
- if (peg$silentFails === 0) { peg$fail(peg$e12); }
2590
+ if (peg$silentFails === 0) { peg$fail(peg$e5); }
2976
2591
  }
2977
2592
  if (s1 !== peg$FAILED) {
2978
2593
  s2 = peg$parseexpression();
@@ -2980,7 +2595,7 @@ function peg$parse(input, options) {
2980
2595
  s3 = peg$parseexpectClosingParenthesis();
2981
2596
  if (s3 !== peg$FAILED) {
2982
2597
  peg$savedPos = s0;
2983
- s0 = peg$f44(s2);
2598
+ s0 = peg$f38(s2);
2984
2599
  } else {
2985
2600
  peg$currPos = s0;
2986
2601
  s0 = peg$FAILED;
@@ -2996,7 +2611,7 @@ function peg$parse(input, options) {
2996
2611
  peg$silentFails--;
2997
2612
  if (s0 === peg$FAILED) {
2998
2613
  s1 = peg$FAILED;
2999
- if (peg$silentFails === 0) { peg$fail(peg$e51); }
2614
+ if (peg$silentFails === 0) { peg$fail(peg$e45); }
3000
2615
  }
3001
2616
 
3002
2617
  return s0;
@@ -3008,11 +2623,11 @@ function peg$parse(input, options) {
3008
2623
  peg$silentFails++;
3009
2624
  s0 = peg$currPos;
3010
2625
  if (input.charCodeAt(peg$currPos) === 171) {
3011
- s1 = peg$c39;
2626
+ s1 = peg$c34;
3012
2627
  peg$currPos++;
3013
2628
  } else {
3014
2629
  s1 = peg$FAILED;
3015
- if (peg$silentFails === 0) { peg$fail(peg$e53); }
2630
+ if (peg$silentFails === 0) { peg$fail(peg$e47); }
3016
2631
  }
3017
2632
  if (s1 !== peg$FAILED) {
3018
2633
  s2 = [];
@@ -3024,7 +2639,7 @@ function peg$parse(input, options) {
3024
2639
  s3 = peg$parseexpectGuillemet();
3025
2640
  if (s3 !== peg$FAILED) {
3026
2641
  peg$savedPos = s0;
3027
- s0 = peg$f45(s2);
2642
+ s0 = peg$f39(s2);
3028
2643
  } else {
3029
2644
  peg$currPos = s0;
3030
2645
  s0 = peg$FAILED;
@@ -3036,7 +2651,7 @@ function peg$parse(input, options) {
3036
2651
  peg$silentFails--;
3037
2652
  if (s0 === peg$FAILED) {
3038
2653
  s1 = peg$FAILED;
3039
- if (peg$silentFails === 0) { peg$fail(peg$e52); }
2654
+ if (peg$silentFails === 0) { peg$fail(peg$e46); }
3040
2655
  }
3041
2656
 
3042
2657
  return s0;
@@ -3049,11 +2664,11 @@ function peg$parse(input, options) {
3049
2664
  s1 = peg$currPos;
3050
2665
  peg$silentFails++;
3051
2666
  if (input.charCodeAt(peg$currPos) === 187) {
3052
- s2 = peg$c34;
2667
+ s2 = peg$c29;
3053
2668
  peg$currPos++;
3054
2669
  } else {
3055
2670
  s2 = peg$FAILED;
3056
- if (peg$silentFails === 0) { peg$fail(peg$e44); }
2671
+ if (peg$silentFails === 0) { peg$fail(peg$e38); }
3057
2672
  }
3058
2673
  if (s2 === peg$FAILED) {
3059
2674
  s2 = peg$parsenewLine();
@@ -3086,15 +2701,15 @@ function peg$parse(input, options) {
3086
2701
 
3087
2702
  s0 = peg$currPos;
3088
2703
  if (input.charCodeAt(peg$currPos) === 126) {
3089
- s1 = peg$c4;
2704
+ s1 = peg$c35;
3090
2705
  peg$currPos++;
3091
2706
  } else {
3092
2707
  s1 = peg$FAILED;
3093
- if (peg$silentFails === 0) { peg$fail(peg$e5); }
2708
+ if (peg$silentFails === 0) { peg$fail(peg$e48); }
3094
2709
  }
3095
2710
  if (s1 !== peg$FAILED) {
3096
2711
  peg$savedPos = s0;
3097
- s1 = peg$f46();
2712
+ s1 = peg$f40();
3098
2713
  }
3099
2714
  s0 = s1;
3100
2715
 
@@ -3110,11 +2725,11 @@ function peg$parse(input, options) {
3110
2725
  if (s1 !== peg$FAILED) {
3111
2726
  s2 = peg$currPos;
3112
2727
  if (input.charCodeAt(peg$currPos) === 58) {
3113
- s3 = peg$c5;
2728
+ s3 = peg$c9;
3114
2729
  peg$currPos++;
3115
2730
  } else {
3116
2731
  s3 = peg$FAILED;
3117
- if (peg$silentFails === 0) { peg$fail(peg$e7); }
2732
+ if (peg$silentFails === 0) { peg$fail(peg$e14); }
3118
2733
  }
3119
2734
  if (s3 !== peg$FAILED) {
3120
2735
  s4 = peg$parseintegerLiteral();
@@ -3136,7 +2751,7 @@ function peg$parse(input, options) {
3136
2751
  s3 = null;
3137
2752
  }
3138
2753
  peg$savedPos = s0;
3139
- s0 = peg$f47(s1, s2, s3);
2754
+ s0 = peg$f41(s1, s2, s3);
3140
2755
  } else {
3141
2756
  peg$currPos = s0;
3142
2757
  s0 = peg$FAILED;
@@ -3144,7 +2759,7 @@ function peg$parse(input, options) {
3144
2759
  peg$silentFails--;
3145
2760
  if (s0 === peg$FAILED) {
3146
2761
  s1 = peg$FAILED;
3147
- if (peg$silentFails === 0) { peg$fail(peg$e54); }
2762
+ if (peg$silentFails === 0) { peg$fail(peg$e49); }
3148
2763
  }
3149
2764
 
3150
2765
  return s0;
@@ -3167,13 +2782,13 @@ function peg$parse(input, options) {
3167
2782
  }
3168
2783
  if (s1 !== peg$FAILED) {
3169
2784
  peg$savedPos = s0;
3170
- s1 = peg$f48(s1);
2785
+ s1 = peg$f42(s1);
3171
2786
  }
3172
2787
  s0 = s1;
3173
2788
  peg$silentFails--;
3174
2789
  if (s0 === peg$FAILED) {
3175
2790
  s1 = peg$FAILED;
3176
- if (peg$silentFails === 0) { peg$fail(peg$e55); }
2791
+ if (peg$silentFails === 0) { peg$fail(peg$e50); }
3177
2792
  }
3178
2793
 
3179
2794
  return s0;
@@ -3183,30 +2798,30 @@ function peg$parse(input, options) {
3183
2798
  var s0, s1, s2, s3;
3184
2799
 
3185
2800
  s0 = input.charAt(peg$currPos);
3186
- if (peg$r3.test(s0)) {
2801
+ if (peg$r2.test(s0)) {
3187
2802
  peg$currPos++;
3188
2803
  } else {
3189
2804
  s0 = peg$FAILED;
3190
- if (peg$silentFails === 0) { peg$fail(peg$e56); }
2805
+ if (peg$silentFails === 0) { peg$fail(peg$e51); }
3191
2806
  }
3192
2807
  if (s0 === peg$FAILED) {
3193
2808
  s0 = peg$currPos;
3194
2809
  if (input.charCodeAt(peg$currPos) === 45) {
3195
- s1 = peg$c40;
2810
+ s1 = peg$c36;
3196
2811
  peg$currPos++;
3197
2812
  } else {
3198
2813
  s1 = peg$FAILED;
3199
- if (peg$silentFails === 0) { peg$fail(peg$e57); }
2814
+ if (peg$silentFails === 0) { peg$fail(peg$e52); }
3200
2815
  }
3201
2816
  if (s1 !== peg$FAILED) {
3202
2817
  s2 = peg$currPos;
3203
2818
  peg$silentFails++;
3204
2819
  if (input.charCodeAt(peg$currPos) === 62) {
3205
- s3 = peg$c2;
2820
+ s3 = peg$c37;
3206
2821
  peg$currPos++;
3207
2822
  } else {
3208
2823
  s3 = peg$FAILED;
3209
- if (peg$silentFails === 0) { peg$fail(peg$e3); }
2824
+ if (peg$silentFails === 0) { peg$fail(peg$e53); }
3210
2825
  }
3211
2826
  peg$silentFails--;
3212
2827
  if (s3 === peg$FAILED) {
@@ -3267,7 +2882,7 @@ function peg$parse(input, options) {
3267
2882
  s2 = null;
3268
2883
  }
3269
2884
  peg$savedPos = s0;
3270
- s0 = peg$f49(s1, s2);
2885
+ s0 = peg$f43(s1, s2);
3271
2886
  } else {
3272
2887
  peg$currPos = s0;
3273
2888
  s0 = peg$FAILED;
@@ -3275,54 +2890,48 @@ function peg$parse(input, options) {
3275
2890
  peg$silentFails--;
3276
2891
  if (s0 === peg$FAILED) {
3277
2892
  s1 = peg$FAILED;
3278
- if (peg$silentFails === 0) { peg$fail(peg$e58); }
2893
+ if (peg$silentFails === 0) { peg$fail(peg$e54); }
3279
2894
  }
3280
2895
 
3281
2896
  return s0;
3282
2897
  }
3283
2898
 
3284
2899
  function peg$parseimplicitParensthesesArguments() {
3285
- var s0, s1, s2, s3, s4, s5;
2900
+ var s0, s1, s2, s3, s4;
3286
2901
 
3287
2902
  s0 = peg$currPos;
3288
- s1 = peg$parseshellMode();
3289
- if (s1 !== peg$FAILED) {
3290
- s2 = peg$currPos;
3291
- s3 = [];
3292
- s4 = peg$parseshorthandFunction();
3293
- while (s4 !== peg$FAILED) {
3294
- s3.push(s4);
3295
- s4 = peg$currPos;
3296
- s5 = peg$parseseparator();
3297
- if (s5 !== peg$FAILED) {
3298
- s5 = peg$parseshorthandFunction();
3299
- if (s5 === peg$FAILED) {
3300
- peg$currPos = s4;
3301
- s4 = peg$FAILED;
3302
- } else {
3303
- s4 = s5;
3304
- }
3305
- } else {
3306
- s4 = s5;
3307
- }
3308
- }
3309
- if (s3.length < 1) {
3310
- peg$currPos = s2;
3311
- s2 = peg$FAILED;
3312
- } else {
3313
- s2 = s3;
3314
- }
3315
- if (s2 !== peg$FAILED) {
3316
- s3 = peg$parseseparator();
3317
- if (s3 === peg$FAILED) {
3318
- s3 = null;
2903
+ s1 = peg$currPos;
2904
+ s2 = [];
2905
+ s3 = peg$parseshorthandFunction();
2906
+ while (s3 !== peg$FAILED) {
2907
+ s2.push(s3);
2908
+ s3 = peg$currPos;
2909
+ s4 = peg$parseseparator();
2910
+ if (s4 !== peg$FAILED) {
2911
+ s4 = peg$parseshorthandFunction();
2912
+ if (s4 === peg$FAILED) {
2913
+ peg$currPos = s3;
2914
+ s3 = peg$FAILED;
2915
+ } else {
2916
+ s3 = s4;
3319
2917
  }
3320
- peg$savedPos = s0;
3321
- s0 = peg$f50(s2);
3322
2918
  } else {
3323
- peg$currPos = s0;
3324
- s0 = peg$FAILED;
2919
+ s3 = s4;
3325
2920
  }
2921
+ }
2922
+ if (s2.length < 1) {
2923
+ peg$currPos = s1;
2924
+ s1 = peg$FAILED;
2925
+ } else {
2926
+ s1 = s2;
2927
+ }
2928
+ if (s1 !== peg$FAILED) {
2929
+ s2 = peg$parseseparator();
2930
+ if (s2 === peg$FAILED) {
2931
+ s2 = null;
2932
+ }
2933
+ peg$savedPos = s0;
2934
+ s0 = peg$f44(s1);
3326
2935
  } else {
3327
2936
  peg$currPos = s0;
3328
2937
  s0 = peg$FAILED;
@@ -3331,15 +2940,35 @@ function peg$parse(input, options) {
3331
2940
  return s0;
3332
2941
  }
3333
2942
 
2943
+ function peg$parseinherited() {
2944
+ var s0;
2945
+
2946
+ s0 = peg$parserootDirectory();
2947
+ if (s0 === peg$FAILED) {
2948
+ s0 = peg$parsehomeDirectory();
2949
+ if (s0 === peg$FAILED) {
2950
+ s0 = peg$parsequalifiedReference();
2951
+ if (s0 === peg$FAILED) {
2952
+ s0 = peg$parsenamespace();
2953
+ if (s0 === peg$FAILED) {
2954
+ s0 = peg$parsescopeReference();
2955
+ }
2956
+ }
2957
+ }
2958
+ }
2959
+
2960
+ return s0;
2961
+ }
2962
+
3334
2963
  function peg$parseinlineSpace() {
3335
2964
  var s0;
3336
2965
 
3337
2966
  s0 = input.charAt(peg$currPos);
3338
- if (peg$r4.test(s0)) {
2967
+ if (peg$r3.test(s0)) {
3339
2968
  peg$currPos++;
3340
2969
  } else {
3341
2970
  s0 = peg$FAILED;
3342
- if (peg$silentFails === 0) { peg$fail(peg$e59); }
2971
+ if (peg$silentFails === 0) { peg$fail(peg$e55); }
3343
2972
  }
3344
2973
 
3345
2974
  return s0;
@@ -3353,62 +2982,42 @@ function peg$parse(input, options) {
3353
2982
  s1 = peg$parsedigits();
3354
2983
  if (s1 !== peg$FAILED) {
3355
2984
  peg$savedPos = s0;
3356
- s1 = peg$f51();
2985
+ s1 = peg$f45();
3357
2986
  }
3358
2987
  s0 = s1;
3359
2988
  peg$silentFails--;
3360
2989
  if (s0 === peg$FAILED) {
3361
2990
  s1 = peg$FAILED;
3362
- if (peg$silentFails === 0) { peg$fail(peg$e60); }
3363
- }
3364
-
3365
- return s0;
3366
- }
3367
-
3368
- function peg$parsejseMode() {
3369
- var s0;
3370
-
3371
- peg$savedPos = peg$currPos;
3372
- s0 = peg$f52();
3373
- if (s0) {
3374
- s0 = undefined;
3375
- } else {
3376
- s0 = peg$FAILED;
2991
+ if (peg$silentFails === 0) { peg$fail(peg$e56); }
3377
2992
  }
3378
2993
 
3379
2994
  return s0;
3380
2995
  }
3381
2996
 
3382
2997
  function peg$parsejsIdentifier() {
3383
- var s0, s1, s2, s3, s4, s5;
2998
+ var s0, s1, s2, s3, s4;
3384
2999
 
3385
3000
  s0 = peg$currPos;
3386
3001
  s1 = peg$currPos;
3387
- s2 = peg$currPos;
3388
- s3 = peg$parsejsIdentifierStart();
3389
- if (s3 !== peg$FAILED) {
3390
- s4 = [];
3391
- s5 = peg$parsejsIdentifierPart();
3392
- while (s5 !== peg$FAILED) {
3393
- s4.push(s5);
3394
- s5 = peg$parsejsIdentifierPart();
3395
- }
3396
- s3 = [s3, s4];
3397
- s2 = s3;
3398
- } else {
3399
- peg$currPos = s2;
3400
- s2 = peg$FAILED;
3401
- }
3002
+ s2 = peg$parsejsIdentifierStart();
3402
3003
  if (s2 !== peg$FAILED) {
3403
- s1 = input.substring(s1, peg$currPos);
3404
- } else {
3004
+ s3 = [];
3005
+ s4 = peg$parsejsIdentifierPart();
3006
+ while (s4 !== peg$FAILED) {
3007
+ s3.push(s4);
3008
+ s4 = peg$parsejsIdentifierPart();
3009
+ }
3010
+ s2 = [s2, s3];
3405
3011
  s1 = s2;
3012
+ } else {
3013
+ peg$currPos = s1;
3014
+ s1 = peg$FAILED;
3406
3015
  }
3407
3016
  if (s1 !== peg$FAILED) {
3408
- peg$savedPos = s0;
3409
- s1 = peg$f53(s1);
3017
+ s0 = input.substring(s0, peg$currPos);
3018
+ } else {
3019
+ s0 = s1;
3410
3020
  }
3411
- s0 = s1;
3412
3021
 
3413
3022
  return s0;
3414
3023
  }
@@ -3423,11 +3032,11 @@ function peg$parse(input, options) {
3423
3032
  peg$currPos++;
3424
3033
  } else {
3425
3034
  s1 = peg$FAILED;
3426
- if (peg$silentFails === 0) { peg$fail(peg$e41); }
3035
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
3427
3036
  }
3428
3037
  if (s1 !== peg$FAILED) {
3429
3038
  peg$savedPos = peg$currPos;
3430
- s2 = peg$f54(s1);
3039
+ s2 = peg$f46(s1);
3431
3040
  if (s2) {
3432
3041
  s2 = undefined;
3433
3042
  } else {
@@ -3447,7 +3056,7 @@ function peg$parse(input, options) {
3447
3056
  peg$silentFails--;
3448
3057
  if (s0 === peg$FAILED) {
3449
3058
  s1 = peg$FAILED;
3450
- if (peg$silentFails === 0) { peg$fail(peg$e61); }
3059
+ if (peg$silentFails === 0) { peg$fail(peg$e57); }
3451
3060
  }
3452
3061
 
3453
3062
  return s0;
@@ -3463,11 +3072,11 @@ function peg$parse(input, options) {
3463
3072
  peg$currPos++;
3464
3073
  } else {
3465
3074
  s1 = peg$FAILED;
3466
- if (peg$silentFails === 0) { peg$fail(peg$e41); }
3075
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
3467
3076
  }
3468
3077
  if (s1 !== peg$FAILED) {
3469
3078
  peg$savedPos = peg$currPos;
3470
- s2 = peg$f55(s1);
3079
+ s2 = peg$f47(s1);
3471
3080
  if (s2) {
3472
3081
  s2 = undefined;
3473
3082
  } else {
@@ -3487,7 +3096,7 @@ function peg$parse(input, options) {
3487
3096
  peg$silentFails--;
3488
3097
  if (s0 === peg$FAILED) {
3489
3098
  s1 = peg$FAILED;
3490
- if (peg$silentFails === 0) { peg$fail(peg$e62); }
3099
+ if (peg$silentFails === 0) { peg$fail(peg$e58); }
3491
3100
  }
3492
3101
 
3493
3102
  return s0;
@@ -3499,18 +3108,18 @@ function peg$parse(input, options) {
3499
3108
  s0 = peg$currPos;
3500
3109
  s1 = peg$parse__();
3501
3110
  if (input.charCodeAt(peg$currPos) === 46) {
3502
- s2 = peg$c37;
3111
+ s2 = peg$c32;
3503
3112
  peg$currPos++;
3504
3113
  } else {
3505
3114
  s2 = peg$FAILED;
3506
- if (peg$silentFails === 0) { peg$fail(peg$e48); }
3115
+ if (peg$silentFails === 0) { peg$fail(peg$e42); }
3507
3116
  }
3508
3117
  if (s2 !== peg$FAILED) {
3509
3118
  s3 = peg$parse__();
3510
3119
  s4 = peg$parsejsIdentifier();
3511
3120
  if (s4 !== peg$FAILED) {
3512
3121
  peg$savedPos = s0;
3513
- s0 = peg$f56(s4);
3122
+ s0 = peg$f48(s4);
3514
3123
  } else {
3515
3124
  peg$currPos = s0;
3516
3125
  s0 = peg$FAILED;
@@ -3523,26 +3132,6 @@ function peg$parse(input, options) {
3523
3132
  return s0;
3524
3133
  }
3525
3134
 
3526
- function peg$parsejsReference() {
3527
- var s0, s1;
3528
-
3529
- peg$silentFails++;
3530
- s0 = peg$currPos;
3531
- s1 = peg$parsejsIdentifier();
3532
- if (s1 !== peg$FAILED) {
3533
- peg$savedPos = s0;
3534
- s1 = peg$f57(s1);
3535
- }
3536
- s0 = s1;
3537
- peg$silentFails--;
3538
- if (s0 === peg$FAILED) {
3539
- s1 = peg$FAILED;
3540
- if (peg$silentFails === 0) { peg$fail(peg$e63); }
3541
- }
3542
-
3543
- return s0;
3544
- }
3545
-
3546
3135
  function peg$parselist() {
3547
3136
  var s0, s1, s2, s3, s4;
3548
3137
 
@@ -3579,7 +3168,7 @@ function peg$parse(input, options) {
3579
3168
  s2 = null;
3580
3169
  }
3581
3170
  peg$savedPos = s0;
3582
- s0 = peg$f58(s1);
3171
+ s0 = peg$f49(s1);
3583
3172
  } else {
3584
3173
  peg$currPos = s0;
3585
3174
  s0 = peg$FAILED;
@@ -3587,7 +3176,18 @@ function peg$parse(input, options) {
3587
3176
  peg$silentFails--;
3588
3177
  if (s0 === peg$FAILED) {
3589
3178
  s1 = peg$FAILED;
3590
- if (peg$silentFails === 0) { peg$fail(peg$e64); }
3179
+ if (peg$silentFails === 0) { peg$fail(peg$e59); }
3180
+ }
3181
+
3182
+ return s0;
3183
+ }
3184
+
3185
+ function peg$parseliteral() {
3186
+ var s0;
3187
+
3188
+ s0 = peg$parsenumericLiteral();
3189
+ if (s0 === peg$FAILED) {
3190
+ s0 = peg$parsestringLiteral();
3591
3191
  }
3592
3192
 
3593
3193
  return s0;
@@ -3602,12 +3202,12 @@ function peg$parse(input, options) {
3602
3202
  s2 = [];
3603
3203
  s3 = peg$currPos;
3604
3204
  s4 = peg$parse__();
3605
- if (input.substr(peg$currPos, 2) === peg$c41) {
3606
- s5 = peg$c41;
3205
+ if (input.substr(peg$currPos, 2) === peg$c38) {
3206
+ s5 = peg$c38;
3607
3207
  peg$currPos += 2;
3608
3208
  } else {
3609
3209
  s5 = peg$FAILED;
3610
- if (peg$silentFails === 0) { peg$fail(peg$e65); }
3210
+ if (peg$silentFails === 0) { peg$fail(peg$e60); }
3611
3211
  }
3612
3212
  if (s5 !== peg$FAILED) {
3613
3213
  s6 = peg$parse__();
@@ -3626,12 +3226,12 @@ function peg$parse(input, options) {
3626
3226
  s2.push(s3);
3627
3227
  s3 = peg$currPos;
3628
3228
  s4 = peg$parse__();
3629
- if (input.substr(peg$currPos, 2) === peg$c41) {
3630
- s5 = peg$c41;
3229
+ if (input.substr(peg$currPos, 2) === peg$c38) {
3230
+ s5 = peg$c38;
3631
3231
  peg$currPos += 2;
3632
3232
  } else {
3633
3233
  s5 = peg$FAILED;
3634
- if (peg$silentFails === 0) { peg$fail(peg$e65); }
3234
+ if (peg$silentFails === 0) { peg$fail(peg$e60); }
3635
3235
  }
3636
3236
  if (s5 !== peg$FAILED) {
3637
3237
  s6 = peg$parse__();
@@ -3648,7 +3248,7 @@ function peg$parse(input, options) {
3648
3248
  }
3649
3249
  }
3650
3250
  peg$savedPos = s0;
3651
- s0 = peg$f59(s1, s2);
3251
+ s0 = peg$f50(s1, s2);
3652
3252
  } else {
3653
3253
  peg$currPos = s0;
3654
3254
  s0 = peg$FAILED;
@@ -3666,12 +3266,12 @@ function peg$parse(input, options) {
3666
3266
  s2 = [];
3667
3267
  s3 = peg$currPos;
3668
3268
  s4 = peg$parse__();
3669
- if (input.substr(peg$currPos, 2) === peg$c42) {
3670
- s5 = peg$c42;
3269
+ if (input.substr(peg$currPos, 2) === peg$c39) {
3270
+ s5 = peg$c39;
3671
3271
  peg$currPos += 2;
3672
3272
  } else {
3673
3273
  s5 = peg$FAILED;
3674
- if (peg$silentFails === 0) { peg$fail(peg$e66); }
3274
+ if (peg$silentFails === 0) { peg$fail(peg$e61); }
3675
3275
  }
3676
3276
  if (s5 !== peg$FAILED) {
3677
3277
  s6 = peg$parse__();
@@ -3690,12 +3290,12 @@ function peg$parse(input, options) {
3690
3290
  s2.push(s3);
3691
3291
  s3 = peg$currPos;
3692
3292
  s4 = peg$parse__();
3693
- if (input.substr(peg$currPos, 2) === peg$c42) {
3694
- s5 = peg$c42;
3293
+ if (input.substr(peg$currPos, 2) === peg$c39) {
3294
+ s5 = peg$c39;
3695
3295
  peg$currPos += 2;
3696
3296
  } else {
3697
3297
  s5 = peg$FAILED;
3698
- if (peg$silentFails === 0) { peg$fail(peg$e66); }
3298
+ if (peg$silentFails === 0) { peg$fail(peg$e61); }
3699
3299
  }
3700
3300
  if (s5 !== peg$FAILED) {
3701
3301
  s6 = peg$parse__();
@@ -3712,7 +3312,7 @@ function peg$parse(input, options) {
3712
3312
  }
3713
3313
  }
3714
3314
  peg$savedPos = s0;
3715
- s0 = peg$f60(s1, s2);
3315
+ s0 = peg$f51(s1, s2);
3716
3316
  } else {
3717
3317
  peg$currPos = s0;
3718
3318
  s0 = peg$FAILED;
@@ -3725,24 +3325,24 @@ function peg$parse(input, options) {
3725
3325
  var s0, s1, s2, s3, s4, s5;
3726
3326
 
3727
3327
  s0 = peg$currPos;
3728
- if (input.substr(peg$currPos, 2) === peg$c43) {
3729
- s1 = peg$c43;
3328
+ if (input.substr(peg$currPos, 2) === peg$c40) {
3329
+ s1 = peg$c40;
3730
3330
  peg$currPos += 2;
3731
3331
  } else {
3732
3332
  s1 = peg$FAILED;
3733
- if (peg$silentFails === 0) { peg$fail(peg$e67); }
3333
+ if (peg$silentFails === 0) { peg$fail(peg$e62); }
3734
3334
  }
3735
3335
  if (s1 !== peg$FAILED) {
3736
3336
  s2 = [];
3737
3337
  s3 = peg$currPos;
3738
3338
  s4 = peg$currPos;
3739
3339
  peg$silentFails++;
3740
- if (input.substr(peg$currPos, 2) === peg$c44) {
3741
- s5 = peg$c44;
3340
+ if (input.substr(peg$currPos, 2) === peg$c41) {
3341
+ s5 = peg$c41;
3742
3342
  peg$currPos += 2;
3743
3343
  } else {
3744
3344
  s5 = peg$FAILED;
3745
- if (peg$silentFails === 0) { peg$fail(peg$e68); }
3345
+ if (peg$silentFails === 0) { peg$fail(peg$e63); }
3746
3346
  }
3747
3347
  peg$silentFails--;
3748
3348
  if (s5 === peg$FAILED) {
@@ -3757,7 +3357,7 @@ function peg$parse(input, options) {
3757
3357
  peg$currPos++;
3758
3358
  } else {
3759
3359
  s5 = peg$FAILED;
3760
- if (peg$silentFails === 0) { peg$fail(peg$e41); }
3360
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
3761
3361
  }
3762
3362
  if (s5 !== peg$FAILED) {
3763
3363
  s4 = [s4, s5];
@@ -3775,12 +3375,12 @@ function peg$parse(input, options) {
3775
3375
  s3 = peg$currPos;
3776
3376
  s4 = peg$currPos;
3777
3377
  peg$silentFails++;
3778
- if (input.substr(peg$currPos, 2) === peg$c44) {
3779
- s5 = peg$c44;
3378
+ if (input.substr(peg$currPos, 2) === peg$c41) {
3379
+ s5 = peg$c41;
3780
3380
  peg$currPos += 2;
3781
3381
  } else {
3782
3382
  s5 = peg$FAILED;
3783
- if (peg$silentFails === 0) { peg$fail(peg$e68); }
3383
+ if (peg$silentFails === 0) { peg$fail(peg$e63); }
3784
3384
  }
3785
3385
  peg$silentFails--;
3786
3386
  if (s5 === peg$FAILED) {
@@ -3795,7 +3395,7 @@ function peg$parse(input, options) {
3795
3395
  peg$currPos++;
3796
3396
  } else {
3797
3397
  s5 = peg$FAILED;
3798
- if (peg$silentFails === 0) { peg$fail(peg$e41); }
3398
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
3799
3399
  }
3800
3400
  if (s5 !== peg$FAILED) {
3801
3401
  s4 = [s4, s5];
@@ -3809,16 +3409,16 @@ function peg$parse(input, options) {
3809
3409
  s3 = peg$FAILED;
3810
3410
  }
3811
3411
  }
3812
- if (input.substr(peg$currPos, 2) === peg$c44) {
3813
- s3 = peg$c44;
3412
+ if (input.substr(peg$currPos, 2) === peg$c41) {
3413
+ s3 = peg$c41;
3814
3414
  peg$currPos += 2;
3815
3415
  } else {
3816
3416
  s3 = peg$FAILED;
3817
- if (peg$silentFails === 0) { peg$fail(peg$e68); }
3417
+ if (peg$silentFails === 0) { peg$fail(peg$e63); }
3818
3418
  }
3819
3419
  if (s3 !== peg$FAILED) {
3820
3420
  peg$savedPos = s0;
3821
- s0 = peg$f61();
3421
+ s0 = peg$f52();
3822
3422
  } else {
3823
3423
  peg$currPos = s0;
3824
3424
  s0 = peg$FAILED;
@@ -3839,11 +3439,11 @@ function peg$parse(input, options) {
3839
3439
  if (s1 !== peg$FAILED) {
3840
3440
  s2 = [];
3841
3441
  s3 = peg$currPos;
3842
- s4 = peg$parsewhitespaceShell();
3442
+ s4 = peg$parsewhitespace();
3843
3443
  if (s4 !== peg$FAILED) {
3844
3444
  s5 = peg$parsemultiplicativeOperator();
3845
3445
  if (s5 !== peg$FAILED) {
3846
- s6 = peg$parsewhitespaceShell();
3446
+ s6 = peg$parsewhitespace();
3847
3447
  if (s6 !== peg$FAILED) {
3848
3448
  s7 = peg$parseexponentiationExpression();
3849
3449
  if (s7 !== peg$FAILED) {
@@ -3867,11 +3467,11 @@ function peg$parse(input, options) {
3867
3467
  while (s3 !== peg$FAILED) {
3868
3468
  s2.push(s3);
3869
3469
  s3 = peg$currPos;
3870
- s4 = peg$parsewhitespaceShell();
3470
+ s4 = peg$parsewhitespace();
3871
3471
  if (s4 !== peg$FAILED) {
3872
3472
  s5 = peg$parsemultiplicativeOperator();
3873
3473
  if (s5 !== peg$FAILED) {
3874
- s6 = peg$parsewhitespaceShell();
3474
+ s6 = peg$parsewhitespace();
3875
3475
  if (s6 !== peg$FAILED) {
3876
3476
  s7 = peg$parseexponentiationExpression();
3877
3477
  if (s7 !== peg$FAILED) {
@@ -3894,7 +3494,7 @@ function peg$parse(input, options) {
3894
3494
  }
3895
3495
  }
3896
3496
  peg$savedPos = s0;
3897
- s0 = peg$f62(s1, s2);
3497
+ s0 = peg$f53(s1, s2);
3898
3498
  } else {
3899
3499
  peg$currPos = s0;
3900
3500
  s0 = peg$FAILED;
@@ -3907,11 +3507,11 @@ function peg$parse(input, options) {
3907
3507
  var s0;
3908
3508
 
3909
3509
  s0 = input.charAt(peg$currPos);
3910
- if (peg$r5.test(s0)) {
3510
+ if (peg$r4.test(s0)) {
3911
3511
  peg$currPos++;
3912
3512
  } else {
3913
3513
  s0 = peg$FAILED;
3914
- if (peg$silentFails === 0) { peg$fail(peg$e69); }
3514
+ if (peg$silentFails === 0) { peg$fail(peg$e64); }
3915
3515
  }
3916
3516
 
3917
3517
  return s0;
@@ -3923,21 +3523,21 @@ function peg$parse(input, options) {
3923
3523
  s0 = peg$currPos;
3924
3524
  s1 = [];
3925
3525
  s2 = input.charAt(peg$currPos);
3926
- if (peg$r6.test(s2)) {
3526
+ if (peg$r5.test(s2)) {
3927
3527
  peg$currPos++;
3928
3528
  } else {
3929
3529
  s2 = peg$FAILED;
3930
- if (peg$silentFails === 0) { peg$fail(peg$e70); }
3530
+ if (peg$silentFails === 0) { peg$fail(peg$e65); }
3931
3531
  }
3932
3532
  if (s2 !== peg$FAILED) {
3933
3533
  while (s2 !== peg$FAILED) {
3934
3534
  s1.push(s2);
3935
3535
  s2 = input.charAt(peg$currPos);
3936
- if (peg$r6.test(s2)) {
3536
+ if (peg$r5.test(s2)) {
3937
3537
  peg$currPos++;
3938
3538
  } else {
3939
3539
  s2 = peg$FAILED;
3940
- if (peg$silentFails === 0) { peg$fail(peg$e70); }
3540
+ if (peg$silentFails === 0) { peg$fail(peg$e65); }
3941
3541
  }
3942
3542
  }
3943
3543
  } else {
@@ -3945,15 +3545,15 @@ function peg$parse(input, options) {
3945
3545
  }
3946
3546
  if (s1 !== peg$FAILED) {
3947
3547
  if (input.charCodeAt(peg$currPos) === 58) {
3948
- s2 = peg$c5;
3548
+ s2 = peg$c9;
3949
3549
  peg$currPos++;
3950
3550
  } else {
3951
3551
  s2 = peg$FAILED;
3952
- if (peg$silentFails === 0) { peg$fail(peg$e7); }
3552
+ if (peg$silentFails === 0) { peg$fail(peg$e14); }
3953
3553
  }
3954
3554
  if (s2 !== peg$FAILED) {
3955
3555
  peg$savedPos = s0;
3956
- s0 = peg$f63(s1);
3556
+ s0 = peg$f54(s1);
3957
3557
  } else {
3958
3558
  peg$currPos = s0;
3959
3559
  s0 = peg$FAILED;
@@ -3966,95 +3566,31 @@ function peg$parse(input, options) {
3966
3566
  return s0;
3967
3567
  }
3968
3568
 
3969
- function peg$parsenewExpression() {
3970
- var s0, s1, s2, s3, s4;
3971
-
3972
- s0 = peg$currPos;
3973
- if (input.substr(peg$currPos, 3) === peg$c45) {
3974
- s1 = peg$c45;
3975
- peg$currPos += 3;
3976
- } else {
3977
- s1 = peg$FAILED;
3978
- if (peg$silentFails === 0) { peg$fail(peg$e71); }
3979
- }
3980
- if (s1 !== peg$FAILED) {
3981
- s2 = peg$parse__();
3982
- s3 = peg$parsejsReference();
3983
- if (s3 !== peg$FAILED) {
3984
- s4 = peg$parseparenthesesArguments();
3985
- if (s4 !== peg$FAILED) {
3986
- peg$savedPos = s0;
3987
- s0 = peg$f64(s3, s4);
3988
- } else {
3989
- peg$currPos = s0;
3990
- s0 = peg$FAILED;
3991
- }
3992
- } else {
3993
- peg$currPos = s0;
3994
- s0 = peg$FAILED;
3995
- }
3996
- } else {
3997
- peg$currPos = s0;
3998
- s0 = peg$FAILED;
3999
- }
4000
- if (s0 === peg$FAILED) {
4001
- s0 = peg$currPos;
4002
- if (input.substr(peg$currPos, 4) === peg$c46) {
4003
- s1 = peg$c46;
4004
- peg$currPos += 4;
4005
- } else {
4006
- s1 = peg$FAILED;
4007
- if (peg$silentFails === 0) { peg$fail(peg$e72); }
4008
- }
4009
- if (s1 !== peg$FAILED) {
4010
- s2 = peg$parsejsReference();
4011
- if (s2 !== peg$FAILED) {
4012
- s3 = peg$parseparenthesesArguments();
4013
- if (s3 !== peg$FAILED) {
4014
- peg$savedPos = s0;
4015
- s0 = peg$f65(s2, s3);
4016
- } else {
4017
- peg$currPos = s0;
4018
- s0 = peg$FAILED;
4019
- }
4020
- } else {
4021
- peg$currPos = s0;
4022
- s0 = peg$FAILED;
4023
- }
4024
- } else {
4025
- peg$currPos = s0;
4026
- s0 = peg$FAILED;
4027
- }
4028
- }
4029
-
4030
- return s0;
4031
- }
4032
-
4033
3569
  function peg$parsenewLine() {
4034
3570
  var s0;
4035
3571
 
4036
3572
  if (input.charCodeAt(peg$currPos) === 10) {
4037
- s0 = peg$c47;
3573
+ s0 = peg$c42;
4038
3574
  peg$currPos++;
4039
3575
  } else {
4040
3576
  s0 = peg$FAILED;
4041
- if (peg$silentFails === 0) { peg$fail(peg$e73); }
3577
+ if (peg$silentFails === 0) { peg$fail(peg$e66); }
4042
3578
  }
4043
3579
  if (s0 === peg$FAILED) {
4044
- if (input.substr(peg$currPos, 2) === peg$c48) {
4045
- s0 = peg$c48;
3580
+ if (input.substr(peg$currPos, 2) === peg$c43) {
3581
+ s0 = peg$c43;
4046
3582
  peg$currPos += 2;
4047
3583
  } else {
4048
3584
  s0 = peg$FAILED;
4049
- if (peg$silentFails === 0) { peg$fail(peg$e74); }
3585
+ if (peg$silentFails === 0) { peg$fail(peg$e67); }
4050
3586
  }
4051
3587
  if (s0 === peg$FAILED) {
4052
3588
  if (input.charCodeAt(peg$currPos) === 13) {
4053
- s0 = peg$c49;
3589
+ s0 = peg$c44;
4054
3590
  peg$currPos++;
4055
3591
  } else {
4056
3592
  s0 = peg$FAILED;
4057
- if (peg$silentFails === 0) { peg$fail(peg$e75); }
3593
+ if (peg$silentFails === 0) { peg$fail(peg$e68); }
4058
3594
  }
4059
3595
  }
4060
3596
  }
@@ -4073,7 +3609,7 @@ function peg$parse(input, options) {
4073
3609
  peg$silentFails--;
4074
3610
  if (s0 === peg$FAILED) {
4075
3611
  s1 = peg$FAILED;
4076
- if (peg$silentFails === 0) { peg$fail(peg$e76); }
3612
+ if (peg$silentFails === 0) { peg$fail(peg$e69); }
4077
3613
  }
4078
3614
 
4079
3615
  return s0;
@@ -4088,12 +3624,12 @@ function peg$parse(input, options) {
4088
3624
  s2 = [];
4089
3625
  s3 = peg$currPos;
4090
3626
  s4 = peg$parse__();
4091
- if (input.substr(peg$currPos, 2) === peg$c50) {
4092
- s5 = peg$c50;
3627
+ if (input.substr(peg$currPos, 2) === peg$c45) {
3628
+ s5 = peg$c45;
4093
3629
  peg$currPos += 2;
4094
3630
  } else {
4095
3631
  s5 = peg$FAILED;
4096
- if (peg$silentFails === 0) { peg$fail(peg$e77); }
3632
+ if (peg$silentFails === 0) { peg$fail(peg$e70); }
4097
3633
  }
4098
3634
  if (s5 !== peg$FAILED) {
4099
3635
  s6 = peg$parse__();
@@ -4112,12 +3648,12 @@ function peg$parse(input, options) {
4112
3648
  s2.push(s3);
4113
3649
  s3 = peg$currPos;
4114
3650
  s4 = peg$parse__();
4115
- if (input.substr(peg$currPos, 2) === peg$c50) {
4116
- s5 = peg$c50;
3651
+ if (input.substr(peg$currPos, 2) === peg$c45) {
3652
+ s5 = peg$c45;
4117
3653
  peg$currPos += 2;
4118
3654
  } else {
4119
3655
  s5 = peg$FAILED;
4120
- if (peg$silentFails === 0) { peg$fail(peg$e77); }
3656
+ if (peg$silentFails === 0) { peg$fail(peg$e70); }
4121
3657
  }
4122
3658
  if (s5 !== peg$FAILED) {
4123
3659
  s6 = peg$parse__();
@@ -4134,7 +3670,7 @@ function peg$parse(input, options) {
4134
3670
  }
4135
3671
  }
4136
3672
  peg$savedPos = s0;
4137
- s0 = peg$f66(s1, s2);
3673
+ s0 = peg$f55(s1, s2);
4138
3674
  } else {
4139
3675
  peg$currPos = s0;
4140
3676
  s0 = peg$FAILED;
@@ -4149,11 +3685,11 @@ function peg$parse(input, options) {
4149
3685
  peg$silentFails++;
4150
3686
  s0 = peg$currPos;
4151
3687
  if (input.charCodeAt(peg$currPos) === 123) {
4152
- s1 = peg$c51;
3688
+ s1 = peg$c46;
4153
3689
  peg$currPos++;
4154
3690
  } else {
4155
3691
  s1 = peg$FAILED;
4156
- if (peg$silentFails === 0) { peg$fail(peg$e79); }
3692
+ if (peg$silentFails === 0) { peg$fail(peg$e72); }
4157
3693
  }
4158
3694
  if (s1 !== peg$FAILED) {
4159
3695
  s2 = peg$parse__();
@@ -4165,7 +3701,7 @@ function peg$parse(input, options) {
4165
3701
  s5 = peg$parseexpectClosingBrace();
4166
3702
  if (s5 !== peg$FAILED) {
4167
3703
  peg$savedPos = s0;
4168
- s0 = peg$f67(s3);
3704
+ s0 = peg$f56(s3);
4169
3705
  } else {
4170
3706
  peg$currPos = s0;
4171
3707
  s0 = peg$FAILED;
@@ -4177,7 +3713,7 @@ function peg$parse(input, options) {
4177
3713
  peg$silentFails--;
4178
3714
  if (s0 === peg$FAILED) {
4179
3715
  s1 = peg$FAILED;
4180
- if (peg$silentFails === 0) { peg$fail(peg$e78); }
3716
+ if (peg$silentFails === 0) { peg$fail(peg$e71); }
4181
3717
  }
4182
3718
 
4183
3719
  return s0;
@@ -4218,7 +3754,7 @@ function peg$parse(input, options) {
4218
3754
  s2 = null;
4219
3755
  }
4220
3756
  peg$savedPos = s0;
4221
- s0 = peg$f68(s1);
3757
+ s0 = peg$f57(s1);
4222
3758
  } else {
4223
3759
  peg$currPos = s0;
4224
3760
  s0 = peg$FAILED;
@@ -4253,18 +3789,18 @@ function peg$parse(input, options) {
4253
3789
  if (s1 !== peg$FAILED) {
4254
3790
  s2 = peg$parse__();
4255
3791
  if (input.charCodeAt(peg$currPos) === 61) {
4256
- s3 = peg$c52;
3792
+ s3 = peg$c47;
4257
3793
  peg$currPos++;
4258
3794
  } else {
4259
3795
  s3 = peg$FAILED;
4260
- if (peg$silentFails === 0) { peg$fail(peg$e81); }
3796
+ if (peg$silentFails === 0) { peg$fail(peg$e74); }
4261
3797
  }
4262
3798
  if (s3 !== peg$FAILED) {
4263
3799
  s4 = peg$parse__();
4264
3800
  s5 = peg$parseexpectPipelineExpression();
4265
3801
  if (s5 !== peg$FAILED) {
4266
3802
  peg$savedPos = s0;
4267
- s0 = peg$f69(s1, s5);
3803
+ s0 = peg$f58(s1, s5);
4268
3804
  } else {
4269
3805
  peg$currPos = s0;
4270
3806
  s0 = peg$FAILED;
@@ -4280,7 +3816,7 @@ function peg$parse(input, options) {
4280
3816
  peg$silentFails--;
4281
3817
  if (s0 === peg$FAILED) {
4282
3818
  s1 = peg$FAILED;
4283
- if (peg$silentFails === 0) { peg$fail(peg$e80); }
3819
+ if (peg$silentFails === 0) { peg$fail(peg$e73); }
4284
3820
  }
4285
3821
 
4286
3822
  return s0;
@@ -4292,21 +3828,21 @@ function peg$parse(input, options) {
4292
3828
  s0 = peg$currPos;
4293
3829
  s1 = peg$currPos;
4294
3830
  if (input.charCodeAt(peg$currPos) === 40) {
4295
- s2 = peg$c8;
3831
+ s2 = peg$c2;
4296
3832
  peg$currPos++;
4297
3833
  } else {
4298
3834
  s2 = peg$FAILED;
4299
- if (peg$silentFails === 0) { peg$fail(peg$e12); }
3835
+ if (peg$silentFails === 0) { peg$fail(peg$e5); }
4300
3836
  }
4301
3837
  if (s2 !== peg$FAILED) {
4302
3838
  s3 = peg$parseobjectPublicKey();
4303
3839
  if (s3 !== peg$FAILED) {
4304
3840
  if (input.charCodeAt(peg$currPos) === 41) {
4305
- s4 = peg$c9;
3841
+ s4 = peg$c3;
4306
3842
  peg$currPos++;
4307
3843
  } else {
4308
3844
  s4 = peg$FAILED;
4309
- if (peg$silentFails === 0) { peg$fail(peg$e13); }
3845
+ if (peg$silentFails === 0) { peg$fail(peg$e6); }
4310
3846
  }
4311
3847
  if (s4 !== peg$FAILED) {
4312
3848
  s2 = [s2, s3, s4];
@@ -4325,7 +3861,7 @@ function peg$parse(input, options) {
4325
3861
  }
4326
3862
  if (s1 !== peg$FAILED) {
4327
3863
  peg$savedPos = s0;
4328
- s1 = peg$f70(s1);
3864
+ s1 = peg$f59(s1);
4329
3865
  }
4330
3866
  s0 = s1;
4331
3867
 
@@ -4343,7 +3879,7 @@ function peg$parse(input, options) {
4343
3879
  peg$silentFails--;
4344
3880
  if (s0 === peg$FAILED) {
4345
3881
  s1 = peg$FAILED;
4346
- if (peg$silentFails === 0) { peg$fail(peg$e82); }
3882
+ if (peg$silentFails === 0) { peg$fail(peg$e75); }
4347
3883
  }
4348
3884
 
4349
3885
  return s0;
@@ -4358,18 +3894,18 @@ function peg$parse(input, options) {
4358
3894
  if (s1 !== peg$FAILED) {
4359
3895
  s2 = peg$parse__();
4360
3896
  if (input.charCodeAt(peg$currPos) === 58) {
4361
- s3 = peg$c5;
3897
+ s3 = peg$c9;
4362
3898
  peg$currPos++;
4363
3899
  } else {
4364
3900
  s3 = peg$FAILED;
4365
- if (peg$silentFails === 0) { peg$fail(peg$e7); }
3901
+ if (peg$silentFails === 0) { peg$fail(peg$e14); }
4366
3902
  }
4367
3903
  if (s3 !== peg$FAILED) {
4368
3904
  s4 = peg$parse__();
4369
3905
  s5 = peg$parseexpectPipelineExpression();
4370
3906
  if (s5 !== peg$FAILED) {
4371
3907
  peg$savedPos = s0;
4372
- s0 = peg$f71(s1, s5);
3908
+ s0 = peg$f60(s1, s5);
4373
3909
  } else {
4374
3910
  peg$currPos = s0;
4375
3911
  s0 = peg$FAILED;
@@ -4385,44 +3921,27 @@ function peg$parse(input, options) {
4385
3921
  peg$silentFails--;
4386
3922
  if (s0 === peg$FAILED) {
4387
3923
  s1 = peg$FAILED;
4388
- if (peg$silentFails === 0) { peg$fail(peg$e83); }
3924
+ if (peg$silentFails === 0) { peg$fail(peg$e76); }
4389
3925
  }
4390
3926
 
4391
3927
  return s0;
4392
3928
  }
4393
3929
 
4394
3930
  function peg$parseobjectShorthandProperty() {
4395
- var s0, s1, s2;
3931
+ var s0, s1;
4396
3932
 
4397
3933
  peg$silentFails++;
4398
3934
  s0 = peg$currPos;
4399
3935
  s1 = peg$parseobjectPublicKey();
4400
3936
  if (s1 !== peg$FAILED) {
4401
3937
  peg$savedPos = s0;
4402
- s1 = peg$f72(s1);
3938
+ s1 = peg$f61(s1);
4403
3939
  }
4404
3940
  s0 = s1;
4405
- if (s0 === peg$FAILED) {
4406
- s0 = peg$currPos;
4407
- s1 = peg$parsejseMode();
4408
- if (s1 !== peg$FAILED) {
4409
- s2 = peg$parseangleBracketLiteral();
4410
- if (s2 !== peg$FAILED) {
4411
- peg$savedPos = s0;
4412
- s0 = peg$f73(s2);
4413
- } else {
4414
- peg$currPos = s0;
4415
- s0 = peg$FAILED;
4416
- }
4417
- } else {
4418
- peg$currPos = s0;
4419
- s0 = peg$FAILED;
4420
- }
4421
- }
4422
3941
  peg$silentFails--;
4423
3942
  if (s0 === peg$FAILED) {
4424
3943
  s1 = peg$FAILED;
4425
- if (peg$silentFails === 0) { peg$fail(peg$e84); }
3944
+ if (peg$silentFails === 0) { peg$fail(peg$e77); }
4426
3945
  }
4427
3946
 
4428
3947
  return s0;
@@ -4435,17 +3954,17 @@ function peg$parse(input, options) {
4435
3954
  s1 = peg$parseidentifier();
4436
3955
  if (s1 !== peg$FAILED) {
4437
3956
  if (input.charCodeAt(peg$currPos) === 47) {
4438
- s2 = peg$c3;
3957
+ s2 = peg$c48;
4439
3958
  peg$currPos++;
4440
3959
  } else {
4441
3960
  s2 = peg$FAILED;
4442
- if (peg$silentFails === 0) { peg$fail(peg$e4); }
3961
+ if (peg$silentFails === 0) { peg$fail(peg$e78); }
4443
3962
  }
4444
3963
  if (s2 === peg$FAILED) {
4445
3964
  s2 = null;
4446
3965
  }
4447
3966
  peg$savedPos = s0;
4448
- s0 = peg$f74(s1, s2);
3967
+ s0 = peg$f62(s1, s2);
4449
3968
  } else {
4450
3969
  peg$currPos = s0;
4451
3970
  s0 = peg$FAILED;
@@ -4455,7 +3974,7 @@ function peg$parse(input, options) {
4455
3974
  s1 = peg$parsestringLiteral();
4456
3975
  if (s1 !== peg$FAILED) {
4457
3976
  peg$savedPos = s0;
4458
- s1 = peg$f75(s1);
3977
+ s1 = peg$f63(s1);
4459
3978
  }
4460
3979
  s0 = s1;
4461
3980
  }
@@ -4463,70 +3982,16 @@ function peg$parse(input, options) {
4463
3982
  return s0;
4464
3983
  }
4465
3984
 
4466
- function peg$parseoptionalChaining() {
4467
- var s0, s1, s2, s3, s4;
4468
-
4469
- s0 = peg$currPos;
4470
- s1 = peg$parse__();
4471
- if (input.substr(peg$currPos, 2) === peg$c53) {
4472
- s2 = peg$c53;
4473
- peg$currPos += 2;
4474
- } else {
4475
- s2 = peg$FAILED;
4476
- if (peg$silentFails === 0) { peg$fail(peg$e85); }
4477
- }
4478
- if (s2 !== peg$FAILED) {
4479
- s3 = peg$parse__();
4480
- s4 = peg$parsejsIdentifier();
4481
- if (s4 !== peg$FAILED) {
4482
- peg$savedPos = s0;
4483
- s0 = peg$f76(s4);
4484
- } else {
4485
- peg$currPos = s0;
4486
- s0 = peg$FAILED;
4487
- }
4488
- } else {
4489
- peg$currPos = s0;
4490
- s0 = peg$FAILED;
4491
- }
4492
-
4493
- return s0;
4494
- }
4495
-
4496
3985
  function peg$parseparameter() {
4497
- var s0, s1, s2;
3986
+ var s0, s1;
4498
3987
 
4499
3988
  s0 = peg$currPos;
4500
- s1 = peg$parsejseMode();
3989
+ s1 = peg$parseidentifier();
4501
3990
  if (s1 !== peg$FAILED) {
4502
- s2 = peg$parsejsIdentifier();
4503
- if (s2 !== peg$FAILED) {
4504
- s0 = s2;
4505
- } else {
4506
- peg$currPos = s0;
4507
- s0 = peg$FAILED;
4508
- }
4509
- } else {
4510
- peg$currPos = s0;
4511
- s0 = peg$FAILED;
4512
- }
4513
- if (s0 === peg$FAILED) {
4514
- s0 = peg$currPos;
4515
- s1 = peg$parseshellMode();
4516
- if (s1 !== peg$FAILED) {
4517
- s2 = peg$parseidentifier();
4518
- if (s2 !== peg$FAILED) {
4519
- peg$savedPos = s0;
4520
- s0 = peg$f77(s2);
4521
- } else {
4522
- peg$currPos = s0;
4523
- s0 = peg$FAILED;
4524
- }
4525
- } else {
4526
- peg$currPos = s0;
4527
- s0 = peg$FAILED;
4528
- }
3991
+ peg$savedPos = s0;
3992
+ s1 = peg$f64(s1);
4529
3993
  }
3994
+ s0 = s1;
4530
3995
 
4531
3996
  return s0;
4532
3997
  }
@@ -4566,7 +4031,7 @@ function peg$parse(input, options) {
4566
4031
  s2 = null;
4567
4032
  }
4568
4033
  peg$savedPos = s0;
4569
- s0 = peg$f78(s1);
4034
+ s0 = peg$f65(s1);
4570
4035
  } else {
4571
4036
  peg$currPos = s0;
4572
4037
  s0 = peg$FAILED;
@@ -4582,7 +4047,7 @@ function peg$parse(input, options) {
4582
4047
  s1 = peg$parseidentifier();
4583
4048
  if (s1 !== peg$FAILED) {
4584
4049
  peg$savedPos = s0;
4585
- s1 = peg$f79(s1);
4050
+ s1 = peg$f66(s1);
4586
4051
  }
4587
4052
  s0 = s1;
4588
4053
 
@@ -4595,11 +4060,11 @@ function peg$parse(input, options) {
4595
4060
  peg$silentFails++;
4596
4061
  s0 = peg$currPos;
4597
4062
  if (input.charCodeAt(peg$currPos) === 40) {
4598
- s1 = peg$c8;
4063
+ s1 = peg$c2;
4599
4064
  peg$currPos++;
4600
4065
  } else {
4601
4066
  s1 = peg$FAILED;
4602
- if (peg$silentFails === 0) { peg$fail(peg$e12); }
4067
+ if (peg$silentFails === 0) { peg$fail(peg$e5); }
4603
4068
  }
4604
4069
  if (s1 !== peg$FAILED) {
4605
4070
  s2 = peg$parse__();
@@ -4611,7 +4076,7 @@ function peg$parse(input, options) {
4611
4076
  s5 = peg$parseexpectClosingParenthesis();
4612
4077
  if (s5 !== peg$FAILED) {
4613
4078
  peg$savedPos = s0;
4614
- s0 = peg$f80(s3);
4079
+ s0 = peg$f67(s3);
4615
4080
  } else {
4616
4081
  peg$currPos = s0;
4617
4082
  s0 = peg$FAILED;
@@ -4623,7 +4088,7 @@ function peg$parse(input, options) {
4623
4088
  peg$silentFails--;
4624
4089
  if (s0 === peg$FAILED) {
4625
4090
  s1 = peg$FAILED;
4626
- if (peg$silentFails === 0) { peg$fail(peg$e86); }
4091
+ if (peg$silentFails === 0) { peg$fail(peg$e79); }
4627
4092
  }
4628
4093
 
4629
4094
  return s0;
@@ -4649,13 +4114,13 @@ function peg$parse(input, options) {
4649
4114
  }
4650
4115
  if (s1 !== peg$FAILED) {
4651
4116
  peg$savedPos = s0;
4652
- s1 = peg$f81(s1);
4117
+ s1 = peg$f68(s1);
4653
4118
  }
4654
4119
  s0 = s1;
4655
4120
  peg$silentFails--;
4656
4121
  if (s0 === peg$FAILED) {
4657
4122
  s1 = peg$FAILED;
4658
- if (peg$silentFails === 0) { peg$fail(peg$e87); }
4123
+ if (peg$silentFails === 0) { peg$fail(peg$e80); }
4659
4124
  }
4660
4125
 
4661
4126
  return s0;
@@ -4668,7 +4133,7 @@ function peg$parse(input, options) {
4668
4133
  s1 = peg$parsepath();
4669
4134
  if (s1 !== peg$FAILED) {
4670
4135
  peg$savedPos = s0;
4671
- s1 = peg$f82(s1);
4136
+ s1 = peg$f69(s1);
4672
4137
  }
4673
4138
  s0 = s1;
4674
4139
 
@@ -4695,7 +4160,7 @@ function peg$parse(input, options) {
4695
4160
  s2 = null;
4696
4161
  }
4697
4162
  peg$savedPos = s0;
4698
- s0 = peg$f83(s1, s2);
4163
+ s0 = peg$f70(s1, s2);
4699
4164
  } else {
4700
4165
  peg$currPos = s0;
4701
4166
  s0 = peg$FAILED;
@@ -4709,11 +4174,11 @@ function peg$parse(input, options) {
4709
4174
 
4710
4175
  s0 = peg$currPos;
4711
4176
  if (input.charCodeAt(peg$currPos) === 47) {
4712
- s1 = peg$c3;
4177
+ s1 = peg$c48;
4713
4178
  peg$currPos++;
4714
4179
  } else {
4715
4180
  s1 = peg$FAILED;
4716
- if (peg$silentFails === 0) { peg$fail(peg$e4); }
4181
+ if (peg$silentFails === 0) { peg$fail(peg$e78); }
4717
4182
  }
4718
4183
  if (s1 !== peg$FAILED) {
4719
4184
  s2 = peg$parsepathKey();
@@ -4733,11 +4198,11 @@ function peg$parse(input, options) {
4733
4198
  var s0;
4734
4199
 
4735
4200
  s0 = input.charAt(peg$currPos);
4736
- if (peg$r7.test(s0)) {
4201
+ if (peg$r6.test(s0)) {
4737
4202
  peg$currPos++;
4738
4203
  } else {
4739
4204
  s0 = peg$FAILED;
4740
- if (peg$silentFails === 0) { peg$fail(peg$e88); }
4205
+ if (peg$silentFails === 0) { peg$fail(peg$e81); }
4741
4206
  }
4742
4207
  if (s0 === peg$FAILED) {
4743
4208
  s0 = peg$parseescapedChar();
@@ -4789,7 +4254,7 @@ function peg$parse(input, options) {
4789
4254
  }
4790
4255
  }
4791
4256
  peg$savedPos = s0;
4792
- s0 = peg$f84(s1, s2);
4257
+ s0 = peg$f71(s1, s2);
4793
4258
  } else {
4794
4259
  peg$currPos = s0;
4795
4260
  s0 = peg$FAILED;
@@ -4799,51 +4264,19 @@ function peg$parse(input, options) {
4799
4264
  }
4800
4265
 
4801
4266
  function peg$parseprimary() {
4802
- var s0, s1, s2;
4267
+ var s0;
4803
4268
 
4804
- s0 = peg$parsenumericLiteral();
4269
+ s0 = peg$parseliteral();
4805
4270
  if (s0 === peg$FAILED) {
4806
- s0 = peg$parsestringLiteral();
4271
+ s0 = peg$parsearrayLiteral();
4807
4272
  if (s0 === peg$FAILED) {
4808
- s0 = peg$parsearrayLiteral();
4273
+ s0 = peg$parseobjectLiteral();
4809
4274
  if (s0 === peg$FAILED) {
4810
- s0 = peg$parseobjectLiteral();
4275
+ s0 = peg$parsegroup();
4811
4276
  if (s0 === peg$FAILED) {
4812
- s0 = peg$parsegroup();
4277
+ s0 = peg$parsetemplateLiteral();
4813
4278
  if (s0 === peg$FAILED) {
4814
- s0 = peg$parsetemplateLiteral();
4815
- if (s0 === peg$FAILED) {
4816
- s0 = peg$currPos;
4817
- s1 = peg$parseshellMode();
4818
- if (s1 !== peg$FAILED) {
4819
- s2 = peg$parseprimaryShell();
4820
- if (s2 !== peg$FAILED) {
4821
- s0 = s2;
4822
- } else {
4823
- peg$currPos = s0;
4824
- s0 = peg$FAILED;
4825
- }
4826
- } else {
4827
- peg$currPos = s0;
4828
- s0 = peg$FAILED;
4829
- }
4830
- if (s0 === peg$FAILED) {
4831
- s0 = peg$currPos;
4832
- s1 = peg$parsejseMode();
4833
- if (s1 !== peg$FAILED) {
4834
- s2 = peg$parseprimaryJse();
4835
- if (s2 !== peg$FAILED) {
4836
- s0 = s2;
4837
- } else {
4838
- peg$currPos = s0;
4839
- s0 = peg$FAILED;
4840
- }
4841
- } else {
4842
- peg$currPos = s0;
4843
- s0 = peg$FAILED;
4844
- }
4845
- }
4846
- }
4279
+ s0 = peg$parseinherited();
4847
4280
  }
4848
4281
  }
4849
4282
  }
@@ -4853,40 +4286,6 @@ function peg$parse(input, options) {
4853
4286
  return s0;
4854
4287
  }
4855
4288
 
4856
- function peg$parseprimaryJse() {
4857
- var s0;
4858
-
4859
- s0 = peg$parseangleBracketLiteral();
4860
- if (s0 === peg$FAILED) {
4861
- s0 = peg$parsejsReference();
4862
- if (s0 === peg$FAILED) {
4863
- s0 = peg$parseregexLiteral();
4864
- }
4865
- }
4866
-
4867
- return s0;
4868
- }
4869
-
4870
- function peg$parseprimaryShell() {
4871
- var s0;
4872
-
4873
- s0 = peg$parserootDirectory();
4874
- if (s0 === peg$FAILED) {
4875
- s0 = peg$parsehomeDirectory();
4876
- if (s0 === peg$FAILED) {
4877
- s0 = peg$parsequalifiedReference();
4878
- if (s0 === peg$FAILED) {
4879
- s0 = peg$parsenamespace();
4880
- if (s0 === peg$FAILED) {
4881
- s0 = peg$parsescopeReference();
4882
- }
4883
- }
4884
- }
4885
- }
4886
-
4887
- return s0;
4888
- }
4889
-
4890
4289
  function peg$parseprogram() {
4891
4290
  var s0, s1, s2;
4892
4291
 
@@ -4906,7 +4305,7 @@ function peg$parse(input, options) {
4906
4305
  peg$silentFails--;
4907
4306
  if (s0 === peg$FAILED) {
4908
4307
  s1 = peg$FAILED;
4909
- if (peg$silentFails === 0) { peg$fail(peg$e89); }
4308
+ if (peg$silentFails === 0) { peg$fail(peg$e82); }
4910
4309
  }
4911
4310
 
4912
4311
  return s0;
@@ -4918,12 +4317,12 @@ function peg$parse(input, options) {
4918
4317
  s0 = peg$currPos;
4919
4318
  s1 = peg$parsenamespace();
4920
4319
  if (s1 !== peg$FAILED) {
4921
- if (input.substr(peg$currPos, 2) === peg$c1) {
4922
- s2 = peg$c1;
4320
+ if (input.substr(peg$currPos, 2) === peg$c49) {
4321
+ s2 = peg$c49;
4923
4322
  peg$currPos += 2;
4924
4323
  } else {
4925
4324
  s2 = peg$FAILED;
4926
- if (peg$silentFails === 0) { peg$fail(peg$e2); }
4325
+ if (peg$silentFails === 0) { peg$fail(peg$e83); }
4927
4326
  }
4928
4327
  if (s2 !== peg$FAILED) {
4929
4328
  s3 = peg$parsehost();
@@ -4936,7 +4335,7 @@ function peg$parse(input, options) {
4936
4335
  s4 = null;
4937
4336
  }
4938
4337
  peg$savedPos = s0;
4939
- s0 = peg$f85(s1, s3, s4);
4338
+ s0 = peg$f72(s1, s3, s4);
4940
4339
  } else {
4941
4340
  peg$currPos = s0;
4942
4341
  s0 = peg$FAILED;
@@ -4950,10 +4349,7 @@ function peg$parse(input, options) {
4950
4349
  s0 = peg$FAILED;
4951
4350
  }
4952
4351
  if (s0 === peg$FAILED) {
4953
- s0 = peg$parsenewExpression();
4954
- if (s0 === peg$FAILED) {
4955
- s0 = peg$parseprimary();
4956
- }
4352
+ s0 = peg$parseprimary();
4957
4353
  }
4958
4354
 
4959
4355
  return s0;
@@ -4968,7 +4364,7 @@ function peg$parse(input, options) {
4968
4364
  s2 = peg$parsescopeReference();
4969
4365
  if (s2 !== peg$FAILED) {
4970
4366
  peg$savedPos = s0;
4971
- s0 = peg$f86(s1, s2);
4367
+ s0 = peg$f73(s1, s2);
4972
4368
  } else {
4973
4369
  peg$currPos = s0;
4974
4370
  s0 = peg$FAILED;
@@ -4981,93 +4377,6 @@ function peg$parse(input, options) {
4981
4377
  return s0;
4982
4378
  }
4983
4379
 
4984
- function peg$parseregexFlags() {
4985
- var s0, s1, s2;
4986
-
4987
- s0 = peg$currPos;
4988
- s1 = [];
4989
- s2 = input.charAt(peg$currPos);
4990
- if (peg$r8.test(s2)) {
4991
- peg$currPos++;
4992
- } else {
4993
- s2 = peg$FAILED;
4994
- if (peg$silentFails === 0) { peg$fail(peg$e90); }
4995
- }
4996
- while (s2 !== peg$FAILED) {
4997
- s1.push(s2);
4998
- s2 = input.charAt(peg$currPos);
4999
- if (peg$r8.test(s2)) {
5000
- peg$currPos++;
5001
- } else {
5002
- s2 = peg$FAILED;
5003
- if (peg$silentFails === 0) { peg$fail(peg$e90); }
5004
- }
5005
- }
5006
- peg$savedPos = s0;
5007
- s1 = peg$f87(s1);
5008
- s0 = s1;
5009
-
5010
- return s0;
5011
- }
5012
-
5013
- function peg$parseregexLiteral() {
5014
- var s0, s1, s2, s3, s4;
5015
-
5016
- s0 = peg$currPos;
5017
- if (input.charCodeAt(peg$currPos) === 47) {
5018
- s1 = peg$c3;
5019
- peg$currPos++;
5020
- } else {
5021
- s1 = peg$FAILED;
5022
- if (peg$silentFails === 0) { peg$fail(peg$e4); }
5023
- }
5024
- if (s1 !== peg$FAILED) {
5025
- s2 = [];
5026
- s3 = peg$parseregexLiteralChar();
5027
- while (s3 !== peg$FAILED) {
5028
- s2.push(s3);
5029
- s3 = peg$parseregexLiteralChar();
5030
- }
5031
- if (input.charCodeAt(peg$currPos) === 47) {
5032
- s3 = peg$c3;
5033
- peg$currPos++;
5034
- } else {
5035
- s3 = peg$FAILED;
5036
- if (peg$silentFails === 0) { peg$fail(peg$e4); }
5037
- }
5038
- if (s3 !== peg$FAILED) {
5039
- s4 = peg$parseregexFlags();
5040
- peg$savedPos = s0;
5041
- s0 = peg$f88(s2, s4);
5042
- } else {
5043
- peg$currPos = s0;
5044
- s0 = peg$FAILED;
5045
- }
5046
- } else {
5047
- peg$currPos = s0;
5048
- s0 = peg$FAILED;
5049
- }
5050
-
5051
- return s0;
5052
- }
5053
-
5054
- function peg$parseregexLiteralChar() {
5055
- var s0;
5056
-
5057
- s0 = input.charAt(peg$currPos);
5058
- if (peg$r9.test(s0)) {
5059
- peg$currPos++;
5060
- } else {
5061
- s0 = peg$FAILED;
5062
- if (peg$silentFails === 0) { peg$fail(peg$e91); }
5063
- }
5064
- if (s0 === peg$FAILED) {
5065
- s0 = peg$parseescapedChar();
5066
- }
5067
-
5068
- return s0;
5069
- }
5070
-
5071
4380
  function peg$parserelationalExpression() {
5072
4381
  var s0, s1, s2, s3, s4, s5, s6, s7;
5073
4382
 
@@ -5076,18 +4385,13 @@ function peg$parse(input, options) {
5076
4385
  if (s1 !== peg$FAILED) {
5077
4386
  s2 = [];
5078
4387
  s3 = peg$currPos;
5079
- s4 = peg$parseinlineSpace();
5080
- if (s4 !== peg$FAILED) {
5081
- s5 = peg$parserelationalOperator();
5082
- if (s5 !== peg$FAILED) {
5083
- s6 = peg$parse__();
5084
- s7 = peg$parseshiftExpression();
5085
- if (s7 !== peg$FAILED) {
5086
- s3 = [ s5, s7 ];
5087
- } else {
5088
- peg$currPos = s3;
5089
- s3 = peg$FAILED;
5090
- }
4388
+ s4 = peg$parse__();
4389
+ s5 = peg$parserelationalOperator();
4390
+ if (s5 !== peg$FAILED) {
4391
+ s6 = peg$parse__();
4392
+ s7 = peg$parseshiftExpression();
4393
+ if (s7 !== peg$FAILED) {
4394
+ s3 = [ s5, s7 ];
5091
4395
  } else {
5092
4396
  peg$currPos = s3;
5093
4397
  s3 = peg$FAILED;
@@ -5099,18 +4403,13 @@ function peg$parse(input, options) {
5099
4403
  while (s3 !== peg$FAILED) {
5100
4404
  s2.push(s3);
5101
4405
  s3 = peg$currPos;
5102
- s4 = peg$parseinlineSpace();
5103
- if (s4 !== peg$FAILED) {
5104
- s5 = peg$parserelationalOperator();
5105
- if (s5 !== peg$FAILED) {
5106
- s6 = peg$parse__();
5107
- s7 = peg$parseshiftExpression();
5108
- if (s7 !== peg$FAILED) {
5109
- s3 = [ s5, s7 ];
5110
- } else {
5111
- peg$currPos = s3;
5112
- s3 = peg$FAILED;
5113
- }
4406
+ s4 = peg$parse__();
4407
+ s5 = peg$parserelationalOperator();
4408
+ if (s5 !== peg$FAILED) {
4409
+ s6 = peg$parse__();
4410
+ s7 = peg$parseshiftExpression();
4411
+ if (s7 !== peg$FAILED) {
4412
+ s3 = [ s5, s7 ];
5114
4413
  } else {
5115
4414
  peg$currPos = s3;
5116
4415
  s3 = peg$FAILED;
@@ -5121,7 +4420,7 @@ function peg$parse(input, options) {
5121
4420
  }
5122
4421
  }
5123
4422
  peg$savedPos = s0;
5124
- s0 = peg$f89(s1, s2);
4423
+ s0 = peg$f74(s1, s2);
5125
4424
  } else {
5126
4425
  peg$currPos = s0;
5127
4426
  s0 = peg$FAILED;
@@ -5133,36 +4432,36 @@ function peg$parse(input, options) {
5133
4432
  function peg$parserelationalOperator() {
5134
4433
  var s0;
5135
4434
 
5136
- if (input.substr(peg$currPos, 2) === peg$c54) {
5137
- s0 = peg$c54;
4435
+ if (input.substr(peg$currPos, 2) === peg$c50) {
4436
+ s0 = peg$c50;
5138
4437
  peg$currPos += 2;
5139
4438
  } else {
5140
4439
  s0 = peg$FAILED;
5141
- if (peg$silentFails === 0) { peg$fail(peg$e92); }
4440
+ if (peg$silentFails === 0) { peg$fail(peg$e84); }
5142
4441
  }
5143
4442
  if (s0 === peg$FAILED) {
5144
4443
  if (input.charCodeAt(peg$currPos) === 60) {
5145
- s0 = peg$c0;
4444
+ s0 = peg$c51;
5146
4445
  peg$currPos++;
5147
4446
  } else {
5148
4447
  s0 = peg$FAILED;
5149
- if (peg$silentFails === 0) { peg$fail(peg$e1); }
4448
+ if (peg$silentFails === 0) { peg$fail(peg$e85); }
5150
4449
  }
5151
4450
  if (s0 === peg$FAILED) {
5152
- if (input.substr(peg$currPos, 2) === peg$c55) {
5153
- s0 = peg$c55;
4451
+ if (input.substr(peg$currPos, 2) === peg$c52) {
4452
+ s0 = peg$c52;
5154
4453
  peg$currPos += 2;
5155
4454
  } else {
5156
4455
  s0 = peg$FAILED;
5157
- if (peg$silentFails === 0) { peg$fail(peg$e93); }
4456
+ if (peg$silentFails === 0) { peg$fail(peg$e86); }
5158
4457
  }
5159
4458
  if (s0 === peg$FAILED) {
5160
4459
  if (input.charCodeAt(peg$currPos) === 62) {
5161
- s0 = peg$c2;
4460
+ s0 = peg$c37;
5162
4461
  peg$currPos++;
5163
4462
  } else {
5164
4463
  s0 = peg$FAILED;
5165
- if (peg$silentFails === 0) { peg$fail(peg$e3); }
4464
+ if (peg$silentFails === 0) { peg$fail(peg$e53); }
5166
4465
  }
5167
4466
  }
5168
4467
  }
@@ -5172,59 +4471,67 @@ function peg$parse(input, options) {
5172
4471
  }
5173
4472
 
5174
4473
  function peg$parserootDirectory() {
5175
- var s0, s1, s2, s3, s4, s5;
4474
+ var s0, s1, s2, s3;
5176
4475
 
5177
4476
  s0 = peg$currPos;
5178
- s1 = peg$currPos;
5179
- peg$silentFails++;
5180
- s2 = peg$currPos;
5181
4477
  if (input.charCodeAt(peg$currPos) === 47) {
5182
- s3 = peg$c3;
4478
+ s1 = peg$c48;
5183
4479
  peg$currPos++;
5184
4480
  } else {
5185
- s3 = peg$FAILED;
5186
- if (peg$silentFails === 0) { peg$fail(peg$e4); }
4481
+ s1 = peg$FAILED;
4482
+ if (peg$silentFails === 0) { peg$fail(peg$e78); }
5187
4483
  }
5188
- if (s3 !== peg$FAILED) {
5189
- s4 = peg$currPos;
5190
- peg$silentFails++;
4484
+ if (s1 !== peg$FAILED) {
4485
+ s2 = peg$parsepathKey();
4486
+ if (s2 !== peg$FAILED) {
4487
+ peg$savedPos = s0;
4488
+ s0 = peg$f75(s2);
4489
+ } else {
4490
+ peg$currPos = s0;
4491
+ s0 = peg$FAILED;
4492
+ }
4493
+ } else {
4494
+ peg$currPos = s0;
4495
+ s0 = peg$FAILED;
4496
+ }
4497
+ if (s0 === peg$FAILED) {
4498
+ s0 = peg$currPos;
5191
4499
  if (input.charCodeAt(peg$currPos) === 47) {
5192
- s5 = peg$c3;
4500
+ s1 = peg$c48;
5193
4501
  peg$currPos++;
5194
4502
  } else {
5195
- s5 = peg$FAILED;
5196
- if (peg$silentFails === 0) { peg$fail(peg$e4); }
5197
- }
5198
- peg$silentFails--;
5199
- if (s5 === peg$FAILED) {
5200
- s4 = undefined;
5201
- } else {
5202
- peg$currPos = s4;
5203
- s4 = peg$FAILED;
4503
+ s1 = peg$FAILED;
4504
+ if (peg$silentFails === 0) { peg$fail(peg$e78); }
5204
4505
  }
5205
- if (s4 !== peg$FAILED) {
5206
- s3 = [s3, s4];
5207
- s2 = s3;
4506
+ if (s1 !== peg$FAILED) {
4507
+ s2 = peg$currPos;
4508
+ peg$silentFails++;
4509
+ if (input.charCodeAt(peg$currPos) === 47) {
4510
+ s3 = peg$c48;
4511
+ peg$currPos++;
4512
+ } else {
4513
+ s3 = peg$FAILED;
4514
+ if (peg$silentFails === 0) { peg$fail(peg$e78); }
4515
+ }
4516
+ peg$silentFails--;
4517
+ if (s3 === peg$FAILED) {
4518
+ s2 = undefined;
4519
+ } else {
4520
+ peg$currPos = s2;
4521
+ s2 = peg$FAILED;
4522
+ }
4523
+ if (s2 !== peg$FAILED) {
4524
+ peg$savedPos = s0;
4525
+ s0 = peg$f76();
4526
+ } else {
4527
+ peg$currPos = s0;
4528
+ s0 = peg$FAILED;
4529
+ }
5208
4530
  } else {
5209
- peg$currPos = s2;
5210
- s2 = peg$FAILED;
4531
+ peg$currPos = s0;
4532
+ s0 = peg$FAILED;
5211
4533
  }
5212
- } else {
5213
- peg$currPos = s2;
5214
- s2 = peg$FAILED;
5215
- }
5216
- peg$silentFails--;
5217
- if (s2 !== peg$FAILED) {
5218
- peg$currPos = s1;
5219
- s1 = undefined;
5220
- } else {
5221
- s1 = peg$FAILED;
5222
- }
5223
- if (s1 !== peg$FAILED) {
5224
- peg$savedPos = s0;
5225
- s1 = peg$f90();
5226
4534
  }
5227
- s0 = s1;
5228
4535
 
5229
4536
  return s0;
5230
4537
  }
@@ -5241,7 +4548,7 @@ function peg$parse(input, options) {
5241
4548
  s2 = null;
5242
4549
  }
5243
4550
  peg$savedPos = s0;
5244
- s0 = peg$f91(s1, s2);
4551
+ s0 = peg$f77(s1, s2);
5245
4552
  } else {
5246
4553
  peg$currPos = s0;
5247
4554
  s0 = peg$FAILED;
@@ -5249,7 +4556,7 @@ function peg$parse(input, options) {
5249
4556
  peg$silentFails--;
5250
4557
  if (s0 === peg$FAILED) {
5251
4558
  s1 = peg$FAILED;
5252
- if (peg$silentFails === 0) { peg$fail(peg$e94); }
4559
+ if (peg$silentFails === 0) { peg$fail(peg$e87); }
5253
4560
  }
5254
4561
 
5255
4562
  return s0;
@@ -5261,11 +4568,11 @@ function peg$parse(input, options) {
5261
4568
  s0 = peg$currPos;
5262
4569
  s1 = peg$parse__();
5263
4570
  if (input.charCodeAt(peg$currPos) === 44) {
5264
- s2 = peg$c13;
4571
+ s2 = peg$c7;
5265
4572
  peg$currPos++;
5266
4573
  } else {
5267
4574
  s2 = peg$FAILED;
5268
- if (peg$silentFails === 0) { peg$fail(peg$e18); }
4575
+ if (peg$silentFails === 0) { peg$fail(peg$e11); }
5269
4576
  }
5270
4577
  if (s2 !== peg$FAILED) {
5271
4578
  s3 = peg$parse__();
@@ -5276,14 +4583,7 @@ function peg$parse(input, options) {
5276
4583
  s0 = peg$FAILED;
5277
4584
  }
5278
4585
  if (s0 === peg$FAILED) {
5279
- s0 = peg$currPos;
5280
- s1 = peg$parsewhitespaceWithNewLine();
5281
- if (s1 !== peg$FAILED) {
5282
- s0 = s1;
5283
- } else {
5284
- peg$currPos = s0;
5285
- s0 = peg$FAILED;
5286
- }
4586
+ s0 = peg$parsewhitespaceWithNewLine();
5287
4587
  }
5288
4588
 
5289
4589
  return s0;
@@ -5293,34 +4593,34 @@ function peg$parse(input, options) {
5293
4593
  var s0, s1, s2, s3;
5294
4594
 
5295
4595
  s0 = peg$currPos;
5296
- if (input.substr(peg$currPos, 2) === peg$c56) {
5297
- s1 = peg$c56;
4596
+ if (input.substr(peg$currPos, 2) === peg$c53) {
4597
+ s1 = peg$c53;
5298
4598
  peg$currPos += 2;
5299
4599
  } else {
5300
4600
  s1 = peg$FAILED;
5301
- if (peg$silentFails === 0) { peg$fail(peg$e95); }
4601
+ if (peg$silentFails === 0) { peg$fail(peg$e88); }
5302
4602
  }
5303
4603
  if (s1 !== peg$FAILED) {
5304
4604
  s2 = [];
5305
4605
  s3 = input.charAt(peg$currPos);
5306
- if (peg$r10.test(s3)) {
4606
+ if (peg$r7.test(s3)) {
5307
4607
  peg$currPos++;
5308
4608
  } else {
5309
4609
  s3 = peg$FAILED;
5310
- if (peg$silentFails === 0) { peg$fail(peg$e96); }
4610
+ if (peg$silentFails === 0) { peg$fail(peg$e89); }
5311
4611
  }
5312
4612
  while (s3 !== peg$FAILED) {
5313
4613
  s2.push(s3);
5314
4614
  s3 = input.charAt(peg$currPos);
5315
- if (peg$r10.test(s3)) {
4615
+ if (peg$r7.test(s3)) {
5316
4616
  peg$currPos++;
5317
4617
  } else {
5318
4618
  s3 = peg$FAILED;
5319
- if (peg$silentFails === 0) { peg$fail(peg$e96); }
4619
+ if (peg$silentFails === 0) { peg$fail(peg$e89); }
5320
4620
  }
5321
4621
  }
5322
4622
  peg$savedPos = s0;
5323
- s0 = peg$f92();
4623
+ s0 = peg$f78();
5324
4624
  } else {
5325
4625
  peg$currPos = s0;
5326
4626
  s0 = peg$FAILED;
@@ -5329,20 +4629,6 @@ function peg$parse(input, options) {
5329
4629
  return s0;
5330
4630
  }
5331
4631
 
5332
- function peg$parseshellMode() {
5333
- var s0;
5334
-
5335
- peg$savedPos = peg$currPos;
5336
- s0 = peg$f93();
5337
- if (s0) {
5338
- s0 = undefined;
5339
- } else {
5340
- s0 = peg$FAILED;
5341
- }
5342
-
5343
- return s0;
5344
- }
5345
-
5346
4632
  function peg$parseshiftExpression() {
5347
4633
  var s0, s1, s2, s3, s4, s5, s6, s7;
5348
4634
 
@@ -5386,7 +4672,7 @@ function peg$parse(input, options) {
5386
4672
  }
5387
4673
  }
5388
4674
  peg$savedPos = s0;
5389
- s0 = peg$f94(s1, s2);
4675
+ s0 = peg$f79(s1, s2);
5390
4676
  } else {
5391
4677
  peg$currPos = s0;
5392
4678
  s0 = peg$FAILED;
@@ -5398,28 +4684,28 @@ function peg$parse(input, options) {
5398
4684
  function peg$parseshiftOperator() {
5399
4685
  var s0;
5400
4686
 
5401
- if (input.substr(peg$currPos, 2) === peg$c57) {
5402
- s0 = peg$c57;
4687
+ if (input.substr(peg$currPos, 2) === peg$c54) {
4688
+ s0 = peg$c54;
5403
4689
  peg$currPos += 2;
5404
4690
  } else {
5405
4691
  s0 = peg$FAILED;
5406
- if (peg$silentFails === 0) { peg$fail(peg$e97); }
4692
+ if (peg$silentFails === 0) { peg$fail(peg$e90); }
5407
4693
  }
5408
4694
  if (s0 === peg$FAILED) {
5409
- if (input.substr(peg$currPos, 3) === peg$c58) {
5410
- s0 = peg$c58;
4695
+ if (input.substr(peg$currPos, 3) === peg$c55) {
4696
+ s0 = peg$c55;
5411
4697
  peg$currPos += 3;
5412
4698
  } else {
5413
4699
  s0 = peg$FAILED;
5414
- if (peg$silentFails === 0) { peg$fail(peg$e98); }
4700
+ if (peg$silentFails === 0) { peg$fail(peg$e91); }
5415
4701
  }
5416
4702
  if (s0 === peg$FAILED) {
5417
- if (input.substr(peg$currPos, 2) === peg$c59) {
5418
- s0 = peg$c59;
4703
+ if (input.substr(peg$currPos, 2) === peg$c56) {
4704
+ s0 = peg$c56;
5419
4705
  peg$currPos += 2;
5420
4706
  } else {
5421
4707
  s0 = peg$FAILED;
5422
- if (peg$silentFails === 0) { peg$fail(peg$e99); }
4708
+ if (peg$silentFails === 0) { peg$fail(peg$e92); }
5423
4709
  }
5424
4710
  }
5425
4711
  }
@@ -5428,46 +4714,40 @@ function peg$parse(input, options) {
5428
4714
  }
5429
4715
 
5430
4716
  function peg$parseshorthandFunction() {
5431
- var s0, s1, s2, s3, s4, s5;
4717
+ var s0, s1, s2, s3, s4;
5432
4718
 
5433
4719
  peg$silentFails++;
5434
4720
  s0 = peg$currPos;
5435
- s1 = peg$parseshellMode();
4721
+ if (input.charCodeAt(peg$currPos) === 61) {
4722
+ s1 = peg$c47;
4723
+ peg$currPos++;
4724
+ } else {
4725
+ s1 = peg$FAILED;
4726
+ if (peg$silentFails === 0) { peg$fail(peg$e74); }
4727
+ }
5436
4728
  if (s1 !== peg$FAILED) {
4729
+ s2 = peg$currPos;
4730
+ peg$silentFails++;
5437
4731
  if (input.charCodeAt(peg$currPos) === 61) {
5438
- s2 = peg$c52;
4732
+ s3 = peg$c47;
5439
4733
  peg$currPos++;
5440
4734
  } else {
4735
+ s3 = peg$FAILED;
4736
+ if (peg$silentFails === 0) { peg$fail(peg$e74); }
4737
+ }
4738
+ peg$silentFails--;
4739
+ if (s3 === peg$FAILED) {
4740
+ s2 = undefined;
4741
+ } else {
4742
+ peg$currPos = s2;
5441
4743
  s2 = peg$FAILED;
5442
- if (peg$silentFails === 0) { peg$fail(peg$e81); }
5443
4744
  }
5444
4745
  if (s2 !== peg$FAILED) {
5445
- s3 = peg$currPos;
5446
- peg$silentFails++;
5447
- if (input.charCodeAt(peg$currPos) === 61) {
5448
- s4 = peg$c52;
5449
- peg$currPos++;
5450
- } else {
5451
- s4 = peg$FAILED;
5452
- if (peg$silentFails === 0) { peg$fail(peg$e81); }
5453
- }
5454
- peg$silentFails--;
5455
- if (s4 === peg$FAILED) {
5456
- s3 = undefined;
5457
- } else {
5458
- peg$currPos = s3;
5459
- s3 = peg$FAILED;
5460
- }
5461
- if (s3 !== peg$FAILED) {
5462
- s4 = peg$parse__();
5463
- s5 = peg$parseimplicitParenthesesCallExpression();
5464
- if (s5 !== peg$FAILED) {
5465
- peg$savedPos = s0;
5466
- s0 = peg$f95(s5);
5467
- } else {
5468
- peg$currPos = s0;
5469
- s0 = peg$FAILED;
5470
- }
4746
+ s3 = peg$parse__();
4747
+ s4 = peg$parseimplicitParenthesesCallExpression();
4748
+ if (s4 !== peg$FAILED) {
4749
+ peg$savedPos = s0;
4750
+ s0 = peg$f80(s4);
5471
4751
  } else {
5472
4752
  peg$currPos = s0;
5473
4753
  s0 = peg$FAILED;
@@ -5486,7 +4766,7 @@ function peg$parse(input, options) {
5486
4766
  peg$silentFails--;
5487
4767
  if (s0 === peg$FAILED) {
5488
4768
  s1 = peg$FAILED;
5489
- if (peg$silentFails === 0) { peg$fail(peg$e100); }
4769
+ if (peg$silentFails === 0) { peg$fail(peg$e93); }
5490
4770
  }
5491
4771
 
5492
4772
  return s0;
@@ -5496,19 +4776,19 @@ function peg$parse(input, options) {
5496
4776
  var s0;
5497
4777
 
5498
4778
  if (input.charCodeAt(peg$currPos) === 8594) {
5499
- s0 = peg$c60;
4779
+ s0 = peg$c57;
5500
4780
  peg$currPos++;
5501
4781
  } else {
5502
4782
  s0 = peg$FAILED;
5503
- if (peg$silentFails === 0) { peg$fail(peg$e101); }
4783
+ if (peg$silentFails === 0) { peg$fail(peg$e94); }
5504
4784
  }
5505
4785
  if (s0 === peg$FAILED) {
5506
- if (input.substr(peg$currPos, 2) === peg$c61) {
5507
- s0 = peg$c61;
4786
+ if (input.substr(peg$currPos, 2) === peg$c58) {
4787
+ s0 = peg$c58;
5508
4788
  peg$currPos += 2;
5509
4789
  } else {
5510
4790
  s0 = peg$FAILED;
5511
- if (peg$silentFails === 0) { peg$fail(peg$e102); }
4791
+ if (peg$silentFails === 0) { peg$fail(peg$e95); }
5512
4792
  }
5513
4793
  }
5514
4794
 
@@ -5519,34 +4799,34 @@ function peg$parse(input, options) {
5519
4799
  var s0, s1, s2, s3;
5520
4800
 
5521
4801
  s0 = peg$currPos;
5522
- if (input.substr(peg$currPos, 2) === peg$c1) {
5523
- s1 = peg$c1;
4802
+ if (input.substr(peg$currPos, 2) === peg$c49) {
4803
+ s1 = peg$c49;
5524
4804
  peg$currPos += 2;
5525
4805
  } else {
5526
4806
  s1 = peg$FAILED;
5527
- if (peg$silentFails === 0) { peg$fail(peg$e2); }
4807
+ if (peg$silentFails === 0) { peg$fail(peg$e83); }
5528
4808
  }
5529
4809
  if (s1 !== peg$FAILED) {
5530
4810
  s2 = [];
5531
4811
  s3 = input.charAt(peg$currPos);
5532
- if (peg$r10.test(s3)) {
4812
+ if (peg$r7.test(s3)) {
5533
4813
  peg$currPos++;
5534
4814
  } else {
5535
4815
  s3 = peg$FAILED;
5536
- if (peg$silentFails === 0) { peg$fail(peg$e96); }
4816
+ if (peg$silentFails === 0) { peg$fail(peg$e89); }
5537
4817
  }
5538
4818
  while (s3 !== peg$FAILED) {
5539
4819
  s2.push(s3);
5540
4820
  s3 = input.charAt(peg$currPos);
5541
- if (peg$r10.test(s3)) {
4821
+ if (peg$r7.test(s3)) {
5542
4822
  peg$currPos++;
5543
4823
  } else {
5544
4824
  s3 = peg$FAILED;
5545
- if (peg$silentFails === 0) { peg$fail(peg$e96); }
4825
+ if (peg$silentFails === 0) { peg$fail(peg$e89); }
5546
4826
  }
5547
4827
  }
5548
4828
  peg$savedPos = s0;
5549
- s0 = peg$f96();
4829
+ s0 = peg$f81();
5550
4830
  } else {
5551
4831
  peg$currPos = s0;
5552
4832
  s0 = peg$FAILED;
@@ -5561,11 +4841,11 @@ function peg$parse(input, options) {
5561
4841
  peg$silentFails++;
5562
4842
  s0 = peg$currPos;
5563
4843
  if (input.charCodeAt(peg$currPos) === 39) {
5564
- s1 = peg$c35;
4844
+ s1 = peg$c30;
5565
4845
  peg$currPos++;
5566
4846
  } else {
5567
4847
  s1 = peg$FAILED;
5568
- if (peg$silentFails === 0) { peg$fail(peg$e45); }
4848
+ if (peg$silentFails === 0) { peg$fail(peg$e39); }
5569
4849
  }
5570
4850
  if (s1 !== peg$FAILED) {
5571
4851
  s2 = [];
@@ -5577,7 +4857,7 @@ function peg$parse(input, options) {
5577
4857
  s3 = peg$parseexpectSingleQuote();
5578
4858
  if (s3 !== peg$FAILED) {
5579
4859
  peg$savedPos = s0;
5580
- s0 = peg$f97(s2);
4860
+ s0 = peg$f82(s2);
5581
4861
  } else {
5582
4862
  peg$currPos = s0;
5583
4863
  s0 = peg$FAILED;
@@ -5589,7 +4869,7 @@ function peg$parse(input, options) {
5589
4869
  peg$silentFails--;
5590
4870
  if (s0 === peg$FAILED) {
5591
4871
  s1 = peg$FAILED;
5592
- if (peg$silentFails === 0) { peg$fail(peg$e103); }
4872
+ if (peg$silentFails === 0) { peg$fail(peg$e96); }
5593
4873
  }
5594
4874
 
5595
4875
  return s0;
@@ -5602,11 +4882,11 @@ function peg$parse(input, options) {
5602
4882
  s1 = peg$currPos;
5603
4883
  peg$silentFails++;
5604
4884
  if (input.charCodeAt(peg$currPos) === 39) {
5605
- s2 = peg$c35;
4885
+ s2 = peg$c30;
5606
4886
  peg$currPos++;
5607
4887
  } else {
5608
4888
  s2 = peg$FAILED;
5609
- if (peg$silentFails === 0) { peg$fail(peg$e45); }
4889
+ if (peg$silentFails === 0) { peg$fail(peg$e39); }
5610
4890
  }
5611
4891
  if (s2 === peg$FAILED) {
5612
4892
  s2 = peg$parsenewLine();
@@ -5641,7 +4921,7 @@ function peg$parse(input, options) {
5641
4921
  s1 = peg$parseslashFollows();
5642
4922
  if (s1 !== peg$FAILED) {
5643
4923
  peg$savedPos = s0;
5644
- s1 = peg$f98();
4924
+ s1 = peg$f83();
5645
4925
  }
5646
4926
  s0 = s1;
5647
4927
 
@@ -5655,11 +4935,11 @@ function peg$parse(input, options) {
5655
4935
  s1 = peg$currPos;
5656
4936
  peg$silentFails++;
5657
4937
  if (input.charCodeAt(peg$currPos) === 47) {
5658
- s2 = peg$c3;
4938
+ s2 = peg$c48;
5659
4939
  peg$currPos++;
5660
4940
  } else {
5661
4941
  s2 = peg$FAILED;
5662
- if (peg$silentFails === 0) { peg$fail(peg$e4); }
4942
+ if (peg$silentFails === 0) { peg$fail(peg$e78); }
5663
4943
  }
5664
4944
  peg$silentFails--;
5665
4945
  if (s2 !== peg$FAILED) {
@@ -5670,7 +4950,7 @@ function peg$parse(input, options) {
5670
4950
  }
5671
4951
  if (s1 !== peg$FAILED) {
5672
4952
  peg$savedPos = s0;
5673
- s1 = peg$f99();
4953
+ s1 = peg$f84();
5674
4954
  }
5675
4955
  s0 = s1;
5676
4956
 
@@ -5684,10 +4964,10 @@ function peg$parse(input, options) {
5684
4964
  s1 = peg$parseellipsis();
5685
4965
  if (s1 !== peg$FAILED) {
5686
4966
  s2 = peg$parse__();
5687
- s3 = peg$parseexpectPipelineExpression();
4967
+ s3 = peg$parsepipelineExpression();
5688
4968
  if (s3 !== peg$FAILED) {
5689
4969
  peg$savedPos = s0;
5690
- s0 = peg$f100(s3);
4970
+ s0 = peg$f85(s3);
5691
4971
  } else {
5692
4972
  peg$currPos = s0;
5693
4973
  s0 = peg$FAILED;
@@ -5701,33 +4981,20 @@ function peg$parse(input, options) {
5701
4981
  }
5702
4982
 
5703
4983
  function peg$parsestringLiteral() {
5704
- var s0, s1, s2;
4984
+ var s0, s1;
5705
4985
 
5706
4986
  peg$silentFails++;
5707
4987
  s0 = peg$parsedoubleQuoteString();
5708
4988
  if (s0 === peg$FAILED) {
5709
4989
  s0 = peg$parsesingleQuoteString();
5710
4990
  if (s0 === peg$FAILED) {
5711
- s0 = peg$currPos;
5712
- s1 = peg$parseshellMode();
5713
- if (s1 !== peg$FAILED) {
5714
- s2 = peg$parseguillemetString();
5715
- if (s2 !== peg$FAILED) {
5716
- s0 = s2;
5717
- } else {
5718
- peg$currPos = s0;
5719
- s0 = peg$FAILED;
5720
- }
5721
- } else {
5722
- peg$currPos = s0;
5723
- s0 = peg$FAILED;
5724
- }
4991
+ s0 = peg$parseguillemetString();
5725
4992
  }
5726
4993
  }
5727
4994
  peg$silentFails--;
5728
4995
  if (s0 === peg$FAILED) {
5729
4996
  s1 = peg$FAILED;
5730
- if (peg$silentFails === 0) { peg$fail(peg$e104); }
4997
+ if (peg$silentFails === 0) { peg$fail(peg$e97); }
5731
4998
  }
5732
4999
 
5733
5000
  return s0;
@@ -5764,10 +5031,10 @@ function peg$parse(input, options) {
5764
5031
  }
5765
5032
  }
5766
5033
  peg$savedPos = s0;
5767
- s0 = peg$f101(s1, s2);
5034
+ s0 = peg$f86(s1, s2);
5768
5035
  peg$silentFails--;
5769
5036
  s1 = peg$FAILED;
5770
- if (peg$silentFails === 0) { peg$fail(peg$e105); }
5037
+ if (peg$silentFails === 0) { peg$fail(peg$e98); }
5771
5038
 
5772
5039
  return s0;
5773
5040
  }
@@ -5778,12 +5045,12 @@ function peg$parse(input, options) {
5778
5045
  s0 = peg$currPos;
5779
5046
  s1 = peg$currPos;
5780
5047
  peg$silentFails++;
5781
- if (input.substr(peg$currPos, 2) === peg$c62) {
5782
- s2 = peg$c62;
5048
+ if (input.substr(peg$currPos, 2) === peg$c59) {
5049
+ s2 = peg$c59;
5783
5050
  peg$currPos += 2;
5784
5051
  } else {
5785
5052
  s2 = peg$FAILED;
5786
- if (peg$silentFails === 0) { peg$fail(peg$e106); }
5053
+ if (peg$silentFails === 0) { peg$fail(peg$e99); }
5787
5054
  }
5788
5055
  peg$silentFails--;
5789
5056
  if (s2 === peg$FAILED) {
@@ -5820,11 +5087,11 @@ function peg$parse(input, options) {
5820
5087
  s2 = peg$parsetemplateBodyChar();
5821
5088
  }
5822
5089
  peg$savedPos = s0;
5823
- s1 = peg$f102(s1);
5090
+ s1 = peg$f87(s1);
5824
5091
  s0 = s1;
5825
5092
  peg$silentFails--;
5826
5093
  s1 = peg$FAILED;
5827
- if (peg$silentFails === 0) { peg$fail(peg$e107); }
5094
+ if (peg$silentFails === 0) { peg$fail(peg$e100); }
5828
5095
 
5829
5096
  return s0;
5830
5097
  }
@@ -5839,7 +5106,7 @@ function peg$parse(input, options) {
5839
5106
  s2 = peg$parse__();
5840
5107
  s3 = peg$parsetemplateBody();
5841
5108
  peg$savedPos = s0;
5842
- s0 = peg$f103(s1, s3);
5109
+ s0 = peg$f88(s1, s3);
5843
5110
  } else {
5844
5111
  peg$currPos = s0;
5845
5112
  s0 = peg$FAILED;
@@ -5847,26 +5114,17 @@ function peg$parse(input, options) {
5847
5114
  if (s0 === peg$FAILED) {
5848
5115
  s0 = peg$currPos;
5849
5116
  s1 = peg$parsefrontMatterYaml();
5850
- if (s1 !== peg$FAILED) {
5851
- s2 = peg$parsetemplateBody();
5852
- peg$savedPos = s0;
5853
- s0 = peg$f104(s1, s2);
5854
- } else {
5855
- peg$currPos = s0;
5856
- s0 = peg$FAILED;
5857
- }
5858
- if (s0 === peg$FAILED) {
5859
- s0 = peg$currPos;
5860
- s1 = peg$parsetemplateBody();
5861
- peg$savedPos = s0;
5862
- s1 = peg$f105(s1);
5863
- s0 = s1;
5117
+ if (s1 === peg$FAILED) {
5118
+ s1 = null;
5864
5119
  }
5120
+ s2 = peg$parsetemplateBody();
5121
+ peg$savedPos = s0;
5122
+ s0 = peg$f89(s1, s2);
5865
5123
  }
5866
5124
  peg$silentFails--;
5867
5125
  if (s0 === peg$FAILED) {
5868
5126
  s1 = peg$FAILED;
5869
- if (peg$silentFails === 0) { peg$fail(peg$e108); }
5127
+ if (peg$silentFails === 0) { peg$fail(peg$e101); }
5870
5128
  }
5871
5129
 
5872
5130
  return s0;
@@ -5878,11 +5136,11 @@ function peg$parse(input, options) {
5878
5136
  peg$silentFails++;
5879
5137
  s0 = peg$currPos;
5880
5138
  if (input.charCodeAt(peg$currPos) === 96) {
5881
- s1 = peg$c32;
5139
+ s1 = peg$c27;
5882
5140
  peg$currPos++;
5883
5141
  } else {
5884
5142
  s1 = peg$FAILED;
5885
- if (peg$silentFails === 0) { peg$fail(peg$e42); }
5143
+ if (peg$silentFails === 0) { peg$fail(peg$e36); }
5886
5144
  }
5887
5145
  if (s1 !== peg$FAILED) {
5888
5146
  s2 = peg$parsetemplateLiteralText();
@@ -5913,7 +5171,7 @@ function peg$parse(input, options) {
5913
5171
  s4 = peg$parseexpectBacktick();
5914
5172
  if (s4 !== peg$FAILED) {
5915
5173
  peg$savedPos = s0;
5916
- s0 = peg$f106(s2, s3);
5174
+ s0 = peg$f90(s2, s3);
5917
5175
  } else {
5918
5176
  peg$currPos = s0;
5919
5177
  s0 = peg$FAILED;
@@ -5925,7 +5183,7 @@ function peg$parse(input, options) {
5925
5183
  peg$silentFails--;
5926
5184
  if (s0 === peg$FAILED) {
5927
5185
  s1 = peg$FAILED;
5928
- if (peg$silentFails === 0) { peg$fail(peg$e109); }
5186
+ if (peg$silentFails === 0) { peg$fail(peg$e102); }
5929
5187
  }
5930
5188
 
5931
5189
  return s0;
@@ -5938,19 +5196,19 @@ function peg$parse(input, options) {
5938
5196
  s1 = peg$currPos;
5939
5197
  peg$silentFails++;
5940
5198
  if (input.charCodeAt(peg$currPos) === 96) {
5941
- s2 = peg$c32;
5199
+ s2 = peg$c27;
5942
5200
  peg$currPos++;
5943
5201
  } else {
5944
5202
  s2 = peg$FAILED;
5945
- if (peg$silentFails === 0) { peg$fail(peg$e42); }
5203
+ if (peg$silentFails === 0) { peg$fail(peg$e36); }
5946
5204
  }
5947
5205
  if (s2 === peg$FAILED) {
5948
- if (input.substr(peg$currPos, 2) === peg$c62) {
5949
- s2 = peg$c62;
5206
+ if (input.substr(peg$currPos, 2) === peg$c59) {
5207
+ s2 = peg$c59;
5950
5208
  peg$currPos += 2;
5951
5209
  } else {
5952
5210
  s2 = peg$FAILED;
5953
- if (peg$silentFails === 0) { peg$fail(peg$e106); }
5211
+ if (peg$silentFails === 0) { peg$fail(peg$e99); }
5954
5212
  }
5955
5213
  }
5956
5214
  peg$silentFails--;
@@ -5987,7 +5245,7 @@ function peg$parse(input, options) {
5987
5245
  s2 = peg$parsetemplateLiteralChar();
5988
5246
  }
5989
5247
  peg$savedPos = s0;
5990
- s1 = peg$f107(s1);
5248
+ s1 = peg$f91(s1);
5991
5249
  s0 = s1;
5992
5250
 
5993
5251
  return s0;
@@ -5998,26 +5256,26 @@ function peg$parse(input, options) {
5998
5256
 
5999
5257
  peg$silentFails++;
6000
5258
  s0 = peg$currPos;
6001
- if (input.substr(peg$currPos, 2) === peg$c62) {
6002
- s1 = peg$c62;
5259
+ if (input.substr(peg$currPos, 2) === peg$c59) {
5260
+ s1 = peg$c59;
6003
5261
  peg$currPos += 2;
6004
5262
  } else {
6005
5263
  s1 = peg$FAILED;
6006
- if (peg$silentFails === 0) { peg$fail(peg$e106); }
5264
+ if (peg$silentFails === 0) { peg$fail(peg$e99); }
6007
5265
  }
6008
5266
  if (s1 !== peg$FAILED) {
6009
5267
  s2 = peg$parseexpectExpression();
6010
5268
  if (s2 !== peg$FAILED) {
6011
5269
  if (input.charCodeAt(peg$currPos) === 125) {
6012
- s3 = peg$c33;
5270
+ s3 = peg$c28;
6013
5271
  peg$currPos++;
6014
5272
  } else {
6015
5273
  s3 = peg$FAILED;
6016
- if (peg$silentFails === 0) { peg$fail(peg$e43); }
5274
+ if (peg$silentFails === 0) { peg$fail(peg$e37); }
6017
5275
  }
6018
5276
  if (s3 !== peg$FAILED) {
6019
5277
  peg$savedPos = s0;
6020
- s0 = peg$f108(s2);
5278
+ s0 = peg$f92(s2);
6021
5279
  } else {
6022
5280
  peg$currPos = s0;
6023
5281
  s0 = peg$FAILED;
@@ -6033,7 +5291,7 @@ function peg$parse(input, options) {
6033
5291
  peg$silentFails--;
6034
5292
  if (s0 === peg$FAILED) {
6035
5293
  s1 = peg$FAILED;
6036
- if (peg$silentFails === 0) { peg$fail(peg$e110); }
5294
+ if (peg$silentFails === 0) { peg$fail(peg$e103); }
6037
5295
  }
6038
5296
 
6039
5297
  return s0;
@@ -6049,7 +5307,7 @@ function peg$parse(input, options) {
6049
5307
  peg$currPos++;
6050
5308
  } else {
6051
5309
  s0 = peg$FAILED;
6052
- if (peg$silentFails === 0) { peg$fail(peg$e41); }
5310
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
6053
5311
  }
6054
5312
  }
6055
5313
 
@@ -6066,7 +5324,7 @@ function peg$parse(input, options) {
6066
5324
  s3 = peg$parseunaryExpression();
6067
5325
  if (s3 !== peg$FAILED) {
6068
5326
  peg$savedPos = s0;
6069
- s0 = peg$f109(s1, s3);
5327
+ s0 = peg$f93(s1, s3);
6070
5328
  } else {
6071
5329
  peg$currPos = s0;
6072
5330
  s0 = peg$FAILED;
@@ -6083,88 +5341,14 @@ function peg$parse(input, options) {
6083
5341
  }
6084
5342
 
6085
5343
  function peg$parseunaryOperator() {
6086
- var s0, s1, s2, s3;
5344
+ var s0;
6087
5345
 
6088
5346
  s0 = input.charAt(peg$currPos);
6089
- if (peg$r11.test(s0)) {
5347
+ if (peg$r8.test(s0)) {
6090
5348
  peg$currPos++;
6091
5349
  } else {
6092
5350
  s0 = peg$FAILED;
6093
- if (peg$silentFails === 0) { peg$fail(peg$e111); }
6094
- }
6095
- if (s0 === peg$FAILED) {
6096
- s0 = peg$currPos;
6097
- if (input.charCodeAt(peg$currPos) === 45) {
6098
- s1 = peg$c40;
6099
- peg$currPos++;
6100
- } else {
6101
- s1 = peg$FAILED;
6102
- if (peg$silentFails === 0) { peg$fail(peg$e57); }
6103
- }
6104
- if (s1 !== peg$FAILED) {
6105
- s2 = peg$currPos;
6106
- peg$silentFails++;
6107
- if (input.substr(peg$currPos, 2) === peg$c63) {
6108
- s3 = peg$c63;
6109
- peg$currPos += 2;
6110
- } else {
6111
- s3 = peg$FAILED;
6112
- if (peg$silentFails === 0) { peg$fail(peg$e112); }
6113
- }
6114
- peg$silentFails--;
6115
- if (s3 === peg$FAILED) {
6116
- s2 = undefined;
6117
- } else {
6118
- peg$currPos = s2;
6119
- s2 = peg$FAILED;
6120
- }
6121
- if (s2 !== peg$FAILED) {
6122
- s0 = s1;
6123
- } else {
6124
- peg$currPos = s0;
6125
- s0 = peg$FAILED;
6126
- }
6127
- } else {
6128
- peg$currPos = s0;
6129
- s0 = peg$FAILED;
6130
- }
6131
- if (s0 === peg$FAILED) {
6132
- s0 = peg$currPos;
6133
- if (input.charCodeAt(peg$currPos) === 126) {
6134
- s1 = peg$c4;
6135
- peg$currPos++;
6136
- } else {
6137
- s1 = peg$FAILED;
6138
- if (peg$silentFails === 0) { peg$fail(peg$e5); }
6139
- }
6140
- if (s1 !== peg$FAILED) {
6141
- s2 = peg$currPos;
6142
- peg$silentFails++;
6143
- if (input.charCodeAt(peg$currPos) === 47) {
6144
- s3 = peg$c3;
6145
- peg$currPos++;
6146
- } else {
6147
- s3 = peg$FAILED;
6148
- if (peg$silentFails === 0) { peg$fail(peg$e4); }
6149
- }
6150
- peg$silentFails--;
6151
- if (s3 === peg$FAILED) {
6152
- s2 = undefined;
6153
- } else {
6154
- peg$currPos = s2;
6155
- s2 = peg$FAILED;
6156
- }
6157
- if (s2 !== peg$FAILED) {
6158
- s0 = s1;
6159
- } else {
6160
- peg$currPos = s0;
6161
- s0 = peg$FAILED;
6162
- }
6163
- } else {
6164
- peg$currPos = s0;
6165
- s0 = peg$FAILED;
6166
- }
6167
- }
5351
+ if (peg$silentFails === 0) { peg$fail(peg$e104); }
6168
5352
  }
6169
5353
 
6170
5354
  return s0;
@@ -6184,40 +5368,6 @@ function peg$parse(input, options) {
6184
5368
  return s0;
6185
5369
  }
6186
5370
 
6187
- function peg$parsewhitespaceShell() {
6188
- var s0, s1, s2;
6189
-
6190
- s0 = peg$currPos;
6191
- s1 = peg$parseshellMode();
6192
- if (s1 !== peg$FAILED) {
6193
- s2 = peg$parsewhitespace();
6194
- if (s2 !== peg$FAILED) {
6195
- s1 = [s1, s2];
6196
- s0 = s1;
6197
- } else {
6198
- peg$currPos = s0;
6199
- s0 = peg$FAILED;
6200
- }
6201
- } else {
6202
- peg$currPos = s0;
6203
- s0 = peg$FAILED;
6204
- }
6205
- if (s0 === peg$FAILED) {
6206
- s0 = peg$currPos;
6207
- s1 = peg$parsejseMode();
6208
- if (s1 !== peg$FAILED) {
6209
- s2 = peg$parse__();
6210
- s1 = [s1, s2];
6211
- s0 = s1;
6212
- } else {
6213
- peg$currPos = s0;
6214
- s0 = peg$FAILED;
6215
- }
6216
- }
6217
-
6218
- return s0;
6219
- }
6220
-
6221
5371
  function peg$parsewhitespaceWithNewLine() {
6222
5372
  var s0, s1, s2, s3, s4;
6223
5373
 
@@ -6277,11 +5427,6 @@ const peg$allowedStartRules = [
6277
5427
  "__",
6278
5428
  "additiveExpression",
6279
5429
  "additiveOperator",
6280
- "angleBracketLiteral",
6281
- "angleBracketPath",
6282
- "angleBracketPathKey",
6283
- "angleBracketPathChar",
6284
- "angleBracketProtocol",
6285
5430
  "arguments",
6286
5431
  "arrayLiteral",
6287
5432
  "arrayEntries",
@@ -6332,22 +5477,21 @@ const peg$allowedStartRules = [
6332
5477
  "identifierChar",
6333
5478
  "implicitParenthesesCallExpression",
6334
5479
  "implicitParensthesesArguments",
5480
+ "inherited",
6335
5481
  "inlineSpace",
6336
5482
  "integerLiteral",
6337
- "jseMode",
6338
5483
  "jsIdentifier",
6339
5484
  "jsIdentifierPart",
6340
5485
  "jsIdentifierStart",
6341
5486
  "jsPropertyAccess",
6342
- "jsReference",
6343
5487
  "list",
5488
+ "literal",
6344
5489
  "logicalAndExpression",
6345
5490
  "logicalOrExpression",
6346
5491
  "multiLineComment",
6347
5492
  "multiplicativeExpression",
6348
5493
  "multiplicativeOperator",
6349
5494
  "namespace",
6350
- "newExpression",
6351
5495
  "newLine",
6352
5496
  "numericLiteral",
6353
5497
  "nullishCoalescingExpression",
@@ -6360,7 +5504,6 @@ const peg$allowedStartRules = [
6360
5504
  "objectProperty",
6361
5505
  "objectShorthandProperty",
6362
5506
  "objectPublicKey",
6363
- "optionalChaining",
6364
5507
  "parameter",
6365
5508
  "parameterList",
6366
5509
  "parameterSingleton",
@@ -6372,21 +5515,15 @@ const peg$allowedStartRules = [
6372
5515
  "pathSegmentChar",
6373
5516
  "pipelineExpression",
6374
5517
  "primary",
6375
- "primaryJse",
6376
- "primaryShell",
6377
5518
  "program",
6378
5519
  "protocolExpression",
6379
5520
  "qualifiedReference",
6380
- "regexFlags",
6381
- "regexLiteral",
6382
- "regexLiteralChar",
6383
5521
  "relationalExpression",
6384
5522
  "relationalOperator",
6385
5523
  "rootDirectory",
6386
5524
  "scopeReference",
6387
5525
  "separator",
6388
5526
  "shebang",
6389
- "shellMode",
6390
5527
  "shiftExpression",
6391
5528
  "shiftOperator",
6392
5529
  "shorthandFunction",
@@ -6410,7 +5547,6 @@ const peg$allowedStartRules = [
6410
5547
  "unaryExpression",
6411
5548
  "unaryOperator",
6412
5549
  "whitespace",
6413
- "whitespaceShell",
6414
5550
  "whitespaceWithNewLine"
6415
5551
  ];
6416
5552