@weborigami/language 0.3.3-jse.2 → 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 (14) hide show
  1. package/main.js +1 -1
  2. package/package.json +3 -3
  3. package/src/compiler/compile.js +0 -2
  4. package/src/compiler/origami.pegjs +28 -118
  5. package/src/compiler/parse.js +818 -1502
  6. package/src/compiler/parserHelpers.js +12 -13
  7. package/src/runtime/handlers.js +1 -4
  8. package/src/runtime/ops.js +10 -34
  9. package/src/runtime/{templateIndent.js → taggedTemplateIndent.js} +2 -2
  10. package/test/compiler/parse.test.js +24 -142
  11. package/test/runtime/ops.test.js +2 -11
  12. package/test/runtime/taggedTemplateIndent.test.js +1 -1
  13. package/src/runtime/templateStandard.js +0 -13
  14. package/test/runtime/templateText.test.js +0 -18
package/src/compiler/parse.js CHANGED
@@ -206,198 +206,185 @@ function peg$parse(input, options) {
206
206
  var peg$FAILED = {};
207
207
  var peg$source = options.grammarSource;
208
208
 
209
- 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 };
210
210
  var peg$startRuleFunction = peg$parse__;
211
211
 
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 = "|";
223
- var peg$c11 = "^";
224
- var peg$c12 = ",";
225
- var peg$c13 = "?";
226
- var peg$c14 = "\u21D2";
227
- var peg$c15 = "=>";
228
- var peg$c16 = "\"";
229
- var peg$c17 = "...";
230
- var peg$c18 = "\u2026";
231
- var peg$c19 = "===";
232
- var peg$c20 = "!==";
233
- var peg$c21 = "==";
234
- var peg$c22 = "!=";
235
- var peg$c23 = "\\0";
236
- var peg$c24 = "\\b";
237
- var peg$c25 = "\\f";
238
- var peg$c26 = "\\n";
239
- var peg$c27 = "\\r";
240
- var peg$c28 = "\\t";
241
- var peg$c29 = "\\v";
242
- var peg$c30 = "\\";
243
- var peg$c31 = "`";
244
- var peg$c32 = "}";
245
- var peg$c33 = "\xBB";
246
- var peg$c34 = "'";
247
- var peg$c35 = "**";
248
- var peg$c36 = ".";
249
- var peg$c37 = "---\n";
250
- var peg$c38 = "\xAB";
251
- var peg$c39 = "~";
252
- var peg$c40 = "-";
253
- var peg$c41 = "&&";
254
- var peg$c42 = "||";
255
- var peg$c43 = "/*";
256
- var peg$c44 = "*/";
257
- var peg$c45 = "new";
258
- var peg$c46 = "\n";
259
- var peg$c47 = "\r\n";
260
- var peg$c48 = "\r";
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 = ">>>";
270
- var peg$c58 = ">>";
271
- var peg$c59 = "\u2192";
272
- var peg$c60 = "->";
273
- var peg$c61 = "${";
274
- var peg$c62 = "-\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 = "${";
275
272
 
276
273
  var peg$r0 = /^[+\-]/;
277
- var peg$r1 = /^[^\/:<>]/;
278
- var peg$r2 = /^[0-9]/;
279
- var peg$r3 = /^[^(){}[\]<>?!|\-=,\/:`"'\xAB\xBB\\\u2192\u21D2\u2026 \t\n\r]/;
280
- var peg$r4 = /^[ \t]/;
281
- var peg$r5 = /^[%*\/]/;
282
- var peg$r6 = /^[A-Za-z]/;
283
- var peg$r7 = /^[^(){}[\],:\/\\ \t\n\r]/;
284
- var peg$r8 = /^[gimuy]/;
285
- var peg$r9 = /^[^\/\n\r]/;
286
- var peg$r10 = /^[^\n\r]/;
287
- 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 = /^[!+\-~]/;
288
282
 
289
283
  var peg$e0 = peg$classExpectation(["+", "-"], false, false);
290
- var peg$e1 = peg$literalExpectation("<", false);
291
- var peg$e2 = peg$literalExpectation("//", false);
292
- var peg$e3 = peg$literalExpectation(">", false);
293
- var peg$e4 = peg$literalExpectation("/", false);
294
- var peg$e5 = peg$classExpectation(["/", ":", "<", ">"], true, false);
295
- var peg$e6 = peg$literalExpectation(":", false);
296
- var peg$e7 = peg$otherExpectation("function arguments");
297
- var peg$e8 = peg$otherExpectation("array");
298
- var peg$e9 = peg$literalExpectation("[", false);
299
- var peg$e10 = peg$literalExpectation("]", false);
300
- var peg$e11 = peg$literalExpectation("(", false);
301
- var peg$e12 = peg$literalExpectation(")", false);
302
- var peg$e13 = peg$literalExpectation("&", false);
303
- var peg$e14 = peg$literalExpectation("|", false);
304
- var peg$e15 = peg$literalExpectation("^", false);
305
- var peg$e16 = peg$otherExpectation("function call");
306
- var peg$e17 = peg$literalExpectation(",", false);
307
- var peg$e18 = peg$otherExpectation("comment");
308
- var peg$e19 = peg$literalExpectation("?", false);
309
- var peg$e20 = peg$classExpectation([["0", "9"]], false, false);
310
- var peg$e21 = peg$literalExpectation("\u21D2", false);
311
- var peg$e22 = peg$literalExpectation("=>", false);
312
- var peg$e23 = peg$otherExpectation("double quote string");
313
- var peg$e24 = peg$literalExpectation("\"", false);
314
- var peg$e25 = peg$literalExpectation("...", false);
315
- var peg$e26 = peg$literalExpectation("\u2026", false);
316
- var peg$e27 = peg$literalExpectation("===", false);
317
- var peg$e28 = peg$literalExpectation("!==", false);
318
- var peg$e29 = peg$literalExpectation("==", false);
319
- var peg$e30 = peg$literalExpectation("!=", false);
320
- var peg$e31 = peg$otherExpectation("backslash-escaped character");
321
- var peg$e32 = peg$literalExpectation("\\0", false);
322
- var peg$e33 = peg$literalExpectation("\\b", false);
323
- var peg$e34 = peg$literalExpectation("\\f", false);
324
- var peg$e35 = peg$literalExpectation("\\n", false);
325
- var peg$e36 = peg$literalExpectation("\\r", false);
326
- var peg$e37 = peg$literalExpectation("\\t", false);
327
- var peg$e38 = peg$literalExpectation("\\v", false);
328
- var peg$e39 = peg$literalExpectation("\\", false);
329
- var peg$e40 = peg$anyExpectation();
330
- var peg$e41 = peg$literalExpectation("`", false);
331
- var peg$e42 = peg$literalExpectation("}", false);
332
- var peg$e43 = peg$literalExpectation("\xBB", false);
333
- var peg$e44 = peg$literalExpectation("'", false);
334
- var peg$e45 = peg$literalExpectation("**", false);
335
- var peg$e46 = peg$otherExpectation("floating-point number");
336
- var peg$e47 = peg$literalExpectation(".", false);
337
- var peg$e48 = peg$literalExpectation("---\n", false);
338
- var peg$e49 = peg$otherExpectation("YAML front matter");
339
- var peg$e50 = peg$otherExpectation("parenthetical group");
340
- var peg$e51 = peg$otherExpectation("guillemet string");
341
- var peg$e52 = peg$literalExpectation("\xAB", false);
342
- var peg$e53 = peg$literalExpectation("~", false);
343
- var peg$e54 = peg$otherExpectation("HTTP/HTTPS host");
344
- var peg$e55 = peg$otherExpectation("identifier");
345
- var peg$e56 = peg$classExpectation(["(", ")", "{", "}", "[", "]", "<", ">", "?", "!", "|", "-", "=", ",", "/", ":", "`", "\"", "'", "\xAB", "\xBB", "\\", "\u2192", "\u21D2", "\u2026", " ", "\t", "\n", "\r"], true, false);
346
- var peg$e57 = peg$literalExpectation("-", false);
347
- var peg$e58 = peg$otherExpectation("function call with implicit parentheses");
348
- var peg$e59 = peg$classExpectation([" ", "\t"], false, false);
349
- var peg$e60 = peg$otherExpectation("integer");
350
- var peg$e61 = peg$otherExpectation("JavaScript identifier continuation");
351
- var peg$e62 = peg$otherExpectation("JavaScript identifier start");
352
- var peg$e63 = peg$otherExpectation("identifier reference");
353
- var peg$e64 = peg$otherExpectation("list");
354
- var peg$e65 = peg$literalExpectation("&&", false);
355
- var peg$e66 = peg$literalExpectation("||", false);
356
- var peg$e67 = peg$literalExpectation("/*", false);
357
- var peg$e68 = peg$literalExpectation("*/", false);
358
- var peg$e69 = peg$classExpectation(["%", "*", "/"], false, false);
359
- var peg$e70 = peg$classExpectation([["A", "Z"], ["a", "z"]], false, false);
360
- var peg$e71 = peg$literalExpectation("new", false);
361
- var peg$e72 = peg$literalExpectation("\n", false);
362
- var peg$e73 = peg$literalExpectation("\r\n", false);
363
- var peg$e74 = peg$literalExpectation("\r", false);
364
- var peg$e75 = peg$otherExpectation("number");
365
- var peg$e76 = peg$literalExpectation("??", false);
366
- var peg$e77 = peg$otherExpectation("object literal");
367
- var peg$e78 = peg$literalExpectation("{", false);
368
- var peg$e79 = peg$otherExpectation("object getter");
369
- var peg$e80 = peg$literalExpectation("=", false);
370
- var peg$e81 = peg$otherExpectation("object key");
371
- var peg$e82 = peg$otherExpectation("object property");
372
- var peg$e83 = peg$otherExpectation("object identifier");
373
- var peg$e84 = peg$literalExpectation("?.", false);
374
- var peg$e85 = peg$otherExpectation("function arguments in parentheses");
375
- var peg$e86 = peg$otherExpectation("slash-separated path");
376
- var peg$e87 = peg$classExpectation(["(", ")", "{", "}", "[", "]", ",", ":", "/", "\\", " ", "\t", "\n", "\r"], true, false);
377
- var peg$e88 = peg$otherExpectation("Origami program");
378
- var peg$e89 = peg$classExpectation(["g", "i", "m", "u", "y"], false, false);
379
- var peg$e90 = peg$classExpectation(["/", "\n", "\r"], true, false);
380
- var peg$e91 = peg$literalExpectation("<=", false);
381
- var peg$e92 = peg$literalExpectation(">=", false);
382
- var peg$e93 = peg$otherExpectation("scope reference");
383
- var peg$e94 = peg$literalExpectation("#!", false);
384
- var peg$e95 = peg$classExpectation(["\n", "\r"], true, false);
385
- var peg$e96 = peg$literalExpectation("<<", false);
386
- var peg$e97 = peg$literalExpectation(">>>", false);
387
- var peg$e98 = peg$literalExpectation(">>", false);
388
- var peg$e99 = peg$otherExpectation("lambda function");
389
- var peg$e100 = peg$literalExpectation("\u2192", false);
390
- var peg$e101 = peg$literalExpectation("->", false);
391
- var peg$e102 = peg$otherExpectation("single quote string");
392
- var peg$e103 = peg$otherExpectation("string");
393
- var peg$e104 = peg$otherExpectation("template");
394
- var peg$e105 = peg$literalExpectation("${", false);
395
- var peg$e106 = peg$otherExpectation("template text");
396
- var peg$e107 = peg$otherExpectation("template document");
397
- var peg$e108 = peg$otherExpectation("template literal");
398
- var peg$e109 = peg$otherExpectation("template substitution");
399
- var peg$e110 = peg$classExpectation(["!", "+"], false, false);
400
- var peg$e111 = 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);
401
388
 
402
389
  var peg$f0 = function() {
403
390
  return null;
@@ -405,66 +392,43 @@ function peg$parse(input, options) {
405
392
  var peg$f1 = function(head, tail) {
406
393
  return tail.reduce(makeBinaryOperation, head);
407
394
  };
408
- var peg$f2 = function(protocol, path) {
409
- return annotate([protocol, ...path], location());
410
- };
411
- var peg$f3 = function(protocol, path) {
412
- const [head, ...tail] = path;
413
- const root = annotate([protocol, head], location());
414
- return annotate([ops.traverse, root, ...tail], location());
415
- };
416
- var peg$f4 = function(path) {
417
- const [head, ...tail] = path;
418
- const root = annotate([ops.scope, head[1]], location());
419
- return tail.length === 0
420
- ? root
421
- : annotate([ops.traverse, root, ...tail], location())
422
- };
423
- var peg$f5 = function(chars, slashFollows) {
424
- // Append a trailing slash if one follows (but don't consume it)
425
- const key = chars.join("") + (slashFollows ? "/" : "");
426
- return annotate([ops.literal, key], location());
427
- };
428
- var peg$f6 = function(protocol) {
429
- return annotate([ops.builtin, `${protocol}:`], location());
430
- };
431
- var peg$f7 = function(entries) {
395
+ var peg$f2 = function(entries) {
432
396
  return makeArray(entries ?? [], location());
433
397
  };
434
- var peg$f8 = function(entries) {
398
+ var peg$f3 = function(entries) {
435
399
  return annotate(entries, location());
436
400
  };
437
- var peg$f9 = function() {
401
+ var peg$f4 = function() {
438
402
  return annotate([ops.literal, undefined], location());
439
403
  };
440
- var peg$f10 = function(parameters, pipeline) {
404
+ var peg$f5 = function(parameters, pipeline) {
441
405
  const lambdaParameters = parameters ?? annotate([], location());
442
406
  return annotate([ops.lambda, lambdaParameters, pipeline], location());
443
407
  };
444
- var peg$f11 = function(parameter, pipeline) {
408
+ var peg$f6 = function(parameter, pipeline) {
445
409
  return annotate([ops.lambda, parameter, pipeline], location());
446
410
  };
447
- var peg$f12 = function(head, tail) {
411
+ var peg$f7 = function(head, tail) {
448
412
  return tail.reduce(makeBinaryOperation, head);
449
413
  };
450
- var peg$f13 = function(head, tail) {
414
+ var peg$f8 = function(head, tail) {
451
415
  return tail.reduce(makeBinaryOperation, head);
452
416
  };
453
- var peg$f14 = function(head, tail) {
417
+ var peg$f9 = function(head, tail) {
454
418
  return tail.reduce(makeBinaryOperation, head);
455
419
  };
456
- var peg$f15 = function(head, tail) {
420
+ var peg$f10 = function(head, tail) {
457
421
  return tail.reduce(makeCall, head);
458
422
  };
459
- var peg$f16 = function(list) {
423
+ var peg$f11 = function(list) {
460
424
  return list.length === 1
461
425
  ? list[0]
462
426
  : annotate([ops.comma, ...list], location());
463
427
  };
464
- var peg$f17 = function(expression) {
428
+ var peg$f12 = function(expression) {
465
429
  return annotate([ops.traverse, expression], location());
466
430
  };
467
- var peg$f18 = function(condition, tail) {
431
+ var peg$f13 = function(condition, tail) {
468
432
  if (!tail) {
469
433
  return condition;
470
434
  }
@@ -476,103 +440,99 @@ function peg$parse(input, options) {
476
440
  downgradeReference(deferred[1])
477
441
  ], location());
478
442
  };
479
- var peg$f19 = function(chars) {
443
+ var peg$f14 = function(chars) {
480
444
  return annotate([ops.literal, chars.join("")], location());
481
445
  };
482
- var peg$f20 = function(head, tail) {
446
+ var peg$f15 = function(head, tail) {
483
447
  return tail.reduce(makeBinaryOperation, head);
484
448
  };
485
- var peg$f21 = function() { return "\0"; };
486
- var peg$f22 = function() { return "\b"; };
487
- var peg$f23 = function() { return "\f"; };
488
- var peg$f24 = function() { return "\n"; };
489
- var peg$f25 = function() { return "\r"; };
490
- var peg$f26 = function() { return "\t"; };
491
- var peg$f27 = function() { return "\v"; };
492
- var peg$f28 = 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() {
493
457
  error("Expected closing backtick");
494
458
  };
495
- var peg$f29 = function() {
459
+ var peg$f24 = function() {
496
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").`);
497
461
  };
498
- var peg$f30 = function() {
462
+ var peg$f25 = function() {
499
463
  error("Expected right bracket");
500
464
  };
501
- var peg$f31 = function() {
465
+ var peg$f26 = function() {
502
466
  error("Expected right parenthesis");
503
467
  };
504
- var peg$f32 = function() {
468
+ var peg$f27 = function() {
505
469
  error("Expected closing quote");
506
470
  };
507
- var peg$f33 = function() {
471
+ var peg$f28 = function() {
508
472
  error("Expected an Origami expression");
509
473
  };
510
- var peg$f34 = function() {
474
+ var peg$f29 = function() {
511
475
  error("Expected \"---\"");
512
476
  };
513
- var peg$f35 = function() {
477
+ var peg$f30 = function() {
514
478
  error("Expected closing guillemet");
515
479
  };
516
- var peg$f36 = function() {
480
+ var peg$f31 = function() {
517
481
  error("Expected closing quote");
518
482
  };
519
- var peg$f37 = function() {
483
+ var peg$f32 = function() {
520
484
  error("Expected an expression");
521
485
  };
522
- var peg$f38 = function(left, right) {
486
+ var peg$f33 = function(left, right) {
523
487
  return right ? annotate([ops.exponentiation, left, right], location()) : left;
524
488
  };
525
- var peg$f39 = function() {
489
+ var peg$f34 = function() {
526
490
  return annotate([ops.literal, parseFloat(text())], location());
527
491
  };
528
- var peg$f40 = function() {
492
+ var peg$f35 = function() {
529
493
  return isOrigamiFrontMatter(input.slice(location().end.offset))
530
494
  };
531
- var peg$f41 = function(chars) {
495
+ var peg$f36 = function(chars) {
532
496
  return chars.join("");
533
497
  };
534
- var peg$f42 = function(yaml) {
498
+ var peg$f37 = function(yaml) {
535
499
  return makeYamlObject(yaml, location());
536
500
  };
537
- var peg$f43 = function(expression) {
501
+ var peg$f38 = function(expression) {
538
502
  return annotate(downgradeReference(expression), location());
539
503
  };
540
- var peg$f44 = function(chars) {
504
+ var peg$f39 = function(chars) {
541
505
  return annotate([ops.literal, chars.join("")], location());
542
506
  };
543
- var peg$f45 = function() {
507
+ var peg$f40 = function() {
544
508
  return annotate([ops.homeDirectory], location());
545
509
  };
546
- var peg$f46 = function(identifier, port, slashFollows) {
510
+ var peg$f41 = function(identifier, port, slashFollows) {
547
511
  const portText = port ? `:${port[1]}` : "";
548
512
  const slashText = slashFollows ? "/" : "";
549
513
  const hostText = identifier + portText + slashText;
550
514
  return annotate([ops.literal, hostText], location());
551
515
  };
552
- var peg$f47 = function(chars) { return chars.join(""); };
553
- var peg$f48 = function(head, args) {
516
+ var peg$f42 = function(chars) { return chars.join(""); };
517
+ var peg$f43 = function(head, args) {
554
518
  return args ? makeCall(head, args) : head;
555
519
  };
556
- var peg$f49 = function(values) {
520
+ var peg$f44 = function(values) {
557
521
  return annotate(values, location());
558
522
  };
559
- var peg$f50 = function() {
523
+ var peg$f45 = function() {
560
524
  return annotate([ops.literal, parseInt(text())], location());
561
525
  };
562
- var peg$f51 = function() { return options.mode === "jse" };
563
- var peg$f52 = function(char) { return char.match(/[$_\p{ID_Continue}]/u) };
564
- var peg$f53 = function(char) { return char.match(/[$_\p{ID_Start}]/u) };
565
- var peg$f54 = function(property) {
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) {
566
529
  const literal = annotate([ops.literal, property], location());
567
530
  return annotate([ops.traverse, literal], location());
568
531
  };
569
- var peg$f55 = function(id) {
570
- return annotate([ops.scope, id], location());
571
- };
572
- var peg$f56 = function(values) {
532
+ var peg$f49 = function(values) {
573
533
  return annotate(values, location());
574
534
  };
575
- var peg$f57 = function(head, tail) {
535
+ var peg$f50 = function(head, tail) {
576
536
  return tail.length === 0
577
537
  ? head
578
538
  : annotate(
@@ -580,7 +540,7 @@ function peg$parse(input, options) {
580
540
  location()
581
541
  );
582
542
  };
583
- var peg$f58 = function(head, tail) {
543
+ var peg$f51 = function(head, tail) {
584
544
  return tail.length === 0
585
545
  ? head
586
546
  : annotate(
@@ -588,18 +548,14 @@ function peg$parse(input, options) {
588
548
  location()
589
549
  );
590
550
  };
591
- var peg$f59 = function() { return null; };
592
- var peg$f60 = function(head, tail) {
551
+ var peg$f52 = function() { return null; };
552
+ var peg$f53 = function(head, tail) {
593
553
  return tail.reduce(makeBinaryOperation, head);
594
554
  };
595
- var peg$f61 = function(chars) {
555
+ var peg$f54 = function(chars) {
596
556
  return annotate([ops.builtin, chars.join("") + ":"], location());
597
557
  };
598
- var peg$f62 = function(head, tail) {
599
- const args = tail?.[0] !== undefined ? tail : [];
600
- return annotate([ops.construct, head, ...args], location());
601
- };
602
- var peg$f63 = function(head, tail) {
558
+ var peg$f55 = function(head, tail) {
603
559
  return tail.length === 0
604
560
  ? head
605
561
  : annotate(
@@ -607,125 +563,113 @@ function peg$parse(input, options) {
607
563
  location()
608
564
  );
609
565
  };
610
- var peg$f64 = function(entries) {
566
+ var peg$f56 = function(entries) {
611
567
  return makeObject(entries ?? [], location());
612
568
  };
613
- var peg$f65 = function(entries) {
569
+ var peg$f57 = function(entries) {
614
570
  return annotate(entries, location());
615
571
  };
616
- var peg$f66 = function(key, pipeline) {
572
+ var peg$f58 = function(key, pipeline) {
617
573
  return annotate(
618
574
  makeProperty(key, annotate([ops.getter, pipeline], location())),
619
575
  location()
620
576
  );
621
577
  };
622
- var peg$f67 = function(hiddenKey) { return hiddenKey.join(""); };
623
- var peg$f68 = function(key, pipeline) {
578
+ var peg$f59 = function(hiddenKey) { return hiddenKey.join(""); };
579
+ var peg$f60 = function(key, pipeline) {
624
580
  return annotate(makeProperty(key, pipeline), location());
625
581
  };
626
- var peg$f69 = function(key) {
582
+ var peg$f61 = function(key) {
627
583
  const inherited = annotate([ops.inherited, key], location());
628
584
  return annotate([key, inherited], location());
629
585
  };
630
- var peg$f70 = function(identifier, slash) {
631
- return identifier + (slash ?? "");
632
- };
633
- var peg$f71 = function(string) {
634
- // Remove `ops.literal` from the string code
635
- return string[1];
636
- };
637
- var peg$f72 = function(property) {
638
- const literal = annotate([ops.literal, property], location());
639
- return annotate([ops.optionalTraverse, literal], location());
586
+ var peg$f62 = function(identifier, slash) {
587
+ return identifier + (slash ?? "");
588
+ };
589
+ var peg$f63 = function(string) {
590
+ // Remove `ops.literal` from the string code
591
+ return string[1];
640
592
  };
641
- var peg$f73 = function(identifier) {
593
+ var peg$f64 = function(identifier) {
642
594
  return annotate([ops.literal, identifier], location());
643
595
  };
644
- var peg$f74 = function(list) {
596
+ var peg$f65 = function(list) {
645
597
  return annotate(list, location());
646
598
  };
647
- var peg$f75 = function(identifier) {
599
+ var peg$f66 = function(identifier) {
648
600
  return annotate(
649
601
  [annotate([ops.literal, identifier], location())],
650
602
  location()
651
603
  );
652
604
  };
653
- var peg$f76 = function(list) {
605
+ var peg$f67 = function(list) {
654
606
  return annotate(list ?? [undefined], location());
655
607
  };
656
- var peg$f77 = function(segments) {
608
+ var peg$f68 = function(segments) {
657
609
  // Drop empty segments that represent consecutive or final slashes
658
610
  segments = segments.filter(segment => segment);
659
611
  return annotate(segments, location());
660
612
  };
661
- var peg$f78 = function(path) {
613
+ var peg$f69 = function(path) {
662
614
  return annotate([ops.traverse, ...path], location());
663
615
  };
664
- var peg$f79 = function(chars, slashFollows) {
616
+ var peg$f70 = function(chars, slashFollows) {
665
617
  // Append a trailing slash if one follows (but don't consume it)
666
618
  const key = chars.join("") + (slashFollows ? "/" : "");
667
619
  return annotate([ops.literal, key], location());
668
620
  };
669
- var peg$f80 = function(head, tail) {
621
+ var peg$f71 = function(head, tail) {
670
622
  return annotate(
671
623
  tail.reduce(makePipeline, downgradeReference(head)),
672
624
  location()
673
625
  );
674
626
  };
675
- var peg$f81 = function(fn, host, path) {
627
+ var peg$f72 = function(fn, host, path) {
676
628
  const keys = annotate([host, ...(path ?? [])], location());
677
629
  return makeCall(fn, keys);
678
630
  };
679
- var peg$f82 = function(fn, reference) {
631
+ var peg$f73 = function(fn, reference) {
680
632
  const literal = annotate([ops.literal, reference[1]], reference.location);
681
633
  return makeCall(fn, [literal]);
682
634
  };
683
- var peg$f83 = function(flags) {
684
- return flags.join("");
685
- };
686
- var peg$f84 = function(chars, flags) {
687
- const regex = new RegExp(chars.join(""), flags);
688
- return annotate([ops.literal, regex], location());
689
- };
690
- var peg$f85 = function(head, tail) {
635
+ var peg$f74 = function(head, tail) {
691
636
  return tail.reduce(makeBinaryOperation, head);
692
637
  };
693
- var peg$f86 = function(key) {
638
+ var peg$f75 = function(key) {
694
639
  return annotate([ops.rootDirectory, key], location());
695
640
  };
696
- var peg$f87 = function() {
641
+ var peg$f76 = function() {
697
642
  return annotate([ops.rootDirectory], location());
698
643
  };
699
- var peg$f88 = function(identifier, slashFollows) {
644
+ var peg$f77 = function(identifier, slashFollows) {
700
645
  const id = identifier + (slashFollows ? "/" : "");
701
646
  return annotate(makeReference(id), location());
702
647
  };
703
- var peg$f89 = function() { return null; };
704
- var peg$f90 = function() { return options.mode === "shell" };
705
- var peg$f91 = function(head, tail) {
648
+ var peg$f78 = function() { return null; };
649
+ var peg$f79 = function(head, tail) {
706
650
  return tail.reduce(makeBinaryOperation, head);
707
651
  };
708
- var peg$f92 = function(definition) {
652
+ var peg$f80 = function(definition) {
709
653
  const lambdaParameters = annotate(
710
654
  [annotate([ops.literal, "_"], location())],
711
655
  location()
712
656
  );
713
657
  return annotate([ops.lambda, lambdaParameters, definition], location());
714
658
  };
715
- var peg$f93 = function() { return null; };
716
- var peg$f94 = function(chars) {
659
+ var peg$f81 = function() { return null; };
660
+ var peg$f82 = function(chars) {
717
661
  return annotate([ops.literal, chars.join("")], location());
718
662
  };
719
- var peg$f95 = function() {
663
+ var peg$f83 = function() {
720
664
  return annotate([ops.literal, "/"], location());
721
665
  };
722
- var peg$f96 = function() {
666
+ var peg$f84 = function() {
723
667
  return true;
724
668
  };
725
- var peg$f97 = function(value) {
669
+ var peg$f85 = function(value) {
726
670
  return annotate([ops.spread, value], location());
727
671
  };
728
- var peg$f98 = function(head, tail) {
672
+ var peg$f86 = function(head, tail) {
729
673
  const lambdaParameters = annotate(
730
674
  [annotate([ops.literal, "_"], location())],
731
675
  location()
@@ -735,29 +679,27 @@ function peg$parse(input, options) {
735
679
  location()
736
680
  );
737
681
  };
738
- var peg$f99 = function(chars) {
682
+ var peg$f87 = function(chars) {
739
683
  return annotate([ops.literal, chars.join("")], location());
740
684
  };
741
- var peg$f100 = function(front, body) {
742
- const macroName = options.mode === "jse" ? "_template" : "@template";
743
- return annotate(applyMacro(front, macroName, body), location());
685
+ var peg$f88 = function(front, body) {
686
+ return annotate(applyMacro(front, "@template", body), location());
744
687
  };
745
- var peg$f101 = function(front, body) {
688
+ var peg$f89 = function(front, body) {
746
689
  return front
747
690
  ? annotate([ops.document, front, body], location())
748
691
  : annotate(body, location());
749
692
  };
750
- var peg$f102 = function(head, tail) {
751
- const op = options.mode === "jse" ? ops.templateStandard : ops.templateTree;
752
- return makeTemplate(op, head, tail, location());
693
+ var peg$f90 = function(head, tail) {
694
+ return makeTemplate(ops.template, head, tail, location());
753
695
  };
754
- var peg$f103 = function(chars) {
696
+ var peg$f91 = function(chars) {
755
697
  return annotate([ops.literal, chars.join("")], location());
756
698
  };
757
- var peg$f104 = function(expression) {
699
+ var peg$f92 = function(expression) {
758
700
  return annotate(expression, location());
759
701
  };
760
- var peg$f105 = function(operator, expression) {
702
+ var peg$f93 = function(operator, expression) {
761
703
  return makeUnaryOperation(operator, expression, location());
762
704
  };
763
705
  var peg$currPos = options.peg$currPos | 0;
@@ -947,11 +889,11 @@ function peg$parse(input, options) {
947
889
  if (s1 !== peg$FAILED) {
948
890
  s2 = [];
949
891
  s3 = peg$currPos;
950
- s4 = peg$parsewhitespaceShell();
892
+ s4 = peg$parsewhitespace();
951
893
  if (s4 !== peg$FAILED) {
952
894
  s5 = peg$parseadditiveOperator();
953
895
  if (s5 !== peg$FAILED) {
954
- s6 = peg$parsewhitespaceShell();
896
+ s6 = peg$parsewhitespace();
955
897
  if (s6 !== peg$FAILED) {
956
898
  s7 = peg$parsemultiplicativeExpression();
957
899
  if (s7 !== peg$FAILED) {
@@ -975,11 +917,11 @@ function peg$parse(input, options) {
975
917
  while (s3 !== peg$FAILED) {
976
918
  s2.push(s3);
977
919
  s3 = peg$currPos;
978
- s4 = peg$parsewhitespaceShell();
920
+ s4 = peg$parsewhitespace();
979
921
  if (s4 !== peg$FAILED) {
980
922
  s5 = peg$parseadditiveOperator();
981
923
  if (s5 !== peg$FAILED) {
982
- s6 = peg$parsewhitespaceShell();
924
+ s6 = peg$parsewhitespace();
983
925
  if (s6 !== peg$FAILED) {
984
926
  s7 = peg$parsemultiplicativeExpression();
985
927
  if (s7 !== peg$FAILED) {
@@ -1025,275 +967,19 @@ function peg$parse(input, options) {
1025
967
  return s0;
1026
968
  }
1027
969
 
1028
- function peg$parseangleBracketLiteral() {
1029
- var s0, s1, s2, s3, s4, s5, s6, s7;
1030
-
1031
- s0 = peg$currPos;
1032
- if (input.charCodeAt(peg$currPos) === 60) {
1033
- s1 = peg$c0;
1034
- peg$currPos++;
1035
- } else {
1036
- s1 = peg$FAILED;
1037
- if (peg$silentFails === 0) { peg$fail(peg$e1); }
1038
- }
1039
- if (s1 !== peg$FAILED) {
1040
- s2 = peg$parse__();
1041
- s3 = peg$parseangleBracketProtocol();
1042
- if (s3 !== peg$FAILED) {
1043
- if (input.substr(peg$currPos, 2) === peg$c1) {
1044
- s4 = peg$c1;
1045
- peg$currPos += 2;
1046
- } else {
1047
- s4 = peg$FAILED;
1048
- if (peg$silentFails === 0) { peg$fail(peg$e2); }
1049
- }
1050
- if (s4 !== peg$FAILED) {
1051
- s5 = peg$parseangleBracketPath();
1052
- s6 = peg$parse__();
1053
- if (input.charCodeAt(peg$currPos) === 62) {
1054
- s7 = peg$c2;
1055
- peg$currPos++;
1056
- } else {
1057
- s7 = peg$FAILED;
1058
- if (peg$silentFails === 0) { peg$fail(peg$e3); }
1059
- }
1060
- if (s7 !== peg$FAILED) {
1061
- peg$savedPos = s0;
1062
- s0 = peg$f2(s3, s5);
1063
- } else {
1064
- peg$currPos = s0;
1065
- s0 = peg$FAILED;
1066
- }
1067
- } else {
1068
- peg$currPos = s0;
1069
- s0 = peg$FAILED;
1070
- }
1071
- } else {
1072
- peg$currPos = s0;
1073
- s0 = peg$FAILED;
1074
- }
1075
- } else {
1076
- peg$currPos = s0;
1077
- s0 = peg$FAILED;
1078
- }
1079
- if (s0 === peg$FAILED) {
1080
- s0 = peg$currPos;
1081
- if (input.charCodeAt(peg$currPos) === 60) {
1082
- s1 = peg$c0;
1083
- peg$currPos++;
1084
- } else {
1085
- s1 = peg$FAILED;
1086
- if (peg$silentFails === 0) { peg$fail(peg$e1); }
1087
- }
1088
- if (s1 !== peg$FAILED) {
1089
- s2 = peg$parseangleBracketProtocol();
1090
- if (s2 !== peg$FAILED) {
1091
- s3 = peg$parseangleBracketPath();
1092
- if (input.charCodeAt(peg$currPos) === 62) {
1093
- s4 = peg$c2;
1094
- peg$currPos++;
1095
- } else {
1096
- s4 = peg$FAILED;
1097
- if (peg$silentFails === 0) { peg$fail(peg$e3); }
1098
- }
1099
- if (s4 !== peg$FAILED) {
1100
- peg$savedPos = s0;
1101
- s0 = peg$f3(s2, s3);
1102
- } else {
1103
- peg$currPos = s0;
1104
- s0 = peg$FAILED;
1105
- }
1106
- } else {
1107
- peg$currPos = s0;
1108
- s0 = peg$FAILED;
1109
- }
1110
- } else {
1111
- peg$currPos = s0;
1112
- s0 = peg$FAILED;
1113
- }
1114
- if (s0 === peg$FAILED) {
1115
- s0 = peg$currPos;
1116
- if (input.charCodeAt(peg$currPos) === 60) {
1117
- s1 = peg$c0;
1118
- peg$currPos++;
1119
- } else {
1120
- s1 = peg$FAILED;
1121
- if (peg$silentFails === 0) { peg$fail(peg$e1); }
1122
- }
1123
- if (s1 !== peg$FAILED) {
1124
- s2 = peg$parse__();
1125
- s3 = peg$parseangleBracketPath();
1126
- s4 = peg$parse__();
1127
- if (input.charCodeAt(peg$currPos) === 62) {
1128
- s5 = peg$c2;
1129
- peg$currPos++;
1130
- } else {
1131
- s5 = peg$FAILED;
1132
- if (peg$silentFails === 0) { peg$fail(peg$e3); }
1133
- }
1134
- if (s5 !== peg$FAILED) {
1135
- peg$savedPos = s0;
1136
- s0 = peg$f4(s3);
1137
- } else {
1138
- peg$currPos = s0;
1139
- s0 = peg$FAILED;
1140
- }
1141
- } else {
1142
- peg$currPos = s0;
1143
- s0 = peg$FAILED;
1144
- }
1145
- }
1146
- }
1147
-
1148
- return s0;
1149
- }
1150
-
1151
- function peg$parseangleBracketPath() {
1152
- var s0, s1, s2, s3;
1153
-
1154
- s0 = peg$currPos;
1155
- s1 = [];
1156
- s2 = peg$parseangleBracketPathKey();
1157
- while (s2 !== peg$FAILED) {
1158
- s1.push(s2);
1159
- s2 = peg$currPos;
1160
- if (input.charCodeAt(peg$currPos) === 47) {
1161
- s3 = peg$c3;
1162
- peg$currPos++;
1163
- } else {
1164
- s3 = peg$FAILED;
1165
- if (peg$silentFails === 0) { peg$fail(peg$e4); }
1166
- }
1167
- if (s3 !== peg$FAILED) {
1168
- s3 = peg$parseangleBracketPathKey();
1169
- if (s3 === peg$FAILED) {
1170
- peg$currPos = s2;
1171
- s2 = peg$FAILED;
1172
- } else {
1173
- s2 = s3;
1174
- }
1175
- } else {
1176
- s2 = s3;
1177
- }
1178
- }
1179
- if (input.charCodeAt(peg$currPos) === 47) {
1180
- s2 = peg$c3;
1181
- peg$currPos++;
1182
- } else {
1183
- s2 = peg$FAILED;
1184
- if (peg$silentFails === 0) { peg$fail(peg$e4); }
1185
- }
1186
- if (s2 === peg$FAILED) {
1187
- s2 = null;
1188
- }
1189
- s0 = s1;
1190
-
1191
- return s0;
1192
- }
1193
-
1194
- function peg$parseangleBracketPathKey() {
1195
- var s0, s1, s2;
1196
-
1197
- s0 = peg$currPos;
1198
- s1 = [];
1199
- s2 = peg$parseangleBracketPathChar();
1200
- if (s2 !== peg$FAILED) {
1201
- while (s2 !== peg$FAILED) {
1202
- s1.push(s2);
1203
- s2 = peg$parseangleBracketPathChar();
1204
- }
1205
- } else {
1206
- s1 = peg$FAILED;
1207
- }
1208
- if (s1 !== peg$FAILED) {
1209
- s2 = peg$parseslashFollows();
1210
- if (s2 === peg$FAILED) {
1211
- s2 = null;
1212
- }
1213
- peg$savedPos = s0;
1214
- s0 = peg$f5(s1, s2);
1215
- } else {
1216
- peg$currPos = s0;
1217
- s0 = peg$FAILED;
1218
- }
1219
-
1220
- return s0;
1221
- }
1222
-
1223
- function peg$parseangleBracketPathChar() {
1224
- var s0;
1225
-
1226
- s0 = input.charAt(peg$currPos);
1227
- if (peg$r1.test(s0)) {
1228
- peg$currPos++;
1229
- } else {
1230
- s0 = peg$FAILED;
1231
- if (peg$silentFails === 0) { peg$fail(peg$e5); }
1232
- }
1233
- if (s0 === peg$FAILED) {
1234
- s0 = peg$parseescapedChar();
1235
- }
1236
-
1237
- return s0;
1238
- }
1239
-
1240
- function peg$parseangleBracketProtocol() {
1241
- var s0, s1, s2;
1242
-
1243
- s0 = peg$currPos;
1244
- s1 = peg$parsejsIdentifier();
1245
- if (s1 !== peg$FAILED) {
1246
- if (input.charCodeAt(peg$currPos) === 58) {
1247
- s2 = peg$c4;
1248
- peg$currPos++;
1249
- } else {
1250
- s2 = peg$FAILED;
1251
- if (peg$silentFails === 0) { peg$fail(peg$e6); }
1252
- }
1253
- if (s2 !== peg$FAILED) {
1254
- peg$savedPos = s0;
1255
- s0 = peg$f6(s1);
1256
- } else {
1257
- peg$currPos = s0;
1258
- s0 = peg$FAILED;
1259
- }
1260
- } else {
1261
- peg$currPos = s0;
1262
- s0 = peg$FAILED;
1263
- }
1264
-
1265
- return s0;
1266
- }
1267
-
1268
970
  function peg$parsearguments() {
1269
- var s0, s1, s2;
971
+ var s0, s1;
1270
972
 
1271
973
  peg$silentFails++;
1272
974
  s0 = peg$parseparenthesesArguments();
1273
975
  if (s0 === peg$FAILED) {
1274
- s0 = peg$currPos;
1275
- s1 = peg$parseshellMode();
1276
- if (s1 !== peg$FAILED) {
1277
- s2 = peg$parsepathArguments();
1278
- if (s2 !== peg$FAILED) {
1279
- s0 = s2;
1280
- } else {
1281
- peg$currPos = s0;
1282
- s0 = peg$FAILED;
1283
- }
1284
- } else {
1285
- peg$currPos = s0;
1286
- s0 = peg$FAILED;
1287
- }
976
+ s0 = peg$parsepathArguments();
1288
977
  if (s0 === peg$FAILED) {
1289
978
  s0 = peg$parsejsPropertyAccess();
1290
979
  if (s0 === peg$FAILED) {
1291
980
  s0 = peg$parsecomputedPropertyAccess();
1292
981
  if (s0 === peg$FAILED) {
1293
- s0 = peg$parseoptionalChaining();
1294
- if (s0 === peg$FAILED) {
1295
- s0 = peg$parsetemplateLiteral();
1296
- }
982
+ s0 = peg$parsetemplateLiteral();
1297
983
  }
1298
984
  }
1299
985
  }
@@ -1301,7 +987,7 @@ function peg$parse(input, options) {
1301
987
  peg$silentFails--;
1302
988
  if (s0 === peg$FAILED) {
1303
989
  s1 = peg$FAILED;
1304
- if (peg$silentFails === 0) { peg$fail(peg$e7); }
990
+ if (peg$silentFails === 0) { peg$fail(peg$e1); }
1305
991
  }
1306
992
 
1307
993
  return s0;
@@ -1313,11 +999,11 @@ function peg$parse(input, options) {
1313
999
  peg$silentFails++;
1314
1000
  s0 = peg$currPos;
1315
1001
  if (input.charCodeAt(peg$currPos) === 91) {
1316
- s1 = peg$c5;
1002
+ s1 = peg$c0;
1317
1003
  peg$currPos++;
1318
1004
  } else {
1319
1005
  s1 = peg$FAILED;
1320
- if (peg$silentFails === 0) { peg$fail(peg$e9); }
1006
+ if (peg$silentFails === 0) { peg$fail(peg$e3); }
1321
1007
  }
1322
1008
  if (s1 !== peg$FAILED) {
1323
1009
  s2 = peg$parse__();
@@ -1329,7 +1015,7 @@ function peg$parse(input, options) {
1329
1015
  s5 = peg$parseexpectClosingBracket();
1330
1016
  if (s5 !== peg$FAILED) {
1331
1017
  peg$savedPos = s0;
1332
- s0 = peg$f7(s3);
1018
+ s0 = peg$f2(s3);
1333
1019
  } else {
1334
1020
  peg$currPos = s0;
1335
1021
  s0 = peg$FAILED;
@@ -1341,7 +1027,7 @@ function peg$parse(input, options) {
1341
1027
  peg$silentFails--;
1342
1028
  if (s0 === peg$FAILED) {
1343
1029
  s1 = peg$FAILED;
1344
- if (peg$silentFails === 0) { peg$fail(peg$e8); }
1030
+ if (peg$silentFails === 0) { peg$fail(peg$e2); }
1345
1031
  }
1346
1032
 
1347
1033
  return s0;
@@ -1382,7 +1068,7 @@ function peg$parse(input, options) {
1382
1068
  s2 = null;
1383
1069
  }
1384
1070
  peg$savedPos = s0;
1385
- s0 = peg$f8(s1);
1071
+ s0 = peg$f3(s1);
1386
1072
  } else {
1387
1073
  peg$currPos = s0;
1388
1074
  s0 = peg$FAILED;
@@ -1403,11 +1089,11 @@ function peg$parse(input, options) {
1403
1089
  s2 = peg$currPos;
1404
1090
  peg$silentFails++;
1405
1091
  if (input.charCodeAt(peg$currPos) === 93) {
1406
- s3 = peg$c6;
1092
+ s3 = peg$c1;
1407
1093
  peg$currPos++;
1408
1094
  } else {
1409
1095
  s3 = peg$FAILED;
1410
- if (peg$silentFails === 0) { peg$fail(peg$e10); }
1096
+ if (peg$silentFails === 0) { peg$fail(peg$e4); }
1411
1097
  }
1412
1098
  peg$silentFails--;
1413
1099
  if (s3 === peg$FAILED) {
@@ -1418,7 +1104,7 @@ function peg$parse(input, options) {
1418
1104
  }
1419
1105
  if (s2 !== peg$FAILED) {
1420
1106
  peg$savedPos = s0;
1421
- s0 = peg$f9();
1107
+ s0 = peg$f4();
1422
1108
  } else {
1423
1109
  peg$currPos = s0;
1424
1110
  s0 = peg$FAILED;
@@ -1434,11 +1120,11 @@ function peg$parse(input, options) {
1434
1120
 
1435
1121
  s0 = peg$currPos;
1436
1122
  if (input.charCodeAt(peg$currPos) === 40) {
1437
- s1 = peg$c7;
1123
+ s1 = peg$c2;
1438
1124
  peg$currPos++;
1439
1125
  } else {
1440
1126
  s1 = peg$FAILED;
1441
- if (peg$silentFails === 0) { peg$fail(peg$e11); }
1127
+ if (peg$silentFails === 0) { peg$fail(peg$e5); }
1442
1128
  }
1443
1129
  if (s1 !== peg$FAILED) {
1444
1130
  s2 = peg$parse__();
@@ -1448,11 +1134,11 @@ function peg$parse(input, options) {
1448
1134
  }
1449
1135
  s4 = peg$parse__();
1450
1136
  if (input.charCodeAt(peg$currPos) === 41) {
1451
- s5 = peg$c8;
1137
+ s5 = peg$c3;
1452
1138
  peg$currPos++;
1453
1139
  } else {
1454
1140
  s5 = peg$FAILED;
1455
- if (peg$silentFails === 0) { peg$fail(peg$e12); }
1141
+ if (peg$silentFails === 0) { peg$fail(peg$e6); }
1456
1142
  }
1457
1143
  if (s5 !== peg$FAILED) {
1458
1144
  s6 = peg$parse__();
@@ -1462,7 +1148,7 @@ function peg$parse(input, options) {
1462
1148
  s9 = peg$parseexpectPipelineExpression();
1463
1149
  if (s9 !== peg$FAILED) {
1464
1150
  peg$savedPos = s0;
1465
- s0 = peg$f10(s3, s9);
1151
+ s0 = peg$f5(s3, s9);
1466
1152
  } else {
1467
1153
  peg$currPos = s0;
1468
1154
  s0 = peg$FAILED;
@@ -1490,7 +1176,7 @@ function peg$parse(input, options) {
1490
1176
  s5 = peg$parseexpectPipelineExpression();
1491
1177
  if (s5 !== peg$FAILED) {
1492
1178
  peg$savedPos = s0;
1493
- s0 = peg$f11(s1, s5);
1179
+ s0 = peg$f6(s1, s5);
1494
1180
  } else {
1495
1181
  peg$currPos = s0;
1496
1182
  s0 = peg$FAILED;
@@ -1554,7 +1240,7 @@ function peg$parse(input, options) {
1554
1240
  }
1555
1241
  }
1556
1242
  peg$savedPos = s0;
1557
- s0 = peg$f12(s1, s2);
1243
+ s0 = peg$f7(s1, s2);
1558
1244
  } else {
1559
1245
  peg$currPos = s0;
1560
1246
  s0 = peg$FAILED;
@@ -1568,21 +1254,21 @@ function peg$parse(input, options) {
1568
1254
 
1569
1255
  s0 = peg$currPos;
1570
1256
  if (input.charCodeAt(peg$currPos) === 38) {
1571
- s1 = peg$c9;
1257
+ s1 = peg$c4;
1572
1258
  peg$currPos++;
1573
1259
  } else {
1574
1260
  s1 = peg$FAILED;
1575
- if (peg$silentFails === 0) { peg$fail(peg$e13); }
1261
+ if (peg$silentFails === 0) { peg$fail(peg$e7); }
1576
1262
  }
1577
1263
  if (s1 !== peg$FAILED) {
1578
1264
  s2 = peg$currPos;
1579
1265
  peg$silentFails++;
1580
1266
  if (input.charCodeAt(peg$currPos) === 38) {
1581
- s3 = peg$c9;
1267
+ s3 = peg$c4;
1582
1268
  peg$currPos++;
1583
1269
  } else {
1584
1270
  s3 = peg$FAILED;
1585
- if (peg$silentFails === 0) { peg$fail(peg$e13); }
1271
+ if (peg$silentFails === 0) { peg$fail(peg$e7); }
1586
1272
  }
1587
1273
  peg$silentFails--;
1588
1274
  if (s3 === peg$FAILED) {
@@ -1648,7 +1334,7 @@ function peg$parse(input, options) {
1648
1334
  }
1649
1335
  }
1650
1336
  peg$savedPos = s0;
1651
- s0 = peg$f13(s1, s2);
1337
+ s0 = peg$f8(s1, s2);
1652
1338
  } else {
1653
1339
  peg$currPos = s0;
1654
1340
  s0 = peg$FAILED;
@@ -1662,21 +1348,21 @@ function peg$parse(input, options) {
1662
1348
 
1663
1349
  s0 = peg$currPos;
1664
1350
  if (input.charCodeAt(peg$currPos) === 124) {
1665
- s1 = peg$c10;
1351
+ s1 = peg$c5;
1666
1352
  peg$currPos++;
1667
1353
  } else {
1668
1354
  s1 = peg$FAILED;
1669
- if (peg$silentFails === 0) { peg$fail(peg$e14); }
1355
+ if (peg$silentFails === 0) { peg$fail(peg$e8); }
1670
1356
  }
1671
1357
  if (s1 !== peg$FAILED) {
1672
1358
  s2 = peg$currPos;
1673
1359
  peg$silentFails++;
1674
1360
  if (input.charCodeAt(peg$currPos) === 124) {
1675
- s3 = peg$c10;
1361
+ s3 = peg$c5;
1676
1362
  peg$currPos++;
1677
1363
  } else {
1678
1364
  s3 = peg$FAILED;
1679
- if (peg$silentFails === 0) { peg$fail(peg$e14); }
1365
+ if (peg$silentFails === 0) { peg$fail(peg$e8); }
1680
1366
  }
1681
1367
  peg$silentFails--;
1682
1368
  if (s3 === peg$FAILED) {
@@ -1742,7 +1428,7 @@ function peg$parse(input, options) {
1742
1428
  }
1743
1429
  }
1744
1430
  peg$savedPos = s0;
1745
- s0 = peg$f14(s1, s2);
1431
+ s0 = peg$f9(s1, s2);
1746
1432
  } else {
1747
1433
  peg$currPos = s0;
1748
1434
  s0 = peg$FAILED;
@@ -1755,11 +1441,11 @@ function peg$parse(input, options) {
1755
1441
  var s0;
1756
1442
 
1757
1443
  if (input.charCodeAt(peg$currPos) === 94) {
1758
- s0 = peg$c11;
1444
+ s0 = peg$c6;
1759
1445
  peg$currPos++;
1760
1446
  } else {
1761
1447
  s0 = peg$FAILED;
1762
- if (peg$silentFails === 0) { peg$fail(peg$e15); }
1448
+ if (peg$silentFails === 0) { peg$fail(peg$e9); }
1763
1449
  }
1764
1450
 
1765
1451
  return s0;
@@ -1779,7 +1465,7 @@ function peg$parse(input, options) {
1779
1465
  s3 = peg$parsearguments();
1780
1466
  }
1781
1467
  peg$savedPos = s0;
1782
- s0 = peg$f15(s1, s2);
1468
+ s0 = peg$f10(s1, s2);
1783
1469
  } else {
1784
1470
  peg$currPos = s0;
1785
1471
  s0 = peg$FAILED;
@@ -1787,7 +1473,7 @@ function peg$parse(input, options) {
1787
1473
  peg$silentFails--;
1788
1474
  if (s0 === peg$FAILED) {
1789
1475
  s1 = peg$FAILED;
1790
- if (peg$silentFails === 0) { peg$fail(peg$e16); }
1476
+ if (peg$silentFails === 0) { peg$fail(peg$e10); }
1791
1477
  }
1792
1478
 
1793
1479
  return s0;
@@ -1806,11 +1492,11 @@ function peg$parse(input, options) {
1806
1492
  s4 = peg$currPos;
1807
1493
  s5 = peg$parse__();
1808
1494
  if (input.charCodeAt(peg$currPos) === 44) {
1809
- s6 = peg$c12;
1495
+ s6 = peg$c7;
1810
1496
  peg$currPos++;
1811
1497
  } else {
1812
1498
  s6 = peg$FAILED;
1813
- if (peg$silentFails === 0) { peg$fail(peg$e17); }
1499
+ if (peg$silentFails === 0) { peg$fail(peg$e11); }
1814
1500
  }
1815
1501
  if (s6 !== peg$FAILED) {
1816
1502
  s7 = peg$parse__();
@@ -1840,7 +1526,7 @@ function peg$parse(input, options) {
1840
1526
  }
1841
1527
  if (s1 !== peg$FAILED) {
1842
1528
  peg$savedPos = s0;
1843
- s1 = peg$f16(s1);
1529
+ s1 = peg$f11(s1);
1844
1530
  }
1845
1531
  s0 = s1;
1846
1532
 
@@ -1858,7 +1544,7 @@ function peg$parse(input, options) {
1858
1544
  peg$silentFails--;
1859
1545
  if (s0 === peg$FAILED) {
1860
1546
  s1 = peg$FAILED;
1861
- if (peg$silentFails === 0) { peg$fail(peg$e18); }
1547
+ if (peg$silentFails === 0) { peg$fail(peg$e12); }
1862
1548
  }
1863
1549
 
1864
1550
  return s0;
@@ -1870,11 +1556,11 @@ function peg$parse(input, options) {
1870
1556
  s0 = peg$currPos;
1871
1557
  s1 = peg$parse__();
1872
1558
  if (input.charCodeAt(peg$currPos) === 91) {
1873
- s2 = peg$c5;
1559
+ s2 = peg$c0;
1874
1560
  peg$currPos++;
1875
1561
  } else {
1876
1562
  s2 = peg$FAILED;
1877
- if (peg$silentFails === 0) { peg$fail(peg$e9); }
1563
+ if (peg$silentFails === 0) { peg$fail(peg$e3); }
1878
1564
  }
1879
1565
  if (s2 !== peg$FAILED) {
1880
1566
  s3 = peg$parseexpression();
@@ -1882,7 +1568,7 @@ function peg$parse(input, options) {
1882
1568
  s4 = peg$parseexpectClosingBracket();
1883
1569
  if (s4 !== peg$FAILED) {
1884
1570
  peg$savedPos = s0;
1885
- s0 = peg$f17(s3);
1571
+ s0 = peg$f12(s3);
1886
1572
  } else {
1887
1573
  peg$currPos = s0;
1888
1574
  s0 = peg$FAILED;
@@ -1908,11 +1594,11 @@ function peg$parse(input, options) {
1908
1594
  s2 = peg$currPos;
1909
1595
  s3 = peg$parse__();
1910
1596
  if (input.charCodeAt(peg$currPos) === 63) {
1911
- s4 = peg$c13;
1597
+ s4 = peg$c8;
1912
1598
  peg$currPos++;
1913
1599
  } else {
1914
1600
  s4 = peg$FAILED;
1915
- if (peg$silentFails === 0) { peg$fail(peg$e19); }
1601
+ if (peg$silentFails === 0) { peg$fail(peg$e13); }
1916
1602
  }
1917
1603
  if (s4 !== peg$FAILED) {
1918
1604
  s5 = peg$parse__();
@@ -1920,11 +1606,11 @@ function peg$parse(input, options) {
1920
1606
  if (s6 !== peg$FAILED) {
1921
1607
  s7 = peg$parse__();
1922
1608
  if (input.charCodeAt(peg$currPos) === 58) {
1923
- s8 = peg$c4;
1609
+ s8 = peg$c9;
1924
1610
  peg$currPos++;
1925
1611
  } else {
1926
1612
  s8 = peg$FAILED;
1927
- if (peg$silentFails === 0) { peg$fail(peg$e6); }
1613
+ if (peg$silentFails === 0) { peg$fail(peg$e14); }
1928
1614
  }
1929
1615
  if (s8 !== peg$FAILED) {
1930
1616
  s9 = peg$parse__();
@@ -1951,7 +1637,7 @@ function peg$parse(input, options) {
1951
1637
  s2 = null;
1952
1638
  }
1953
1639
  peg$savedPos = s0;
1954
- s0 = peg$f18(s1, s2);
1640
+ s0 = peg$f13(s1, s2);
1955
1641
  } else {
1956
1642
  peg$currPos = s0;
1957
1643
  s0 = peg$FAILED;
@@ -1966,21 +1652,21 @@ function peg$parse(input, options) {
1966
1652
  s0 = peg$currPos;
1967
1653
  s1 = [];
1968
1654
  s2 = input.charAt(peg$currPos);
1969
- if (peg$r2.test(s2)) {
1655
+ if (peg$r1.test(s2)) {
1970
1656
  peg$currPos++;
1971
1657
  } else {
1972
1658
  s2 = peg$FAILED;
1973
- if (peg$silentFails === 0) { peg$fail(peg$e20); }
1659
+ if (peg$silentFails === 0) { peg$fail(peg$e15); }
1974
1660
  }
1975
1661
  if (s2 !== peg$FAILED) {
1976
1662
  while (s2 !== peg$FAILED) {
1977
1663
  s1.push(s2);
1978
1664
  s2 = input.charAt(peg$currPos);
1979
- if (peg$r2.test(s2)) {
1665
+ if (peg$r1.test(s2)) {
1980
1666
  peg$currPos++;
1981
1667
  } else {
1982
1668
  s2 = peg$FAILED;
1983
- if (peg$silentFails === 0) { peg$fail(peg$e20); }
1669
+ if (peg$silentFails === 0) { peg$fail(peg$e15); }
1984
1670
  }
1985
1671
  }
1986
1672
  } else {
@@ -2000,19 +1686,19 @@ function peg$parse(input, options) {
2000
1686
  var s0;
2001
1687
 
2002
1688
  if (input.charCodeAt(peg$currPos) === 8658) {
2003
- s0 = peg$c14;
1689
+ s0 = peg$c10;
2004
1690
  peg$currPos++;
2005
1691
  } else {
2006
1692
  s0 = peg$FAILED;
2007
- if (peg$silentFails === 0) { peg$fail(peg$e21); }
1693
+ if (peg$silentFails === 0) { peg$fail(peg$e16); }
2008
1694
  }
2009
1695
  if (s0 === peg$FAILED) {
2010
- if (input.substr(peg$currPos, 2) === peg$c15) {
2011
- s0 = peg$c15;
1696
+ if (input.substr(peg$currPos, 2) === peg$c11) {
1697
+ s0 = peg$c11;
2012
1698
  peg$currPos += 2;
2013
1699
  } else {
2014
1700
  s0 = peg$FAILED;
2015
- if (peg$silentFails === 0) { peg$fail(peg$e22); }
1701
+ if (peg$silentFails === 0) { peg$fail(peg$e17); }
2016
1702
  }
2017
1703
  }
2018
1704
 
@@ -2025,11 +1711,11 @@ function peg$parse(input, options) {
2025
1711
  peg$silentFails++;
2026
1712
  s0 = peg$currPos;
2027
1713
  if (input.charCodeAt(peg$currPos) === 34) {
2028
- s1 = peg$c16;
1714
+ s1 = peg$c12;
2029
1715
  peg$currPos++;
2030
1716
  } else {
2031
1717
  s1 = peg$FAILED;
2032
- if (peg$silentFails === 0) { peg$fail(peg$e24); }
1718
+ if (peg$silentFails === 0) { peg$fail(peg$e19); }
2033
1719
  }
2034
1720
  if (s1 !== peg$FAILED) {
2035
1721
  s2 = [];
@@ -2041,7 +1727,7 @@ function peg$parse(input, options) {
2041
1727
  s3 = peg$parseexpectDoubleQuote();
2042
1728
  if (s3 !== peg$FAILED) {
2043
1729
  peg$savedPos = s0;
2044
- s0 = peg$f19(s2);
1730
+ s0 = peg$f14(s2);
2045
1731
  } else {
2046
1732
  peg$currPos = s0;
2047
1733
  s0 = peg$FAILED;
@@ -2053,7 +1739,7 @@ function peg$parse(input, options) {
2053
1739
  peg$silentFails--;
2054
1740
  if (s0 === peg$FAILED) {
2055
1741
  s1 = peg$FAILED;
2056
- if (peg$silentFails === 0) { peg$fail(peg$e23); }
1742
+ if (peg$silentFails === 0) { peg$fail(peg$e18); }
2057
1743
  }
2058
1744
 
2059
1745
  return s0;
@@ -2066,11 +1752,11 @@ function peg$parse(input, options) {
2066
1752
  s1 = peg$currPos;
2067
1753
  peg$silentFails++;
2068
1754
  if (input.charCodeAt(peg$currPos) === 34) {
2069
- s2 = peg$c16;
1755
+ s2 = peg$c12;
2070
1756
  peg$currPos++;
2071
1757
  } else {
2072
1758
  s2 = peg$FAILED;
2073
- if (peg$silentFails === 0) { peg$fail(peg$e24); }
1759
+ if (peg$silentFails === 0) { peg$fail(peg$e19); }
2074
1760
  }
2075
1761
  if (s2 === peg$FAILED) {
2076
1762
  s2 = peg$parsenewLine();
@@ -2101,20 +1787,20 @@ function peg$parse(input, options) {
2101
1787
  function peg$parseellipsis() {
2102
1788
  var s0;
2103
1789
 
2104
- if (input.substr(peg$currPos, 3) === peg$c17) {
2105
- s0 = peg$c17;
1790
+ if (input.substr(peg$currPos, 3) === peg$c13) {
1791
+ s0 = peg$c13;
2106
1792
  peg$currPos += 3;
2107
1793
  } else {
2108
1794
  s0 = peg$FAILED;
2109
- if (peg$silentFails === 0) { peg$fail(peg$e25); }
1795
+ if (peg$silentFails === 0) { peg$fail(peg$e20); }
2110
1796
  }
2111
1797
  if (s0 === peg$FAILED) {
2112
1798
  if (input.charCodeAt(peg$currPos) === 8230) {
2113
- s0 = peg$c18;
1799
+ s0 = peg$c14;
2114
1800
  peg$currPos++;
2115
1801
  } else {
2116
1802
  s0 = peg$FAILED;
2117
- if (peg$silentFails === 0) { peg$fail(peg$e26); }
1803
+ if (peg$silentFails === 0) { peg$fail(peg$e21); }
2118
1804
  }
2119
1805
  }
2120
1806
 
@@ -2164,7 +1850,7 @@ function peg$parse(input, options) {
2164
1850
  }
2165
1851
  }
2166
1852
  peg$savedPos = s0;
2167
- s0 = peg$f20(s1, s2);
1853
+ s0 = peg$f15(s1, s2);
2168
1854
  } else {
2169
1855
  peg$currPos = s0;
2170
1856
  s0 = peg$FAILED;
@@ -2176,36 +1862,36 @@ function peg$parse(input, options) {
2176
1862
  function peg$parseequalityOperator() {
2177
1863
  var s0;
2178
1864
 
2179
- if (input.substr(peg$currPos, 3) === peg$c19) {
2180
- s0 = peg$c19;
1865
+ if (input.substr(peg$currPos, 3) === peg$c15) {
1866
+ s0 = peg$c15;
2181
1867
  peg$currPos += 3;
2182
1868
  } else {
2183
1869
  s0 = peg$FAILED;
2184
- if (peg$silentFails === 0) { peg$fail(peg$e27); }
1870
+ if (peg$silentFails === 0) { peg$fail(peg$e22); }
2185
1871
  }
2186
1872
  if (s0 === peg$FAILED) {
2187
- if (input.substr(peg$currPos, 3) === peg$c20) {
2188
- s0 = peg$c20;
1873
+ if (input.substr(peg$currPos, 3) === peg$c16) {
1874
+ s0 = peg$c16;
2189
1875
  peg$currPos += 3;
2190
1876
  } else {
2191
1877
  s0 = peg$FAILED;
2192
- if (peg$silentFails === 0) { peg$fail(peg$e28); }
1878
+ if (peg$silentFails === 0) { peg$fail(peg$e23); }
2193
1879
  }
2194
1880
  if (s0 === peg$FAILED) {
2195
- if (input.substr(peg$currPos, 2) === peg$c21) {
2196
- s0 = peg$c21;
1881
+ if (input.substr(peg$currPos, 2) === peg$c17) {
1882
+ s0 = peg$c17;
2197
1883
  peg$currPos += 2;
2198
1884
  } else {
2199
1885
  s0 = peg$FAILED;
2200
- if (peg$silentFails === 0) { peg$fail(peg$e29); }
1886
+ if (peg$silentFails === 0) { peg$fail(peg$e24); }
2201
1887
  }
2202
1888
  if (s0 === peg$FAILED) {
2203
- if (input.substr(peg$currPos, 2) === peg$c22) {
2204
- s0 = peg$c22;
1889
+ if (input.substr(peg$currPos, 2) === peg$c18) {
1890
+ s0 = peg$c18;
2205
1891
  peg$currPos += 2;
2206
1892
  } else {
2207
1893
  s0 = peg$FAILED;
2208
- if (peg$silentFails === 0) { peg$fail(peg$e30); }
1894
+ if (peg$silentFails === 0) { peg$fail(peg$e25); }
2209
1895
  }
2210
1896
  }
2211
1897
  }
@@ -2219,110 +1905,110 @@ function peg$parse(input, options) {
2219
1905
 
2220
1906
  peg$silentFails++;
2221
1907
  s0 = peg$currPos;
2222
- if (input.substr(peg$currPos, 2) === peg$c23) {
2223
- s1 = peg$c23;
1908
+ if (input.substr(peg$currPos, 2) === peg$c19) {
1909
+ s1 = peg$c19;
2224
1910
  peg$currPos += 2;
2225
1911
  } else {
2226
1912
  s1 = peg$FAILED;
2227
- if (peg$silentFails === 0) { peg$fail(peg$e32); }
1913
+ if (peg$silentFails === 0) { peg$fail(peg$e27); }
2228
1914
  }
2229
1915
  if (s1 !== peg$FAILED) {
2230
1916
  peg$savedPos = s0;
2231
- s1 = peg$f21();
1917
+ s1 = peg$f16();
2232
1918
  }
2233
1919
  s0 = s1;
2234
1920
  if (s0 === peg$FAILED) {
2235
1921
  s0 = peg$currPos;
2236
- if (input.substr(peg$currPos, 2) === peg$c24) {
2237
- s1 = peg$c24;
1922
+ if (input.substr(peg$currPos, 2) === peg$c20) {
1923
+ s1 = peg$c20;
2238
1924
  peg$currPos += 2;
2239
1925
  } else {
2240
1926
  s1 = peg$FAILED;
2241
- if (peg$silentFails === 0) { peg$fail(peg$e33); }
1927
+ if (peg$silentFails === 0) { peg$fail(peg$e28); }
2242
1928
  }
2243
1929
  if (s1 !== peg$FAILED) {
2244
1930
  peg$savedPos = s0;
2245
- s1 = peg$f22();
1931
+ s1 = peg$f17();
2246
1932
  }
2247
1933
  s0 = s1;
2248
1934
  if (s0 === peg$FAILED) {
2249
1935
  s0 = peg$currPos;
2250
- if (input.substr(peg$currPos, 2) === peg$c25) {
2251
- s1 = peg$c25;
1936
+ if (input.substr(peg$currPos, 2) === peg$c21) {
1937
+ s1 = peg$c21;
2252
1938
  peg$currPos += 2;
2253
1939
  } else {
2254
1940
  s1 = peg$FAILED;
2255
- if (peg$silentFails === 0) { peg$fail(peg$e34); }
1941
+ if (peg$silentFails === 0) { peg$fail(peg$e29); }
2256
1942
  }
2257
1943
  if (s1 !== peg$FAILED) {
2258
1944
  peg$savedPos = s0;
2259
- s1 = peg$f23();
1945
+ s1 = peg$f18();
2260
1946
  }
2261
1947
  s0 = s1;
2262
1948
  if (s0 === peg$FAILED) {
2263
1949
  s0 = peg$currPos;
2264
- if (input.substr(peg$currPos, 2) === peg$c26) {
2265
- s1 = peg$c26;
1950
+ if (input.substr(peg$currPos, 2) === peg$c22) {
1951
+ s1 = peg$c22;
2266
1952
  peg$currPos += 2;
2267
1953
  } else {
2268
1954
  s1 = peg$FAILED;
2269
- if (peg$silentFails === 0) { peg$fail(peg$e35); }
1955
+ if (peg$silentFails === 0) { peg$fail(peg$e30); }
2270
1956
  }
2271
1957
  if (s1 !== peg$FAILED) {
2272
1958
  peg$savedPos = s0;
2273
- s1 = peg$f24();
1959
+ s1 = peg$f19();
2274
1960
  }
2275
1961
  s0 = s1;
2276
1962
  if (s0 === peg$FAILED) {
2277
1963
  s0 = peg$currPos;
2278
- if (input.substr(peg$currPos, 2) === peg$c27) {
2279
- s1 = peg$c27;
1964
+ if (input.substr(peg$currPos, 2) === peg$c23) {
1965
+ s1 = peg$c23;
2280
1966
  peg$currPos += 2;
2281
1967
  } else {
2282
1968
  s1 = peg$FAILED;
2283
- if (peg$silentFails === 0) { peg$fail(peg$e36); }
1969
+ if (peg$silentFails === 0) { peg$fail(peg$e31); }
2284
1970
  }
2285
1971
  if (s1 !== peg$FAILED) {
2286
1972
  peg$savedPos = s0;
2287
- s1 = peg$f25();
1973
+ s1 = peg$f20();
2288
1974
  }
2289
1975
  s0 = s1;
2290
1976
  if (s0 === peg$FAILED) {
2291
1977
  s0 = peg$currPos;
2292
- if (input.substr(peg$currPos, 2) === peg$c28) {
2293
- s1 = peg$c28;
1978
+ if (input.substr(peg$currPos, 2) === peg$c24) {
1979
+ s1 = peg$c24;
2294
1980
  peg$currPos += 2;
2295
1981
  } else {
2296
1982
  s1 = peg$FAILED;
2297
- if (peg$silentFails === 0) { peg$fail(peg$e37); }
1983
+ if (peg$silentFails === 0) { peg$fail(peg$e32); }
2298
1984
  }
2299
1985
  if (s1 !== peg$FAILED) {
2300
1986
  peg$savedPos = s0;
2301
- s1 = peg$f26();
1987
+ s1 = peg$f21();
2302
1988
  }
2303
1989
  s0 = s1;
2304
1990
  if (s0 === peg$FAILED) {
2305
1991
  s0 = peg$currPos;
2306
- if (input.substr(peg$currPos, 2) === peg$c29) {
2307
- s1 = peg$c29;
1992
+ if (input.substr(peg$currPos, 2) === peg$c25) {
1993
+ s1 = peg$c25;
2308
1994
  peg$currPos += 2;
2309
1995
  } else {
2310
1996
  s1 = peg$FAILED;
2311
- if (peg$silentFails === 0) { peg$fail(peg$e38); }
1997
+ if (peg$silentFails === 0) { peg$fail(peg$e33); }
2312
1998
  }
2313
1999
  if (s1 !== peg$FAILED) {
2314
2000
  peg$savedPos = s0;
2315
- s1 = peg$f27();
2001
+ s1 = peg$f22();
2316
2002
  }
2317
2003
  s0 = s1;
2318
2004
  if (s0 === peg$FAILED) {
2319
2005
  s0 = peg$currPos;
2320
2006
  if (input.charCodeAt(peg$currPos) === 92) {
2321
- s1 = peg$c30;
2007
+ s1 = peg$c26;
2322
2008
  peg$currPos++;
2323
2009
  } else {
2324
2010
  s1 = peg$FAILED;
2325
- if (peg$silentFails === 0) { peg$fail(peg$e39); }
2011
+ if (peg$silentFails === 0) { peg$fail(peg$e34); }
2326
2012
  }
2327
2013
  if (s1 !== peg$FAILED) {
2328
2014
  if (input.length > peg$currPos) {
@@ -2330,7 +2016,7 @@ function peg$parse(input, options) {
2330
2016
  peg$currPos++;
2331
2017
  } else {
2332
2018
  s2 = peg$FAILED;
2333
- if (peg$silentFails === 0) { peg$fail(peg$e40); }
2019
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
2334
2020
  }
2335
2021
  if (s2 !== peg$FAILED) {
2336
2022
  s0 = s2;
@@ -2352,7 +2038,7 @@ function peg$parse(input, options) {
2352
2038
  peg$silentFails--;
2353
2039
  if (s0 === peg$FAILED) {
2354
2040
  s1 = peg$FAILED;
2355
- if (peg$silentFails === 0) { peg$fail(peg$e31); }
2041
+ if (peg$silentFails === 0) { peg$fail(peg$e26); }
2356
2042
  }
2357
2043
 
2358
2044
  return s0;
@@ -2362,11 +2048,11 @@ function peg$parse(input, options) {
2362
2048
  var s0, s1;
2363
2049
 
2364
2050
  if (input.charCodeAt(peg$currPos) === 96) {
2365
- s0 = peg$c31;
2051
+ s0 = peg$c27;
2366
2052
  peg$currPos++;
2367
2053
  } else {
2368
2054
  s0 = peg$FAILED;
2369
- if (peg$silentFails === 0) { peg$fail(peg$e41); }
2055
+ if (peg$silentFails === 0) { peg$fail(peg$e36); }
2370
2056
  }
2371
2057
  if (s0 === peg$FAILED) {
2372
2058
  s0 = peg$currPos;
@@ -2375,13 +2061,13 @@ function peg$parse(input, options) {
2375
2061
  peg$currPos++;
2376
2062
  } else {
2377
2063
  s1 = peg$FAILED;
2378
- if (peg$silentFails === 0) { peg$fail(peg$e40); }
2064
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
2379
2065
  }
2380
2066
  if (s1 === peg$FAILED) {
2381
2067
  s1 = null;
2382
2068
  }
2383
2069
  peg$savedPos = s0;
2384
- s1 = peg$f28();
2070
+ s1 = peg$f23();
2385
2071
  s0 = s1;
2386
2072
  }
2387
2073
 
@@ -2392,11 +2078,11 @@ function peg$parse(input, options) {
2392
2078
  var s0, s1;
2393
2079
 
2394
2080
  if (input.charCodeAt(peg$currPos) === 125) {
2395
- s0 = peg$c32;
2081
+ s0 = peg$c28;
2396
2082
  peg$currPos++;
2397
2083
  } else {
2398
2084
  s0 = peg$FAILED;
2399
- if (peg$silentFails === 0) { peg$fail(peg$e42); }
2085
+ if (peg$silentFails === 0) { peg$fail(peg$e37); }
2400
2086
  }
2401
2087
  if (s0 === peg$FAILED) {
2402
2088
  s0 = peg$currPos;
@@ -2405,13 +2091,13 @@ function peg$parse(input, options) {
2405
2091
  peg$currPos++;
2406
2092
  } else {
2407
2093
  s1 = peg$FAILED;
2408
- if (peg$silentFails === 0) { peg$fail(peg$e40); }
2094
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
2409
2095
  }
2410
2096
  if (s1 === peg$FAILED) {
2411
2097
  s1 = null;
2412
2098
  }
2413
2099
  peg$savedPos = s0;
2414
- s1 = peg$f29();
2100
+ s1 = peg$f24();
2415
2101
  s0 = s1;
2416
2102
  }
2417
2103
 
@@ -2422,11 +2108,11 @@ function peg$parse(input, options) {
2422
2108
  var s0, s1;
2423
2109
 
2424
2110
  if (input.charCodeAt(peg$currPos) === 93) {
2425
- s0 = peg$c6;
2111
+ s0 = peg$c1;
2426
2112
  peg$currPos++;
2427
2113
  } else {
2428
2114
  s0 = peg$FAILED;
2429
- if (peg$silentFails === 0) { peg$fail(peg$e10); }
2115
+ if (peg$silentFails === 0) { peg$fail(peg$e4); }
2430
2116
  }
2431
2117
  if (s0 === peg$FAILED) {
2432
2118
  s0 = peg$currPos;
@@ -2435,13 +2121,13 @@ function peg$parse(input, options) {
2435
2121
  peg$currPos++;
2436
2122
  } else {
2437
2123
  s1 = peg$FAILED;
2438
- if (peg$silentFails === 0) { peg$fail(peg$e40); }
2124
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
2439
2125
  }
2440
2126
  if (s1 === peg$FAILED) {
2441
2127
  s1 = null;
2442
2128
  }
2443
2129
  peg$savedPos = s0;
2444
- s1 = peg$f30();
2130
+ s1 = peg$f25();
2445
2131
  s0 = s1;
2446
2132
  }
2447
2133
 
@@ -2452,11 +2138,11 @@ function peg$parse(input, options) {
2452
2138
  var s0, s1;
2453
2139
 
2454
2140
  if (input.charCodeAt(peg$currPos) === 41) {
2455
- s0 = peg$c8;
2141
+ s0 = peg$c3;
2456
2142
  peg$currPos++;
2457
2143
  } else {
2458
2144
  s0 = peg$FAILED;
2459
- if (peg$silentFails === 0) { peg$fail(peg$e12); }
2145
+ if (peg$silentFails === 0) { peg$fail(peg$e6); }
2460
2146
  }
2461
2147
  if (s0 === peg$FAILED) {
2462
2148
  s0 = peg$currPos;
@@ -2465,13 +2151,13 @@ function peg$parse(input, options) {
2465
2151
  peg$currPos++;
2466
2152
  } else {
2467
2153
  s1 = peg$FAILED;
2468
- if (peg$silentFails === 0) { peg$fail(peg$e40); }
2154
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
2469
2155
  }
2470
2156
  if (s1 === peg$FAILED) {
2471
2157
  s1 = null;
2472
2158
  }
2473
2159
  peg$savedPos = s0;
2474
- s1 = peg$f31();
2160
+ s1 = peg$f26();
2475
2161
  s0 = s1;
2476
2162
  }
2477
2163
 
@@ -2482,11 +2168,11 @@ function peg$parse(input, options) {
2482
2168
  var s0, s1;
2483
2169
 
2484
2170
  if (input.charCodeAt(peg$currPos) === 34) {
2485
- s0 = peg$c16;
2171
+ s0 = peg$c12;
2486
2172
  peg$currPos++;
2487
2173
  } else {
2488
2174
  s0 = peg$FAILED;
2489
- if (peg$silentFails === 0) { peg$fail(peg$e24); }
2175
+ if (peg$silentFails === 0) { peg$fail(peg$e19); }
2490
2176
  }
2491
2177
  if (s0 === peg$FAILED) {
2492
2178
  s0 = peg$currPos;
@@ -2495,13 +2181,13 @@ function peg$parse(input, options) {
2495
2181
  peg$currPos++;
2496
2182
  } else {
2497
2183
  s1 = peg$FAILED;
2498
- if (peg$silentFails === 0) { peg$fail(peg$e40); }
2184
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
2499
2185
  }
2500
2186
  if (s1 === peg$FAILED) {
2501
2187
  s1 = null;
2502
2188
  }
2503
2189
  peg$savedPos = s0;
2504
- s1 = peg$f32();
2190
+ s1 = peg$f27();
2505
2191
  s0 = s1;
2506
2192
  }
2507
2193
 
@@ -2519,13 +2205,13 @@ function peg$parse(input, options) {
2519
2205
  peg$currPos++;
2520
2206
  } else {
2521
2207
  s1 = peg$FAILED;
2522
- if (peg$silentFails === 0) { peg$fail(peg$e40); }
2208
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
2523
2209
  }
2524
2210
  if (s1 === peg$FAILED) {
2525
2211
  s1 = null;
2526
2212
  }
2527
2213
  peg$savedPos = s0;
2528
- s1 = peg$f33();
2214
+ s1 = peg$f28();
2529
2215
  s0 = s1;
2530
2216
  }
2531
2217
 
@@ -2543,13 +2229,13 @@ function peg$parse(input, options) {
2543
2229
  peg$currPos++;
2544
2230
  } else {
2545
2231
  s1 = peg$FAILED;
2546
- if (peg$silentFails === 0) { peg$fail(peg$e40); }
2232
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
2547
2233
  }
2548
2234
  if (s1 === peg$FAILED) {
2549
2235
  s1 = null;
2550
2236
  }
2551
2237
  peg$savedPos = s0;
2552
- s1 = peg$f34();
2238
+ s1 = peg$f29();
2553
2239
  s0 = s1;
2554
2240
  }
2555
2241
 
@@ -2560,11 +2246,11 @@ function peg$parse(input, options) {
2560
2246
  var s0, s1;
2561
2247
 
2562
2248
  if (input.charCodeAt(peg$currPos) === 187) {
2563
- s0 = peg$c33;
2249
+ s0 = peg$c29;
2564
2250
  peg$currPos++;
2565
2251
  } else {
2566
2252
  s0 = peg$FAILED;
2567
- if (peg$silentFails === 0) { peg$fail(peg$e43); }
2253
+ if (peg$silentFails === 0) { peg$fail(peg$e38); }
2568
2254
  }
2569
2255
  if (s0 === peg$FAILED) {
2570
2256
  s0 = peg$currPos;
@@ -2573,13 +2259,13 @@ function peg$parse(input, options) {
2573
2259
  peg$currPos++;
2574
2260
  } else {
2575
2261
  s1 = peg$FAILED;
2576
- if (peg$silentFails === 0) { peg$fail(peg$e40); }
2262
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
2577
2263
  }
2578
2264
  if (s1 === peg$FAILED) {
2579
2265
  s1 = null;
2580
2266
  }
2581
2267
  peg$savedPos = s0;
2582
- s1 = peg$f35();
2268
+ s1 = peg$f30();
2583
2269
  s0 = s1;
2584
2270
  }
2585
2271
 
@@ -2590,11 +2276,11 @@ function peg$parse(input, options) {
2590
2276
  var s0, s1;
2591
2277
 
2592
2278
  if (input.charCodeAt(peg$currPos) === 39) {
2593
- s0 = peg$c34;
2279
+ s0 = peg$c30;
2594
2280
  peg$currPos++;
2595
2281
  } else {
2596
2282
  s0 = peg$FAILED;
2597
- if (peg$silentFails === 0) { peg$fail(peg$e44); }
2283
+ if (peg$silentFails === 0) { peg$fail(peg$e39); }
2598
2284
  }
2599
2285
  if (s0 === peg$FAILED) {
2600
2286
  s0 = peg$currPos;
@@ -2603,13 +2289,13 @@ function peg$parse(input, options) {
2603
2289
  peg$currPos++;
2604
2290
  } else {
2605
2291
  s1 = peg$FAILED;
2606
- if (peg$silentFails === 0) { peg$fail(peg$e40); }
2292
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
2607
2293
  }
2608
2294
  if (s1 === peg$FAILED) {
2609
2295
  s1 = null;
2610
2296
  }
2611
2297
  peg$savedPos = s0;
2612
- s1 = peg$f36();
2298
+ s1 = peg$f31();
2613
2299
  s0 = s1;
2614
2300
  }
2615
2301
 
@@ -2627,13 +2313,13 @@ function peg$parse(input, options) {
2627
2313
  peg$currPos++;
2628
2314
  } else {
2629
2315
  s1 = peg$FAILED;
2630
- if (peg$silentFails === 0) { peg$fail(peg$e40); }
2316
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
2631
2317
  }
2632
2318
  if (s1 === peg$FAILED) {
2633
2319
  s1 = null;
2634
2320
  }
2635
2321
  peg$savedPos = s0;
2636
- s1 = peg$f37();
2322
+ s1 = peg$f32();
2637
2323
  s0 = s1;
2638
2324
  }
2639
2325
 
@@ -2648,12 +2334,12 @@ function peg$parse(input, options) {
2648
2334
  if (s1 !== peg$FAILED) {
2649
2335
  s2 = peg$currPos;
2650
2336
  s3 = peg$parse__();
2651
- if (input.substr(peg$currPos, 2) === peg$c35) {
2652
- s4 = peg$c35;
2337
+ if (input.substr(peg$currPos, 2) === peg$c31) {
2338
+ s4 = peg$c31;
2653
2339
  peg$currPos += 2;
2654
2340
  } else {
2655
2341
  s4 = peg$FAILED;
2656
- if (peg$silentFails === 0) { peg$fail(peg$e45); }
2342
+ if (peg$silentFails === 0) { peg$fail(peg$e40); }
2657
2343
  }
2658
2344
  if (s4 !== peg$FAILED) {
2659
2345
  s5 = peg$parse__();
@@ -2672,7 +2358,7 @@ function peg$parse(input, options) {
2672
2358
  s2 = null;
2673
2359
  }
2674
2360
  peg$savedPos = s0;
2675
- s0 = peg$f38(s1, s2);
2361
+ s0 = peg$f33(s1, s2);
2676
2362
  } else {
2677
2363
  peg$currPos = s0;
2678
2364
  s0 = peg$FAILED;
@@ -2708,17 +2394,17 @@ function peg$parse(input, options) {
2708
2394
  s1 = null;
2709
2395
  }
2710
2396
  if (input.charCodeAt(peg$currPos) === 46) {
2711
- s2 = peg$c36;
2397
+ s2 = peg$c32;
2712
2398
  peg$currPos++;
2713
2399
  } else {
2714
2400
  s2 = peg$FAILED;
2715
- if (peg$silentFails === 0) { peg$fail(peg$e47); }
2401
+ if (peg$silentFails === 0) { peg$fail(peg$e42); }
2716
2402
  }
2717
2403
  if (s2 !== peg$FAILED) {
2718
2404
  s3 = peg$parsedigits();
2719
2405
  if (s3 !== peg$FAILED) {
2720
2406
  peg$savedPos = s0;
2721
- s0 = peg$f39();
2407
+ s0 = peg$f34();
2722
2408
  } else {
2723
2409
  peg$currPos = s0;
2724
2410
  s0 = peg$FAILED;
@@ -2730,7 +2416,7 @@ function peg$parse(input, options) {
2730
2416
  peg$silentFails--;
2731
2417
  if (s0 === peg$FAILED) {
2732
2418
  s1 = peg$FAILED;
2733
- if (peg$silentFails === 0) { peg$fail(peg$e46); }
2419
+ if (peg$silentFails === 0) { peg$fail(peg$e41); }
2734
2420
  }
2735
2421
 
2736
2422
  return s0;
@@ -2739,12 +2425,12 @@ function peg$parse(input, options) {
2739
2425
  function peg$parsefrontDelimiter() {
2740
2426
  var s0;
2741
2427
 
2742
- if (input.substr(peg$currPos, 4) === peg$c37) {
2743
- s0 = peg$c37;
2428
+ if (input.substr(peg$currPos, 4) === peg$c33) {
2429
+ s0 = peg$c33;
2744
2430
  peg$currPos += 4;
2745
2431
  } else {
2746
2432
  s0 = peg$FAILED;
2747
- if (peg$silentFails === 0) { peg$fail(peg$e48); }
2433
+ if (peg$silentFails === 0) { peg$fail(peg$e43); }
2748
2434
  }
2749
2435
 
2750
2436
  return s0;
@@ -2757,7 +2443,7 @@ function peg$parse(input, options) {
2757
2443
  s1 = peg$parsefrontDelimiter();
2758
2444
  if (s1 !== peg$FAILED) {
2759
2445
  peg$savedPos = peg$currPos;
2760
- s2 = peg$f40();
2446
+ s2 = peg$f35();
2761
2447
  if (s2) {
2762
2448
  s2 = undefined;
2763
2449
  } else {
@@ -2811,7 +2497,7 @@ function peg$parse(input, options) {
2811
2497
  peg$currPos++;
2812
2498
  } else {
2813
2499
  s4 = peg$FAILED;
2814
- if (peg$silentFails === 0) { peg$fail(peg$e40); }
2500
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
2815
2501
  }
2816
2502
  if (s4 !== peg$FAILED) {
2817
2503
  s2 = s4;
@@ -2842,7 +2528,7 @@ function peg$parse(input, options) {
2842
2528
  peg$currPos++;
2843
2529
  } else {
2844
2530
  s4 = peg$FAILED;
2845
- if (peg$silentFails === 0) { peg$fail(peg$e40); }
2531
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
2846
2532
  }
2847
2533
  if (s4 !== peg$FAILED) {
2848
2534
  s2 = s4;
@@ -2856,7 +2542,7 @@ function peg$parse(input, options) {
2856
2542
  }
2857
2543
  }
2858
2544
  peg$savedPos = s0;
2859
- s1 = peg$f41(s1);
2545
+ s1 = peg$f36(s1);
2860
2546
  s0 = s1;
2861
2547
 
2862
2548
  return s0;
@@ -2873,7 +2559,7 @@ function peg$parse(input, options) {
2873
2559
  s3 = peg$parsefrontDelimiter();
2874
2560
  if (s3 !== peg$FAILED) {
2875
2561
  peg$savedPos = s0;
2876
- s0 = peg$f42(s2);
2562
+ s0 = peg$f37(s2);
2877
2563
  } else {
2878
2564
  peg$currPos = s0;
2879
2565
  s0 = peg$FAILED;
@@ -2885,7 +2571,7 @@ function peg$parse(input, options) {
2885
2571
  peg$silentFails--;
2886
2572
  if (s0 === peg$FAILED) {
2887
2573
  s1 = peg$FAILED;
2888
- if (peg$silentFails === 0) { peg$fail(peg$e49); }
2574
+ if (peg$silentFails === 0) { peg$fail(peg$e44); }
2889
2575
  }
2890
2576
 
2891
2577
  return s0;
@@ -2897,11 +2583,11 @@ function peg$parse(input, options) {
2897
2583
  peg$silentFails++;
2898
2584
  s0 = peg$currPos;
2899
2585
  if (input.charCodeAt(peg$currPos) === 40) {
2900
- s1 = peg$c7;
2586
+ s1 = peg$c2;
2901
2587
  peg$currPos++;
2902
2588
  } else {
2903
2589
  s1 = peg$FAILED;
2904
- if (peg$silentFails === 0) { peg$fail(peg$e11); }
2590
+ if (peg$silentFails === 0) { peg$fail(peg$e5); }
2905
2591
  }
2906
2592
  if (s1 !== peg$FAILED) {
2907
2593
  s2 = peg$parseexpression();
@@ -2909,7 +2595,7 @@ function peg$parse(input, options) {
2909
2595
  s3 = peg$parseexpectClosingParenthesis();
2910
2596
  if (s3 !== peg$FAILED) {
2911
2597
  peg$savedPos = s0;
2912
- s0 = peg$f43(s2);
2598
+ s0 = peg$f38(s2);
2913
2599
  } else {
2914
2600
  peg$currPos = s0;
2915
2601
  s0 = peg$FAILED;
@@ -2925,7 +2611,7 @@ function peg$parse(input, options) {
2925
2611
  peg$silentFails--;
2926
2612
  if (s0 === peg$FAILED) {
2927
2613
  s1 = peg$FAILED;
2928
- if (peg$silentFails === 0) { peg$fail(peg$e50); }
2614
+ if (peg$silentFails === 0) { peg$fail(peg$e45); }
2929
2615
  }
2930
2616
 
2931
2617
  return s0;
@@ -2937,11 +2623,11 @@ function peg$parse(input, options) {
2937
2623
  peg$silentFails++;
2938
2624
  s0 = peg$currPos;
2939
2625
  if (input.charCodeAt(peg$currPos) === 171) {
2940
- s1 = peg$c38;
2626
+ s1 = peg$c34;
2941
2627
  peg$currPos++;
2942
2628
  } else {
2943
2629
  s1 = peg$FAILED;
2944
- if (peg$silentFails === 0) { peg$fail(peg$e52); }
2630
+ if (peg$silentFails === 0) { peg$fail(peg$e47); }
2945
2631
  }
2946
2632
  if (s1 !== peg$FAILED) {
2947
2633
  s2 = [];
@@ -2953,7 +2639,7 @@ function peg$parse(input, options) {
2953
2639
  s3 = peg$parseexpectGuillemet();
2954
2640
  if (s3 !== peg$FAILED) {
2955
2641
  peg$savedPos = s0;
2956
- s0 = peg$f44(s2);
2642
+ s0 = peg$f39(s2);
2957
2643
  } else {
2958
2644
  peg$currPos = s0;
2959
2645
  s0 = peg$FAILED;
@@ -2965,7 +2651,7 @@ function peg$parse(input, options) {
2965
2651
  peg$silentFails--;
2966
2652
  if (s0 === peg$FAILED) {
2967
2653
  s1 = peg$FAILED;
2968
- if (peg$silentFails === 0) { peg$fail(peg$e51); }
2654
+ if (peg$silentFails === 0) { peg$fail(peg$e46); }
2969
2655
  }
2970
2656
 
2971
2657
  return s0;
@@ -2978,11 +2664,11 @@ function peg$parse(input, options) {
2978
2664
  s1 = peg$currPos;
2979
2665
  peg$silentFails++;
2980
2666
  if (input.charCodeAt(peg$currPos) === 187) {
2981
- s2 = peg$c33;
2667
+ s2 = peg$c29;
2982
2668
  peg$currPos++;
2983
2669
  } else {
2984
2670
  s2 = peg$FAILED;
2985
- if (peg$silentFails === 0) { peg$fail(peg$e43); }
2671
+ if (peg$silentFails === 0) { peg$fail(peg$e38); }
2986
2672
  }
2987
2673
  if (s2 === peg$FAILED) {
2988
2674
  s2 = peg$parsenewLine();
@@ -3015,15 +2701,15 @@ function peg$parse(input, options) {
3015
2701
 
3016
2702
  s0 = peg$currPos;
3017
2703
  if (input.charCodeAt(peg$currPos) === 126) {
3018
- s1 = peg$c39;
2704
+ s1 = peg$c35;
3019
2705
  peg$currPos++;
3020
2706
  } else {
3021
2707
  s1 = peg$FAILED;
3022
- if (peg$silentFails === 0) { peg$fail(peg$e53); }
2708
+ if (peg$silentFails === 0) { peg$fail(peg$e48); }
3023
2709
  }
3024
2710
  if (s1 !== peg$FAILED) {
3025
2711
  peg$savedPos = s0;
3026
- s1 = peg$f45();
2712
+ s1 = peg$f40();
3027
2713
  }
3028
2714
  s0 = s1;
3029
2715
 
@@ -3039,11 +2725,11 @@ function peg$parse(input, options) {
3039
2725
  if (s1 !== peg$FAILED) {
3040
2726
  s2 = peg$currPos;
3041
2727
  if (input.charCodeAt(peg$currPos) === 58) {
3042
- s3 = peg$c4;
2728
+ s3 = peg$c9;
3043
2729
  peg$currPos++;
3044
2730
  } else {
3045
2731
  s3 = peg$FAILED;
3046
- if (peg$silentFails === 0) { peg$fail(peg$e6); }
2732
+ if (peg$silentFails === 0) { peg$fail(peg$e14); }
3047
2733
  }
3048
2734
  if (s3 !== peg$FAILED) {
3049
2735
  s4 = peg$parseintegerLiteral();
@@ -3065,7 +2751,7 @@ function peg$parse(input, options) {
3065
2751
  s3 = null;
3066
2752
  }
3067
2753
  peg$savedPos = s0;
3068
- s0 = peg$f46(s1, s2, s3);
2754
+ s0 = peg$f41(s1, s2, s3);
3069
2755
  } else {
3070
2756
  peg$currPos = s0;
3071
2757
  s0 = peg$FAILED;
@@ -3073,7 +2759,7 @@ function peg$parse(input, options) {
3073
2759
  peg$silentFails--;
3074
2760
  if (s0 === peg$FAILED) {
3075
2761
  s1 = peg$FAILED;
3076
- if (peg$silentFails === 0) { peg$fail(peg$e54); }
2762
+ if (peg$silentFails === 0) { peg$fail(peg$e49); }
3077
2763
  }
3078
2764
 
3079
2765
  return s0;
@@ -3096,13 +2782,13 @@ function peg$parse(input, options) {
3096
2782
  }
3097
2783
  if (s1 !== peg$FAILED) {
3098
2784
  peg$savedPos = s0;
3099
- s1 = peg$f47(s1);
2785
+ s1 = peg$f42(s1);
3100
2786
  }
3101
2787
  s0 = s1;
3102
2788
  peg$silentFails--;
3103
2789
  if (s0 === peg$FAILED) {
3104
2790
  s1 = peg$FAILED;
3105
- if (peg$silentFails === 0) { peg$fail(peg$e55); }
2791
+ if (peg$silentFails === 0) { peg$fail(peg$e50); }
3106
2792
  }
3107
2793
 
3108
2794
  return s0;
@@ -3112,30 +2798,30 @@ function peg$parse(input, options) {
3112
2798
  var s0, s1, s2, s3;
3113
2799
 
3114
2800
  s0 = input.charAt(peg$currPos);
3115
- if (peg$r3.test(s0)) {
2801
+ if (peg$r2.test(s0)) {
3116
2802
  peg$currPos++;
3117
2803
  } else {
3118
2804
  s0 = peg$FAILED;
3119
- if (peg$silentFails === 0) { peg$fail(peg$e56); }
2805
+ if (peg$silentFails === 0) { peg$fail(peg$e51); }
3120
2806
  }
3121
2807
  if (s0 === peg$FAILED) {
3122
2808
  s0 = peg$currPos;
3123
2809
  if (input.charCodeAt(peg$currPos) === 45) {
3124
- s1 = peg$c40;
2810
+ s1 = peg$c36;
3125
2811
  peg$currPos++;
3126
2812
  } else {
3127
2813
  s1 = peg$FAILED;
3128
- if (peg$silentFails === 0) { peg$fail(peg$e57); }
2814
+ if (peg$silentFails === 0) { peg$fail(peg$e52); }
3129
2815
  }
3130
2816
  if (s1 !== peg$FAILED) {
3131
2817
  s2 = peg$currPos;
3132
2818
  peg$silentFails++;
3133
2819
  if (input.charCodeAt(peg$currPos) === 62) {
3134
- s3 = peg$c2;
2820
+ s3 = peg$c37;
3135
2821
  peg$currPos++;
3136
2822
  } else {
3137
2823
  s3 = peg$FAILED;
3138
- if (peg$silentFails === 0) { peg$fail(peg$e3); }
2824
+ if (peg$silentFails === 0) { peg$fail(peg$e53); }
3139
2825
  }
3140
2826
  peg$silentFails--;
3141
2827
  if (s3 === peg$FAILED) {
@@ -3196,7 +2882,7 @@ function peg$parse(input, options) {
3196
2882
  s2 = null;
3197
2883
  }
3198
2884
  peg$savedPos = s0;
3199
- s0 = peg$f48(s1, s2);
2885
+ s0 = peg$f43(s1, s2);
3200
2886
  } else {
3201
2887
  peg$currPos = s0;
3202
2888
  s0 = peg$FAILED;
@@ -3204,54 +2890,48 @@ function peg$parse(input, options) {
3204
2890
  peg$silentFails--;
3205
2891
  if (s0 === peg$FAILED) {
3206
2892
  s1 = peg$FAILED;
3207
- if (peg$silentFails === 0) { peg$fail(peg$e58); }
2893
+ if (peg$silentFails === 0) { peg$fail(peg$e54); }
3208
2894
  }
3209
2895
 
3210
2896
  return s0;
3211
2897
  }
3212
2898
 
3213
2899
  function peg$parseimplicitParensthesesArguments() {
3214
- var s0, s1, s2, s3, s4, s5;
2900
+ var s0, s1, s2, s3, s4;
3215
2901
 
3216
2902
  s0 = peg$currPos;
3217
- s1 = peg$parseshellMode();
3218
- if (s1 !== peg$FAILED) {
3219
- s2 = peg$currPos;
3220
- s3 = [];
3221
- s4 = peg$parseshorthandFunction();
3222
- while (s4 !== peg$FAILED) {
3223
- s3.push(s4);
3224
- s4 = peg$currPos;
3225
- s5 = peg$parseseparator();
3226
- if (s5 !== peg$FAILED) {
3227
- s5 = peg$parseshorthandFunction();
3228
- if (s5 === peg$FAILED) {
3229
- peg$currPos = s4;
3230
- s4 = peg$FAILED;
3231
- } else {
3232
- s4 = s5;
3233
- }
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;
3234
2915
  } else {
3235
- s4 = s5;
2916
+ s3 = s4;
3236
2917
  }
3237
- }
3238
- if (s3.length < 1) {
3239
- peg$currPos = s2;
3240
- s2 = peg$FAILED;
3241
2918
  } else {
3242
- s2 = s3;
2919
+ s3 = s4;
3243
2920
  }
3244
- if (s2 !== peg$FAILED) {
3245
- s3 = peg$parseseparator();
3246
- if (s3 === peg$FAILED) {
3247
- s3 = null;
3248
- }
3249
- peg$savedPos = s0;
3250
- s0 = peg$f49(s2);
3251
- } else {
3252
- peg$currPos = s0;
3253
- s0 = peg$FAILED;
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;
3254
2932
  }
2933
+ peg$savedPos = s0;
2934
+ s0 = peg$f44(s1);
3255
2935
  } else {
3256
2936
  peg$currPos = s0;
3257
2937
  s0 = peg$FAILED;
@@ -3260,15 +2940,35 @@ function peg$parse(input, options) {
3260
2940
  return s0;
3261
2941
  }
3262
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
+
3263
2963
  function peg$parseinlineSpace() {
3264
2964
  var s0;
3265
2965
 
3266
2966
  s0 = input.charAt(peg$currPos);
3267
- if (peg$r4.test(s0)) {
2967
+ if (peg$r3.test(s0)) {
3268
2968
  peg$currPos++;
3269
2969
  } else {
3270
2970
  s0 = peg$FAILED;
3271
- if (peg$silentFails === 0) { peg$fail(peg$e59); }
2971
+ if (peg$silentFails === 0) { peg$fail(peg$e55); }
3272
2972
  }
3273
2973
 
3274
2974
  return s0;
@@ -3282,27 +2982,13 @@ function peg$parse(input, options) {
3282
2982
  s1 = peg$parsedigits();
3283
2983
  if (s1 !== peg$FAILED) {
3284
2984
  peg$savedPos = s0;
3285
- s1 = peg$f50();
2985
+ s1 = peg$f45();
3286
2986
  }
3287
2987
  s0 = s1;
3288
2988
  peg$silentFails--;
3289
2989
  if (s0 === peg$FAILED) {
3290
2990
  s1 = peg$FAILED;
3291
- if (peg$silentFails === 0) { peg$fail(peg$e60); }
3292
- }
3293
-
3294
- return s0;
3295
- }
3296
-
3297
- function peg$parsejseMode() {
3298
- var s0;
3299
-
3300
- peg$savedPos = peg$currPos;
3301
- s0 = peg$f51();
3302
- if (s0) {
3303
- s0 = undefined;
3304
- } else {
3305
- s0 = peg$FAILED;
2991
+ if (peg$silentFails === 0) { peg$fail(peg$e56); }
3306
2992
  }
3307
2993
 
3308
2994
  return s0;
@@ -3346,11 +3032,11 @@ function peg$parse(input, options) {
3346
3032
  peg$currPos++;
3347
3033
  } else {
3348
3034
  s1 = peg$FAILED;
3349
- if (peg$silentFails === 0) { peg$fail(peg$e40); }
3035
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
3350
3036
  }
3351
3037
  if (s1 !== peg$FAILED) {
3352
3038
  peg$savedPos = peg$currPos;
3353
- s2 = peg$f52(s1);
3039
+ s2 = peg$f46(s1);
3354
3040
  if (s2) {
3355
3041
  s2 = undefined;
3356
3042
  } else {
@@ -3370,7 +3056,7 @@ function peg$parse(input, options) {
3370
3056
  peg$silentFails--;
3371
3057
  if (s0 === peg$FAILED) {
3372
3058
  s1 = peg$FAILED;
3373
- if (peg$silentFails === 0) { peg$fail(peg$e61); }
3059
+ if (peg$silentFails === 0) { peg$fail(peg$e57); }
3374
3060
  }
3375
3061
 
3376
3062
  return s0;
@@ -3386,11 +3072,11 @@ function peg$parse(input, options) {
3386
3072
  peg$currPos++;
3387
3073
  } else {
3388
3074
  s1 = peg$FAILED;
3389
- if (peg$silentFails === 0) { peg$fail(peg$e40); }
3075
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
3390
3076
  }
3391
3077
  if (s1 !== peg$FAILED) {
3392
3078
  peg$savedPos = peg$currPos;
3393
- s2 = peg$f53(s1);
3079
+ s2 = peg$f47(s1);
3394
3080
  if (s2) {
3395
3081
  s2 = undefined;
3396
3082
  } else {
@@ -3410,7 +3096,7 @@ function peg$parse(input, options) {
3410
3096
  peg$silentFails--;
3411
3097
  if (s0 === peg$FAILED) {
3412
3098
  s1 = peg$FAILED;
3413
- if (peg$silentFails === 0) { peg$fail(peg$e62); }
3099
+ if (peg$silentFails === 0) { peg$fail(peg$e58); }
3414
3100
  }
3415
3101
 
3416
3102
  return s0;
@@ -3422,18 +3108,18 @@ function peg$parse(input, options) {
3422
3108
  s0 = peg$currPos;
3423
3109
  s1 = peg$parse__();
3424
3110
  if (input.charCodeAt(peg$currPos) === 46) {
3425
- s2 = peg$c36;
3111
+ s2 = peg$c32;
3426
3112
  peg$currPos++;
3427
3113
  } else {
3428
3114
  s2 = peg$FAILED;
3429
- if (peg$silentFails === 0) { peg$fail(peg$e47); }
3115
+ if (peg$silentFails === 0) { peg$fail(peg$e42); }
3430
3116
  }
3431
3117
  if (s2 !== peg$FAILED) {
3432
3118
  s3 = peg$parse__();
3433
3119
  s4 = peg$parsejsIdentifier();
3434
3120
  if (s4 !== peg$FAILED) {
3435
3121
  peg$savedPos = s0;
3436
- s0 = peg$f54(s4);
3122
+ s0 = peg$f48(s4);
3437
3123
  } else {
3438
3124
  peg$currPos = s0;
3439
3125
  s0 = peg$FAILED;
@@ -3446,26 +3132,6 @@ function peg$parse(input, options) {
3446
3132
  return s0;
3447
3133
  }
3448
3134
 
3449
- function peg$parsejsReference() {
3450
- var s0, s1;
3451
-
3452
- peg$silentFails++;
3453
- s0 = peg$currPos;
3454
- s1 = peg$parsejsIdentifier();
3455
- if (s1 !== peg$FAILED) {
3456
- peg$savedPos = s0;
3457
- s1 = peg$f55(s1);
3458
- }
3459
- s0 = s1;
3460
- peg$silentFails--;
3461
- if (s0 === peg$FAILED) {
3462
- s1 = peg$FAILED;
3463
- if (peg$silentFails === 0) { peg$fail(peg$e63); }
3464
- }
3465
-
3466
- return s0;
3467
- }
3468
-
3469
3135
  function peg$parselist() {
3470
3136
  var s0, s1, s2, s3, s4;
3471
3137
 
@@ -3502,15 +3168,26 @@ function peg$parse(input, options) {
3502
3168
  s2 = null;
3503
3169
  }
3504
3170
  peg$savedPos = s0;
3505
- s0 = peg$f56(s1);
3171
+ s0 = peg$f49(s1);
3506
3172
  } else {
3507
3173
  peg$currPos = s0;
3508
3174
  s0 = peg$FAILED;
3509
3175
  }
3510
3176
  peg$silentFails--;
3511
3177
  if (s0 === peg$FAILED) {
3512
- s1 = peg$FAILED;
3513
- if (peg$silentFails === 0) { peg$fail(peg$e64); }
3178
+ s1 = peg$FAILED;
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();
3514
3191
  }
3515
3192
 
3516
3193
  return s0;
@@ -3525,12 +3202,12 @@ function peg$parse(input, options) {
3525
3202
  s2 = [];
3526
3203
  s3 = peg$currPos;
3527
3204
  s4 = peg$parse__();
3528
- if (input.substr(peg$currPos, 2) === peg$c41) {
3529
- s5 = peg$c41;
3205
+ if (input.substr(peg$currPos, 2) === peg$c38) {
3206
+ s5 = peg$c38;
3530
3207
  peg$currPos += 2;
3531
3208
  } else {
3532
3209
  s5 = peg$FAILED;
3533
- if (peg$silentFails === 0) { peg$fail(peg$e65); }
3210
+ if (peg$silentFails === 0) { peg$fail(peg$e60); }
3534
3211
  }
3535
3212
  if (s5 !== peg$FAILED) {
3536
3213
  s6 = peg$parse__();
@@ -3549,12 +3226,12 @@ function peg$parse(input, options) {
3549
3226
  s2.push(s3);
3550
3227
  s3 = peg$currPos;
3551
3228
  s4 = peg$parse__();
3552
- if (input.substr(peg$currPos, 2) === peg$c41) {
3553
- s5 = peg$c41;
3229
+ if (input.substr(peg$currPos, 2) === peg$c38) {
3230
+ s5 = peg$c38;
3554
3231
  peg$currPos += 2;
3555
3232
  } else {
3556
3233
  s5 = peg$FAILED;
3557
- if (peg$silentFails === 0) { peg$fail(peg$e65); }
3234
+ if (peg$silentFails === 0) { peg$fail(peg$e60); }
3558
3235
  }
3559
3236
  if (s5 !== peg$FAILED) {
3560
3237
  s6 = peg$parse__();
@@ -3571,7 +3248,7 @@ function peg$parse(input, options) {
3571
3248
  }
3572
3249
  }
3573
3250
  peg$savedPos = s0;
3574
- s0 = peg$f57(s1, s2);
3251
+ s0 = peg$f50(s1, s2);
3575
3252
  } else {
3576
3253
  peg$currPos = s0;
3577
3254
  s0 = peg$FAILED;
@@ -3589,12 +3266,12 @@ function peg$parse(input, options) {
3589
3266
  s2 = [];
3590
3267
  s3 = peg$currPos;
3591
3268
  s4 = peg$parse__();
3592
- if (input.substr(peg$currPos, 2) === peg$c42) {
3593
- s5 = peg$c42;
3269
+ if (input.substr(peg$currPos, 2) === peg$c39) {
3270
+ s5 = peg$c39;
3594
3271
  peg$currPos += 2;
3595
3272
  } else {
3596
3273
  s5 = peg$FAILED;
3597
- if (peg$silentFails === 0) { peg$fail(peg$e66); }
3274
+ if (peg$silentFails === 0) { peg$fail(peg$e61); }
3598
3275
  }
3599
3276
  if (s5 !== peg$FAILED) {
3600
3277
  s6 = peg$parse__();
@@ -3613,12 +3290,12 @@ function peg$parse(input, options) {
3613
3290
  s2.push(s3);
3614
3291
  s3 = peg$currPos;
3615
3292
  s4 = peg$parse__();
3616
- if (input.substr(peg$currPos, 2) === peg$c42) {
3617
- s5 = peg$c42;
3293
+ if (input.substr(peg$currPos, 2) === peg$c39) {
3294
+ s5 = peg$c39;
3618
3295
  peg$currPos += 2;
3619
3296
  } else {
3620
3297
  s5 = peg$FAILED;
3621
- if (peg$silentFails === 0) { peg$fail(peg$e66); }
3298
+ if (peg$silentFails === 0) { peg$fail(peg$e61); }
3622
3299
  }
3623
3300
  if (s5 !== peg$FAILED) {
3624
3301
  s6 = peg$parse__();
@@ -3635,7 +3312,7 @@ function peg$parse(input, options) {
3635
3312
  }
3636
3313
  }
3637
3314
  peg$savedPos = s0;
3638
- s0 = peg$f58(s1, s2);
3315
+ s0 = peg$f51(s1, s2);
3639
3316
  } else {
3640
3317
  peg$currPos = s0;
3641
3318
  s0 = peg$FAILED;
@@ -3648,24 +3325,24 @@ function peg$parse(input, options) {
3648
3325
  var s0, s1, s2, s3, s4, s5;
3649
3326
 
3650
3327
  s0 = peg$currPos;
3651
- if (input.substr(peg$currPos, 2) === peg$c43) {
3652
- s1 = peg$c43;
3328
+ if (input.substr(peg$currPos, 2) === peg$c40) {
3329
+ s1 = peg$c40;
3653
3330
  peg$currPos += 2;
3654
3331
  } else {
3655
3332
  s1 = peg$FAILED;
3656
- if (peg$silentFails === 0) { peg$fail(peg$e67); }
3333
+ if (peg$silentFails === 0) { peg$fail(peg$e62); }
3657
3334
  }
3658
3335
  if (s1 !== peg$FAILED) {
3659
3336
  s2 = [];
3660
3337
  s3 = peg$currPos;
3661
3338
  s4 = peg$currPos;
3662
3339
  peg$silentFails++;
3663
- if (input.substr(peg$currPos, 2) === peg$c44) {
3664
- s5 = peg$c44;
3340
+ if (input.substr(peg$currPos, 2) === peg$c41) {
3341
+ s5 = peg$c41;
3665
3342
  peg$currPos += 2;
3666
3343
  } else {
3667
3344
  s5 = peg$FAILED;
3668
- if (peg$silentFails === 0) { peg$fail(peg$e68); }
3345
+ if (peg$silentFails === 0) { peg$fail(peg$e63); }
3669
3346
  }
3670
3347
  peg$silentFails--;
3671
3348
  if (s5 === peg$FAILED) {
@@ -3680,7 +3357,7 @@ function peg$parse(input, options) {
3680
3357
  peg$currPos++;
3681
3358
  } else {
3682
3359
  s5 = peg$FAILED;
3683
- if (peg$silentFails === 0) { peg$fail(peg$e40); }
3360
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
3684
3361
  }
3685
3362
  if (s5 !== peg$FAILED) {
3686
3363
  s4 = [s4, s5];
@@ -3698,12 +3375,12 @@ function peg$parse(input, options) {
3698
3375
  s3 = peg$currPos;
3699
3376
  s4 = peg$currPos;
3700
3377
  peg$silentFails++;
3701
- if (input.substr(peg$currPos, 2) === peg$c44) {
3702
- s5 = peg$c44;
3378
+ if (input.substr(peg$currPos, 2) === peg$c41) {
3379
+ s5 = peg$c41;
3703
3380
  peg$currPos += 2;
3704
3381
  } else {
3705
3382
  s5 = peg$FAILED;
3706
- if (peg$silentFails === 0) { peg$fail(peg$e68); }
3383
+ if (peg$silentFails === 0) { peg$fail(peg$e63); }
3707
3384
  }
3708
3385
  peg$silentFails--;
3709
3386
  if (s5 === peg$FAILED) {
@@ -3718,7 +3395,7 @@ function peg$parse(input, options) {
3718
3395
  peg$currPos++;
3719
3396
  } else {
3720
3397
  s5 = peg$FAILED;
3721
- if (peg$silentFails === 0) { peg$fail(peg$e40); }
3398
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
3722
3399
  }
3723
3400
  if (s5 !== peg$FAILED) {
3724
3401
  s4 = [s4, s5];
@@ -3732,16 +3409,16 @@ function peg$parse(input, options) {
3732
3409
  s3 = peg$FAILED;
3733
3410
  }
3734
3411
  }
3735
- if (input.substr(peg$currPos, 2) === peg$c44) {
3736
- s3 = peg$c44;
3412
+ if (input.substr(peg$currPos, 2) === peg$c41) {
3413
+ s3 = peg$c41;
3737
3414
  peg$currPos += 2;
3738
3415
  } else {
3739
3416
  s3 = peg$FAILED;
3740
- if (peg$silentFails === 0) { peg$fail(peg$e68); }
3417
+ if (peg$silentFails === 0) { peg$fail(peg$e63); }
3741
3418
  }
3742
3419
  if (s3 !== peg$FAILED) {
3743
3420
  peg$savedPos = s0;
3744
- s0 = peg$f59();
3421
+ s0 = peg$f52();
3745
3422
  } else {
3746
3423
  peg$currPos = s0;
3747
3424
  s0 = peg$FAILED;
@@ -3762,11 +3439,11 @@ function peg$parse(input, options) {
3762
3439
  if (s1 !== peg$FAILED) {
3763
3440
  s2 = [];
3764
3441
  s3 = peg$currPos;
3765
- s4 = peg$parsewhitespaceShell();
3442
+ s4 = peg$parsewhitespace();
3766
3443
  if (s4 !== peg$FAILED) {
3767
3444
  s5 = peg$parsemultiplicativeOperator();
3768
3445
  if (s5 !== peg$FAILED) {
3769
- s6 = peg$parsewhitespaceShell();
3446
+ s6 = peg$parsewhitespace();
3770
3447
  if (s6 !== peg$FAILED) {
3771
3448
  s7 = peg$parseexponentiationExpression();
3772
3449
  if (s7 !== peg$FAILED) {
@@ -3790,11 +3467,11 @@ function peg$parse(input, options) {
3790
3467
  while (s3 !== peg$FAILED) {
3791
3468
  s2.push(s3);
3792
3469
  s3 = peg$currPos;
3793
- s4 = peg$parsewhitespaceShell();
3470
+ s4 = peg$parsewhitespace();
3794
3471
  if (s4 !== peg$FAILED) {
3795
3472
  s5 = peg$parsemultiplicativeOperator();
3796
3473
  if (s5 !== peg$FAILED) {
3797
- s6 = peg$parsewhitespaceShell();
3474
+ s6 = peg$parsewhitespace();
3798
3475
  if (s6 !== peg$FAILED) {
3799
3476
  s7 = peg$parseexponentiationExpression();
3800
3477
  if (s7 !== peg$FAILED) {
@@ -3817,7 +3494,7 @@ function peg$parse(input, options) {
3817
3494
  }
3818
3495
  }
3819
3496
  peg$savedPos = s0;
3820
- s0 = peg$f60(s1, s2);
3497
+ s0 = peg$f53(s1, s2);
3821
3498
  } else {
3822
3499
  peg$currPos = s0;
3823
3500
  s0 = peg$FAILED;
@@ -3830,11 +3507,11 @@ function peg$parse(input, options) {
3830
3507
  var s0;
3831
3508
 
3832
3509
  s0 = input.charAt(peg$currPos);
3833
- if (peg$r5.test(s0)) {
3510
+ if (peg$r4.test(s0)) {
3834
3511
  peg$currPos++;
3835
3512
  } else {
3836
3513
  s0 = peg$FAILED;
3837
- if (peg$silentFails === 0) { peg$fail(peg$e69); }
3514
+ if (peg$silentFails === 0) { peg$fail(peg$e64); }
3838
3515
  }
3839
3516
 
3840
3517
  return s0;
@@ -3846,21 +3523,21 @@ function peg$parse(input, options) {
3846
3523
  s0 = peg$currPos;
3847
3524
  s1 = [];
3848
3525
  s2 = input.charAt(peg$currPos);
3849
- if (peg$r6.test(s2)) {
3526
+ if (peg$r5.test(s2)) {
3850
3527
  peg$currPos++;
3851
3528
  } else {
3852
3529
  s2 = peg$FAILED;
3853
- if (peg$silentFails === 0) { peg$fail(peg$e70); }
3530
+ if (peg$silentFails === 0) { peg$fail(peg$e65); }
3854
3531
  }
3855
3532
  if (s2 !== peg$FAILED) {
3856
3533
  while (s2 !== peg$FAILED) {
3857
3534
  s1.push(s2);
3858
3535
  s2 = input.charAt(peg$currPos);
3859
- if (peg$r6.test(s2)) {
3536
+ if (peg$r5.test(s2)) {
3860
3537
  peg$currPos++;
3861
3538
  } else {
3862
3539
  s2 = peg$FAILED;
3863
- if (peg$silentFails === 0) { peg$fail(peg$e70); }
3540
+ if (peg$silentFails === 0) { peg$fail(peg$e65); }
3864
3541
  }
3865
3542
  }
3866
3543
  } else {
@@ -3868,50 +3545,15 @@ function peg$parse(input, options) {
3868
3545
  }
3869
3546
  if (s1 !== peg$FAILED) {
3870
3547
  if (input.charCodeAt(peg$currPos) === 58) {
3871
- s2 = peg$c4;
3548
+ s2 = peg$c9;
3872
3549
  peg$currPos++;
3873
3550
  } else {
3874
3551
  s2 = peg$FAILED;
3875
- if (peg$silentFails === 0) { peg$fail(peg$e6); }
3552
+ if (peg$silentFails === 0) { peg$fail(peg$e14); }
3876
3553
  }
3877
3554
  if (s2 !== peg$FAILED) {
3878
3555
  peg$savedPos = s0;
3879
- s0 = peg$f61(s1);
3880
- } else {
3881
- peg$currPos = s0;
3882
- s0 = peg$FAILED;
3883
- }
3884
- } else {
3885
- peg$currPos = s0;
3886
- s0 = peg$FAILED;
3887
- }
3888
-
3889
- return s0;
3890
- }
3891
-
3892
- function peg$parsenewExpression() {
3893
- var s0, s1, s2, s3, s4;
3894
-
3895
- s0 = peg$currPos;
3896
- if (input.substr(peg$currPos, 3) === peg$c45) {
3897
- s1 = peg$c45;
3898
- peg$currPos += 3;
3899
- } else {
3900
- s1 = peg$FAILED;
3901
- if (peg$silentFails === 0) { peg$fail(peg$e71); }
3902
- }
3903
- if (s1 !== peg$FAILED) {
3904
- s2 = peg$parse__();
3905
- s3 = peg$parsejsReference();
3906
- if (s3 !== peg$FAILED) {
3907
- s4 = peg$parseparenthesesArguments();
3908
- if (s4 !== peg$FAILED) {
3909
- peg$savedPos = s0;
3910
- s0 = peg$f62(s3, s4);
3911
- } else {
3912
- peg$currPos = s0;
3913
- s0 = peg$FAILED;
3914
- }
3556
+ s0 = peg$f54(s1);
3915
3557
  } else {
3916
3558
  peg$currPos = s0;
3917
3559
  s0 = peg$FAILED;
@@ -3928,27 +3570,27 @@ function peg$parse(input, options) {
3928
3570
  var s0;
3929
3571
 
3930
3572
  if (input.charCodeAt(peg$currPos) === 10) {
3931
- s0 = peg$c46;
3573
+ s0 = peg$c42;
3932
3574
  peg$currPos++;
3933
3575
  } else {
3934
3576
  s0 = peg$FAILED;
3935
- if (peg$silentFails === 0) { peg$fail(peg$e72); }
3577
+ if (peg$silentFails === 0) { peg$fail(peg$e66); }
3936
3578
  }
3937
3579
  if (s0 === peg$FAILED) {
3938
- if (input.substr(peg$currPos, 2) === peg$c47) {
3939
- s0 = peg$c47;
3580
+ if (input.substr(peg$currPos, 2) === peg$c43) {
3581
+ s0 = peg$c43;
3940
3582
  peg$currPos += 2;
3941
3583
  } else {
3942
3584
  s0 = peg$FAILED;
3943
- if (peg$silentFails === 0) { peg$fail(peg$e73); }
3585
+ if (peg$silentFails === 0) { peg$fail(peg$e67); }
3944
3586
  }
3945
3587
  if (s0 === peg$FAILED) {
3946
3588
  if (input.charCodeAt(peg$currPos) === 13) {
3947
- s0 = peg$c48;
3589
+ s0 = peg$c44;
3948
3590
  peg$currPos++;
3949
3591
  } else {
3950
3592
  s0 = peg$FAILED;
3951
- if (peg$silentFails === 0) { peg$fail(peg$e74); }
3593
+ if (peg$silentFails === 0) { peg$fail(peg$e68); }
3952
3594
  }
3953
3595
  }
3954
3596
  }
@@ -3967,7 +3609,7 @@ function peg$parse(input, options) {
3967
3609
  peg$silentFails--;
3968
3610
  if (s0 === peg$FAILED) {
3969
3611
  s1 = peg$FAILED;
3970
- if (peg$silentFails === 0) { peg$fail(peg$e75); }
3612
+ if (peg$silentFails === 0) { peg$fail(peg$e69); }
3971
3613
  }
3972
3614
 
3973
3615
  return s0;
@@ -3982,12 +3624,12 @@ function peg$parse(input, options) {
3982
3624
  s2 = [];
3983
3625
  s3 = peg$currPos;
3984
3626
  s4 = peg$parse__();
3985
- if (input.substr(peg$currPos, 2) === peg$c49) {
3986
- s5 = peg$c49;
3627
+ if (input.substr(peg$currPos, 2) === peg$c45) {
3628
+ s5 = peg$c45;
3987
3629
  peg$currPos += 2;
3988
3630
  } else {
3989
3631
  s5 = peg$FAILED;
3990
- if (peg$silentFails === 0) { peg$fail(peg$e76); }
3632
+ if (peg$silentFails === 0) { peg$fail(peg$e70); }
3991
3633
  }
3992
3634
  if (s5 !== peg$FAILED) {
3993
3635
  s6 = peg$parse__();
@@ -4006,12 +3648,12 @@ function peg$parse(input, options) {
4006
3648
  s2.push(s3);
4007
3649
  s3 = peg$currPos;
4008
3650
  s4 = peg$parse__();
4009
- if (input.substr(peg$currPos, 2) === peg$c49) {
4010
- s5 = peg$c49;
3651
+ if (input.substr(peg$currPos, 2) === peg$c45) {
3652
+ s5 = peg$c45;
4011
3653
  peg$currPos += 2;
4012
3654
  } else {
4013
3655
  s5 = peg$FAILED;
4014
- if (peg$silentFails === 0) { peg$fail(peg$e76); }
3656
+ if (peg$silentFails === 0) { peg$fail(peg$e70); }
4015
3657
  }
4016
3658
  if (s5 !== peg$FAILED) {
4017
3659
  s6 = peg$parse__();
@@ -4028,7 +3670,7 @@ function peg$parse(input, options) {
4028
3670
  }
4029
3671
  }
4030
3672
  peg$savedPos = s0;
4031
- s0 = peg$f63(s1, s2);
3673
+ s0 = peg$f55(s1, s2);
4032
3674
  } else {
4033
3675
  peg$currPos = s0;
4034
3676
  s0 = peg$FAILED;
@@ -4043,11 +3685,11 @@ function peg$parse(input, options) {
4043
3685
  peg$silentFails++;
4044
3686
  s0 = peg$currPos;
4045
3687
  if (input.charCodeAt(peg$currPos) === 123) {
4046
- s1 = peg$c50;
3688
+ s1 = peg$c46;
4047
3689
  peg$currPos++;
4048
3690
  } else {
4049
3691
  s1 = peg$FAILED;
4050
- if (peg$silentFails === 0) { peg$fail(peg$e78); }
3692
+ if (peg$silentFails === 0) { peg$fail(peg$e72); }
4051
3693
  }
4052
3694
  if (s1 !== peg$FAILED) {
4053
3695
  s2 = peg$parse__();
@@ -4059,7 +3701,7 @@ function peg$parse(input, options) {
4059
3701
  s5 = peg$parseexpectClosingBrace();
4060
3702
  if (s5 !== peg$FAILED) {
4061
3703
  peg$savedPos = s0;
4062
- s0 = peg$f64(s3);
3704
+ s0 = peg$f56(s3);
4063
3705
  } else {
4064
3706
  peg$currPos = s0;
4065
3707
  s0 = peg$FAILED;
@@ -4071,7 +3713,7 @@ function peg$parse(input, options) {
4071
3713
  peg$silentFails--;
4072
3714
  if (s0 === peg$FAILED) {
4073
3715
  s1 = peg$FAILED;
4074
- if (peg$silentFails === 0) { peg$fail(peg$e77); }
3716
+ if (peg$silentFails === 0) { peg$fail(peg$e71); }
4075
3717
  }
4076
3718
 
4077
3719
  return s0;
@@ -4112,7 +3754,7 @@ function peg$parse(input, options) {
4112
3754
  s2 = null;
4113
3755
  }
4114
3756
  peg$savedPos = s0;
4115
- s0 = peg$f65(s1);
3757
+ s0 = peg$f57(s1);
4116
3758
  } else {
4117
3759
  peg$currPos = s0;
4118
3760
  s0 = peg$FAILED;
@@ -4147,18 +3789,18 @@ function peg$parse(input, options) {
4147
3789
  if (s1 !== peg$FAILED) {
4148
3790
  s2 = peg$parse__();
4149
3791
  if (input.charCodeAt(peg$currPos) === 61) {
4150
- s3 = peg$c51;
3792
+ s3 = peg$c47;
4151
3793
  peg$currPos++;
4152
3794
  } else {
4153
3795
  s3 = peg$FAILED;
4154
- if (peg$silentFails === 0) { peg$fail(peg$e80); }
3796
+ if (peg$silentFails === 0) { peg$fail(peg$e74); }
4155
3797
  }
4156
3798
  if (s3 !== peg$FAILED) {
4157
3799
  s4 = peg$parse__();
4158
3800
  s5 = peg$parseexpectPipelineExpression();
4159
3801
  if (s5 !== peg$FAILED) {
4160
3802
  peg$savedPos = s0;
4161
- s0 = peg$f66(s1, s5);
3803
+ s0 = peg$f58(s1, s5);
4162
3804
  } else {
4163
3805
  peg$currPos = s0;
4164
3806
  s0 = peg$FAILED;
@@ -4174,7 +3816,7 @@ function peg$parse(input, options) {
4174
3816
  peg$silentFails--;
4175
3817
  if (s0 === peg$FAILED) {
4176
3818
  s1 = peg$FAILED;
4177
- if (peg$silentFails === 0) { peg$fail(peg$e79); }
3819
+ if (peg$silentFails === 0) { peg$fail(peg$e73); }
4178
3820
  }
4179
3821
 
4180
3822
  return s0;
@@ -4186,21 +3828,21 @@ function peg$parse(input, options) {
4186
3828
  s0 = peg$currPos;
4187
3829
  s1 = peg$currPos;
4188
3830
  if (input.charCodeAt(peg$currPos) === 40) {
4189
- s2 = peg$c7;
3831
+ s2 = peg$c2;
4190
3832
  peg$currPos++;
4191
3833
  } else {
4192
3834
  s2 = peg$FAILED;
4193
- if (peg$silentFails === 0) { peg$fail(peg$e11); }
3835
+ if (peg$silentFails === 0) { peg$fail(peg$e5); }
4194
3836
  }
4195
3837
  if (s2 !== peg$FAILED) {
4196
3838
  s3 = peg$parseobjectPublicKey();
4197
3839
  if (s3 !== peg$FAILED) {
4198
3840
  if (input.charCodeAt(peg$currPos) === 41) {
4199
- s4 = peg$c8;
3841
+ s4 = peg$c3;
4200
3842
  peg$currPos++;
4201
3843
  } else {
4202
3844
  s4 = peg$FAILED;
4203
- if (peg$silentFails === 0) { peg$fail(peg$e12); }
3845
+ if (peg$silentFails === 0) { peg$fail(peg$e6); }
4204
3846
  }
4205
3847
  if (s4 !== peg$FAILED) {
4206
3848
  s2 = [s2, s3, s4];
@@ -4219,7 +3861,7 @@ function peg$parse(input, options) {
4219
3861
  }
4220
3862
  if (s1 !== peg$FAILED) {
4221
3863
  peg$savedPos = s0;
4222
- s1 = peg$f67(s1);
3864
+ s1 = peg$f59(s1);
4223
3865
  }
4224
3866
  s0 = s1;
4225
3867
 
@@ -4237,7 +3879,7 @@ function peg$parse(input, options) {
4237
3879
  peg$silentFails--;
4238
3880
  if (s0 === peg$FAILED) {
4239
3881
  s1 = peg$FAILED;
4240
- if (peg$silentFails === 0) { peg$fail(peg$e81); }
3882
+ if (peg$silentFails === 0) { peg$fail(peg$e75); }
4241
3883
  }
4242
3884
 
4243
3885
  return s0;
@@ -4252,18 +3894,18 @@ function peg$parse(input, options) {
4252
3894
  if (s1 !== peg$FAILED) {
4253
3895
  s2 = peg$parse__();
4254
3896
  if (input.charCodeAt(peg$currPos) === 58) {
4255
- s3 = peg$c4;
3897
+ s3 = peg$c9;
4256
3898
  peg$currPos++;
4257
3899
  } else {
4258
3900
  s3 = peg$FAILED;
4259
- if (peg$silentFails === 0) { peg$fail(peg$e6); }
3901
+ if (peg$silentFails === 0) { peg$fail(peg$e14); }
4260
3902
  }
4261
3903
  if (s3 !== peg$FAILED) {
4262
3904
  s4 = peg$parse__();
4263
3905
  s5 = peg$parseexpectPipelineExpression();
4264
3906
  if (s5 !== peg$FAILED) {
4265
3907
  peg$savedPos = s0;
4266
- s0 = peg$f68(s1, s5);
3908
+ s0 = peg$f60(s1, s5);
4267
3909
  } else {
4268
3910
  peg$currPos = s0;
4269
3911
  s0 = peg$FAILED;
@@ -4279,7 +3921,7 @@ function peg$parse(input, options) {
4279
3921
  peg$silentFails--;
4280
3922
  if (s0 === peg$FAILED) {
4281
3923
  s1 = peg$FAILED;
4282
- if (peg$silentFails === 0) { peg$fail(peg$e82); }
3924
+ if (peg$silentFails === 0) { peg$fail(peg$e76); }
4283
3925
  }
4284
3926
 
4285
3927
  return s0;
@@ -4293,13 +3935,13 @@ function peg$parse(input, options) {
4293
3935
  s1 = peg$parseobjectPublicKey();
4294
3936
  if (s1 !== peg$FAILED) {
4295
3937
  peg$savedPos = s0;
4296
- s1 = peg$f69(s1);
3938
+ s1 = peg$f61(s1);
4297
3939
  }
4298
3940
  s0 = s1;
4299
3941
  peg$silentFails--;
4300
3942
  if (s0 === peg$FAILED) {
4301
3943
  s1 = peg$FAILED;
4302
- if (peg$silentFails === 0) { peg$fail(peg$e83); }
3944
+ if (peg$silentFails === 0) { peg$fail(peg$e77); }
4303
3945
  }
4304
3946
 
4305
3947
  return s0;
@@ -4312,17 +3954,17 @@ function peg$parse(input, options) {
4312
3954
  s1 = peg$parseidentifier();
4313
3955
  if (s1 !== peg$FAILED) {
4314
3956
  if (input.charCodeAt(peg$currPos) === 47) {
4315
- s2 = peg$c3;
3957
+ s2 = peg$c48;
4316
3958
  peg$currPos++;
4317
3959
  } else {
4318
3960
  s2 = peg$FAILED;
4319
- if (peg$silentFails === 0) { peg$fail(peg$e4); }
3961
+ if (peg$silentFails === 0) { peg$fail(peg$e78); }
4320
3962
  }
4321
3963
  if (s2 === peg$FAILED) {
4322
3964
  s2 = null;
4323
3965
  }
4324
3966
  peg$savedPos = s0;
4325
- s0 = peg$f70(s1, s2);
3967
+ s0 = peg$f62(s1, s2);
4326
3968
  } else {
4327
3969
  peg$currPos = s0;
4328
3970
  s0 = peg$FAILED;
@@ -4332,7 +3974,7 @@ function peg$parse(input, options) {
4332
3974
  s1 = peg$parsestringLiteral();
4333
3975
  if (s1 !== peg$FAILED) {
4334
3976
  peg$savedPos = s0;
4335
- s1 = peg$f71(s1);
3977
+ s1 = peg$f63(s1);
4336
3978
  }
4337
3979
  s0 = s1;
4338
3980
  }
@@ -4340,36 +3982,6 @@ function peg$parse(input, options) {
4340
3982
  return s0;
4341
3983
  }
4342
3984
 
4343
- function peg$parseoptionalChaining() {
4344
- var s0, s1, s2, s3, s4;
4345
-
4346
- s0 = peg$currPos;
4347
- s1 = peg$parse__();
4348
- if (input.substr(peg$currPos, 2) === peg$c52) {
4349
- s2 = peg$c52;
4350
- peg$currPos += 2;
4351
- } else {
4352
- s2 = peg$FAILED;
4353
- if (peg$silentFails === 0) { peg$fail(peg$e84); }
4354
- }
4355
- if (s2 !== peg$FAILED) {
4356
- s3 = peg$parse__();
4357
- s4 = peg$parsejsIdentifier();
4358
- if (s4 !== peg$FAILED) {
4359
- peg$savedPos = s0;
4360
- s0 = peg$f72(s4);
4361
- } else {
4362
- peg$currPos = s0;
4363
- s0 = peg$FAILED;
4364
- }
4365
- } else {
4366
- peg$currPos = s0;
4367
- s0 = peg$FAILED;
4368
- }
4369
-
4370
- return s0;
4371
- }
4372
-
4373
3985
  function peg$parseparameter() {
4374
3986
  var s0, s1;
4375
3987
 
@@ -4377,7 +3989,7 @@ function peg$parse(input, options) {
4377
3989
  s1 = peg$parseidentifier();
4378
3990
  if (s1 !== peg$FAILED) {
4379
3991
  peg$savedPos = s0;
4380
- s1 = peg$f73(s1);
3992
+ s1 = peg$f64(s1);
4381
3993
  }
4382
3994
  s0 = s1;
4383
3995
 
@@ -4419,7 +4031,7 @@ function peg$parse(input, options) {
4419
4031
  s2 = null;
4420
4032
  }
4421
4033
  peg$savedPos = s0;
4422
- s0 = peg$f74(s1);
4034
+ s0 = peg$f65(s1);
4423
4035
  } else {
4424
4036
  peg$currPos = s0;
4425
4037
  s0 = peg$FAILED;
@@ -4435,7 +4047,7 @@ function peg$parse(input, options) {
4435
4047
  s1 = peg$parseidentifier();
4436
4048
  if (s1 !== peg$FAILED) {
4437
4049
  peg$savedPos = s0;
4438
- s1 = peg$f75(s1);
4050
+ s1 = peg$f66(s1);
4439
4051
  }
4440
4052
  s0 = s1;
4441
4053
 
@@ -4448,11 +4060,11 @@ function peg$parse(input, options) {
4448
4060
  peg$silentFails++;
4449
4061
  s0 = peg$currPos;
4450
4062
  if (input.charCodeAt(peg$currPos) === 40) {
4451
- s1 = peg$c7;
4063
+ s1 = peg$c2;
4452
4064
  peg$currPos++;
4453
4065
  } else {
4454
4066
  s1 = peg$FAILED;
4455
- if (peg$silentFails === 0) { peg$fail(peg$e11); }
4067
+ if (peg$silentFails === 0) { peg$fail(peg$e5); }
4456
4068
  }
4457
4069
  if (s1 !== peg$FAILED) {
4458
4070
  s2 = peg$parse__();
@@ -4464,7 +4076,7 @@ function peg$parse(input, options) {
4464
4076
  s5 = peg$parseexpectClosingParenthesis();
4465
4077
  if (s5 !== peg$FAILED) {
4466
4078
  peg$savedPos = s0;
4467
- s0 = peg$f76(s3);
4079
+ s0 = peg$f67(s3);
4468
4080
  } else {
4469
4081
  peg$currPos = s0;
4470
4082
  s0 = peg$FAILED;
@@ -4476,7 +4088,7 @@ function peg$parse(input, options) {
4476
4088
  peg$silentFails--;
4477
4089
  if (s0 === peg$FAILED) {
4478
4090
  s1 = peg$FAILED;
4479
- if (peg$silentFails === 0) { peg$fail(peg$e85); }
4091
+ if (peg$silentFails === 0) { peg$fail(peg$e79); }
4480
4092
  }
4481
4093
 
4482
4094
  return s0;
@@ -4502,13 +4114,13 @@ function peg$parse(input, options) {
4502
4114
  }
4503
4115
  if (s1 !== peg$FAILED) {
4504
4116
  peg$savedPos = s0;
4505
- s1 = peg$f77(s1);
4117
+ s1 = peg$f68(s1);
4506
4118
  }
4507
4119
  s0 = s1;
4508
4120
  peg$silentFails--;
4509
4121
  if (s0 === peg$FAILED) {
4510
4122
  s1 = peg$FAILED;
4511
- if (peg$silentFails === 0) { peg$fail(peg$e86); }
4123
+ if (peg$silentFails === 0) { peg$fail(peg$e80); }
4512
4124
  }
4513
4125
 
4514
4126
  return s0;
@@ -4521,7 +4133,7 @@ function peg$parse(input, options) {
4521
4133
  s1 = peg$parsepath();
4522
4134
  if (s1 !== peg$FAILED) {
4523
4135
  peg$savedPos = s0;
4524
- s1 = peg$f78(s1);
4136
+ s1 = peg$f69(s1);
4525
4137
  }
4526
4138
  s0 = s1;
4527
4139
 
@@ -4548,7 +4160,7 @@ function peg$parse(input, options) {
4548
4160
  s2 = null;
4549
4161
  }
4550
4162
  peg$savedPos = s0;
4551
- s0 = peg$f79(s1, s2);
4163
+ s0 = peg$f70(s1, s2);
4552
4164
  } else {
4553
4165
  peg$currPos = s0;
4554
4166
  s0 = peg$FAILED;
@@ -4562,11 +4174,11 @@ function peg$parse(input, options) {
4562
4174
 
4563
4175
  s0 = peg$currPos;
4564
4176
  if (input.charCodeAt(peg$currPos) === 47) {
4565
- s1 = peg$c3;
4177
+ s1 = peg$c48;
4566
4178
  peg$currPos++;
4567
4179
  } else {
4568
4180
  s1 = peg$FAILED;
4569
- if (peg$silentFails === 0) { peg$fail(peg$e4); }
4181
+ if (peg$silentFails === 0) { peg$fail(peg$e78); }
4570
4182
  }
4571
4183
  if (s1 !== peg$FAILED) {
4572
4184
  s2 = peg$parsepathKey();
@@ -4586,11 +4198,11 @@ function peg$parse(input, options) {
4586
4198
  var s0;
4587
4199
 
4588
4200
  s0 = input.charAt(peg$currPos);
4589
- if (peg$r7.test(s0)) {
4201
+ if (peg$r6.test(s0)) {
4590
4202
  peg$currPos++;
4591
4203
  } else {
4592
4204
  s0 = peg$FAILED;
4593
- if (peg$silentFails === 0) { peg$fail(peg$e87); }
4205
+ if (peg$silentFails === 0) { peg$fail(peg$e81); }
4594
4206
  }
4595
4207
  if (s0 === peg$FAILED) {
4596
4208
  s0 = peg$parseescapedChar();
@@ -4642,7 +4254,7 @@ function peg$parse(input, options) {
4642
4254
  }
4643
4255
  }
4644
4256
  peg$savedPos = s0;
4645
- s0 = peg$f80(s1, s2);
4257
+ s0 = peg$f71(s1, s2);
4646
4258
  } else {
4647
4259
  peg$currPos = s0;
4648
4260
  s0 = peg$FAILED;
@@ -4652,51 +4264,19 @@ function peg$parse(input, options) {
4652
4264
  }
4653
4265
 
4654
4266
  function peg$parseprimary() {
4655
- var s0, s1, s2;
4267
+ var s0;
4656
4268
 
4657
- s0 = peg$parsenumericLiteral();
4269
+ s0 = peg$parseliteral();
4658
4270
  if (s0 === peg$FAILED) {
4659
- s0 = peg$parsestringLiteral();
4271
+ s0 = peg$parsearrayLiteral();
4660
4272
  if (s0 === peg$FAILED) {
4661
- s0 = peg$parsearrayLiteral();
4273
+ s0 = peg$parseobjectLiteral();
4662
4274
  if (s0 === peg$FAILED) {
4663
- s0 = peg$parseobjectLiteral();
4275
+ s0 = peg$parsegroup();
4664
4276
  if (s0 === peg$FAILED) {
4665
- s0 = peg$parsegroup();
4277
+ s0 = peg$parsetemplateLiteral();
4666
4278
  if (s0 === peg$FAILED) {
4667
- s0 = peg$parsetemplateLiteral();
4668
- if (s0 === peg$FAILED) {
4669
- s0 = peg$currPos;
4670
- s1 = peg$parseshellMode();
4671
- if (s1 !== peg$FAILED) {
4672
- s2 = peg$parseprimaryShell();
4673
- if (s2 !== peg$FAILED) {
4674
- s0 = s2;
4675
- } else {
4676
- peg$currPos = s0;
4677
- s0 = peg$FAILED;
4678
- }
4679
- } else {
4680
- peg$currPos = s0;
4681
- s0 = peg$FAILED;
4682
- }
4683
- if (s0 === peg$FAILED) {
4684
- s0 = peg$currPos;
4685
- s1 = peg$parsejseMode();
4686
- if (s1 !== peg$FAILED) {
4687
- s2 = peg$parseprimaryJse();
4688
- if (s2 !== peg$FAILED) {
4689
- s0 = s2;
4690
- } else {
4691
- peg$currPos = s0;
4692
- s0 = peg$FAILED;
4693
- }
4694
- } else {
4695
- peg$currPos = s0;
4696
- s0 = peg$FAILED;
4697
- }
4698
- }
4699
- }
4279
+ s0 = peg$parseinherited();
4700
4280
  }
4701
4281
  }
4702
4282
  }
@@ -4706,40 +4286,6 @@ function peg$parse(input, options) {
4706
4286
  return s0;
4707
4287
  }
4708
4288
 
4709
- function peg$parseprimaryJse() {
4710
- var s0;
4711
-
4712
- s0 = peg$parseangleBracketLiteral();
4713
- if (s0 === peg$FAILED) {
4714
- s0 = peg$parsejsReference();
4715
- if (s0 === peg$FAILED) {
4716
- s0 = peg$parseregexLiteral();
4717
- }
4718
- }
4719
-
4720
- return s0;
4721
- }
4722
-
4723
- function peg$parseprimaryShell() {
4724
- var s0;
4725
-
4726
- s0 = peg$parserootDirectory();
4727
- if (s0 === peg$FAILED) {
4728
- s0 = peg$parsehomeDirectory();
4729
- if (s0 === peg$FAILED) {
4730
- s0 = peg$parsequalifiedReference();
4731
- if (s0 === peg$FAILED) {
4732
- s0 = peg$parsenamespace();
4733
- if (s0 === peg$FAILED) {
4734
- s0 = peg$parsescopeReference();
4735
- }
4736
- }
4737
- }
4738
- }
4739
-
4740
- return s0;
4741
- }
4742
-
4743
4289
  function peg$parseprogram() {
4744
4290
  var s0, s1, s2;
4745
4291
 
@@ -4753,145 +4299,47 @@ function peg$parse(input, options) {
4753
4299
  if (s2 !== peg$FAILED) {
4754
4300
  s0 = s2;
4755
4301
  } else {
4756
- peg$currPos = s0;
4757
- s0 = peg$FAILED;
4758
- }
4759
- peg$silentFails--;
4760
- if (s0 === peg$FAILED) {
4761
- s1 = peg$FAILED;
4762
- if (peg$silentFails === 0) { peg$fail(peg$e88); }
4763
- }
4764
-
4765
- return s0;
4766
- }
4767
-
4768
- function peg$parseprotocolExpression() {
4769
- var s0, s1, s2, s3, s4;
4770
-
4771
- s0 = peg$currPos;
4772
- s1 = peg$parsenamespace();
4773
- if (s1 !== peg$FAILED) {
4774
- if (input.substr(peg$currPos, 2) === peg$c1) {
4775
- s2 = peg$c1;
4776
- peg$currPos += 2;
4777
- } else {
4778
- s2 = peg$FAILED;
4779
- if (peg$silentFails === 0) { peg$fail(peg$e2); }
4780
- }
4781
- if (s2 !== peg$FAILED) {
4782
- s3 = peg$parsehost();
4783
- if (s3 === peg$FAILED) {
4784
- s3 = peg$parseslash();
4785
- }
4786
- if (s3 !== peg$FAILED) {
4787
- s4 = peg$parsepath();
4788
- if (s4 === peg$FAILED) {
4789
- s4 = null;
4790
- }
4791
- peg$savedPos = s0;
4792
- s0 = peg$f81(s1, s3, s4);
4793
- } else {
4794
- peg$currPos = s0;
4795
- s0 = peg$FAILED;
4796
- }
4797
- } else {
4798
- peg$currPos = s0;
4799
- s0 = peg$FAILED;
4800
- }
4801
- } else {
4802
- peg$currPos = s0;
4803
- s0 = peg$FAILED;
4804
- }
4805
- if (s0 === peg$FAILED) {
4806
- s0 = peg$parsenewExpression();
4807
- if (s0 === peg$FAILED) {
4808
- s0 = peg$parseprimary();
4809
- }
4810
- }
4811
-
4812
- return s0;
4813
- }
4814
-
4815
- function peg$parsequalifiedReference() {
4816
- var s0, s1, s2;
4817
-
4818
- s0 = peg$currPos;
4819
- s1 = peg$parsenamespace();
4820
- if (s1 !== peg$FAILED) {
4821
- s2 = peg$parsescopeReference();
4822
- if (s2 !== peg$FAILED) {
4823
- peg$savedPos = s0;
4824
- s0 = peg$f82(s1, s2);
4825
- } else {
4826
- peg$currPos = s0;
4827
- s0 = peg$FAILED;
4828
- }
4829
- } else {
4830
- peg$currPos = s0;
4831
- s0 = peg$FAILED;
4832
- }
4833
-
4834
- return s0;
4835
- }
4836
-
4837
- function peg$parseregexFlags() {
4838
- var s0, s1, s2;
4839
-
4840
- s0 = peg$currPos;
4841
- s1 = [];
4842
- s2 = input.charAt(peg$currPos);
4843
- if (peg$r8.test(s2)) {
4844
- peg$currPos++;
4845
- } else {
4846
- s2 = peg$FAILED;
4847
- if (peg$silentFails === 0) { peg$fail(peg$e89); }
4302
+ peg$currPos = s0;
4303
+ s0 = peg$FAILED;
4848
4304
  }
4849
- while (s2 !== peg$FAILED) {
4850
- s1.push(s2);
4851
- s2 = input.charAt(peg$currPos);
4852
- if (peg$r8.test(s2)) {
4853
- peg$currPos++;
4854
- } else {
4855
- s2 = peg$FAILED;
4856
- if (peg$silentFails === 0) { peg$fail(peg$e89); }
4857
- }
4305
+ peg$silentFails--;
4306
+ if (s0 === peg$FAILED) {
4307
+ s1 = peg$FAILED;
4308
+ if (peg$silentFails === 0) { peg$fail(peg$e82); }
4858
4309
  }
4859
- peg$savedPos = s0;
4860
- s1 = peg$f83(s1);
4861
- s0 = s1;
4862
4310
 
4863
4311
  return s0;
4864
4312
  }
4865
4313
 
4866
- function peg$parseregexLiteral() {
4314
+ function peg$parseprotocolExpression() {
4867
4315
  var s0, s1, s2, s3, s4;
4868
4316
 
4869
4317
  s0 = peg$currPos;
4870
- if (input.charCodeAt(peg$currPos) === 47) {
4871
- s1 = peg$c3;
4872
- peg$currPos++;
4873
- } else {
4874
- s1 = peg$FAILED;
4875
- if (peg$silentFails === 0) { peg$fail(peg$e4); }
4876
- }
4318
+ s1 = peg$parsenamespace();
4877
4319
  if (s1 !== peg$FAILED) {
4878
- s2 = [];
4879
- s3 = peg$parseregexLiteralChar();
4880
- while (s3 !== peg$FAILED) {
4881
- s2.push(s3);
4882
- s3 = peg$parseregexLiteralChar();
4883
- }
4884
- if (input.charCodeAt(peg$currPos) === 47) {
4885
- s3 = peg$c3;
4886
- peg$currPos++;
4320
+ if (input.substr(peg$currPos, 2) === peg$c49) {
4321
+ s2 = peg$c49;
4322
+ peg$currPos += 2;
4887
4323
  } else {
4888
- s3 = peg$FAILED;
4889
- if (peg$silentFails === 0) { peg$fail(peg$e4); }
4324
+ s2 = peg$FAILED;
4325
+ if (peg$silentFails === 0) { peg$fail(peg$e83); }
4890
4326
  }
4891
- if (s3 !== peg$FAILED) {
4892
- s4 = peg$parseregexFlags();
4893
- peg$savedPos = s0;
4894
- s0 = peg$f84(s2, s4);
4327
+ if (s2 !== peg$FAILED) {
4328
+ s3 = peg$parsehost();
4329
+ if (s3 === peg$FAILED) {
4330
+ s3 = peg$parseslash();
4331
+ }
4332
+ if (s3 !== peg$FAILED) {
4333
+ s4 = peg$parsepath();
4334
+ if (s4 === peg$FAILED) {
4335
+ s4 = null;
4336
+ }
4337
+ peg$savedPos = s0;
4338
+ s0 = peg$f72(s1, s3, s4);
4339
+ } else {
4340
+ peg$currPos = s0;
4341
+ s0 = peg$FAILED;
4342
+ }
4895
4343
  } else {
4896
4344
  peg$currPos = s0;
4897
4345
  s0 = peg$FAILED;
@@ -4900,22 +4348,30 @@ function peg$parse(input, options) {
4900
4348
  peg$currPos = s0;
4901
4349
  s0 = peg$FAILED;
4902
4350
  }
4351
+ if (s0 === peg$FAILED) {
4352
+ s0 = peg$parseprimary();
4353
+ }
4903
4354
 
4904
4355
  return s0;
4905
4356
  }
4906
4357
 
4907
- function peg$parseregexLiteralChar() {
4908
- var s0;
4358
+ function peg$parsequalifiedReference() {
4359
+ var s0, s1, s2;
4909
4360
 
4910
- s0 = input.charAt(peg$currPos);
4911
- if (peg$r9.test(s0)) {
4912
- peg$currPos++;
4361
+ s0 = peg$currPos;
4362
+ s1 = peg$parsenamespace();
4363
+ if (s1 !== peg$FAILED) {
4364
+ s2 = peg$parsescopeReference();
4365
+ if (s2 !== peg$FAILED) {
4366
+ peg$savedPos = s0;
4367
+ s0 = peg$f73(s1, s2);
4368
+ } else {
4369
+ peg$currPos = s0;
4370
+ s0 = peg$FAILED;
4371
+ }
4913
4372
  } else {
4373
+ peg$currPos = s0;
4914
4374
  s0 = peg$FAILED;
4915
- if (peg$silentFails === 0) { peg$fail(peg$e90); }
4916
- }
4917
- if (s0 === peg$FAILED) {
4918
- s0 = peg$parseescapedChar();
4919
4375
  }
4920
4376
 
4921
4377
  return s0;
@@ -4964,7 +4420,7 @@ function peg$parse(input, options) {
4964
4420
  }
4965
4421
  }
4966
4422
  peg$savedPos = s0;
4967
- s0 = peg$f85(s1, s2);
4423
+ s0 = peg$f74(s1, s2);
4968
4424
  } else {
4969
4425
  peg$currPos = s0;
4970
4426
  s0 = peg$FAILED;
@@ -4976,36 +4432,36 @@ function peg$parse(input, options) {
4976
4432
  function peg$parserelationalOperator() {
4977
4433
  var s0;
4978
4434
 
4979
- if (input.substr(peg$currPos, 2) === peg$c53) {
4980
- s0 = peg$c53;
4435
+ if (input.substr(peg$currPos, 2) === peg$c50) {
4436
+ s0 = peg$c50;
4981
4437
  peg$currPos += 2;
4982
4438
  } else {
4983
4439
  s0 = peg$FAILED;
4984
- if (peg$silentFails === 0) { peg$fail(peg$e91); }
4440
+ if (peg$silentFails === 0) { peg$fail(peg$e84); }
4985
4441
  }
4986
4442
  if (s0 === peg$FAILED) {
4987
4443
  if (input.charCodeAt(peg$currPos) === 60) {
4988
- s0 = peg$c0;
4444
+ s0 = peg$c51;
4989
4445
  peg$currPos++;
4990
4446
  } else {
4991
4447
  s0 = peg$FAILED;
4992
- if (peg$silentFails === 0) { peg$fail(peg$e1); }
4448
+ if (peg$silentFails === 0) { peg$fail(peg$e85); }
4993
4449
  }
4994
4450
  if (s0 === peg$FAILED) {
4995
- if (input.substr(peg$currPos, 2) === peg$c54) {
4996
- s0 = peg$c54;
4451
+ if (input.substr(peg$currPos, 2) === peg$c52) {
4452
+ s0 = peg$c52;
4997
4453
  peg$currPos += 2;
4998
4454
  } else {
4999
4455
  s0 = peg$FAILED;
5000
- if (peg$silentFails === 0) { peg$fail(peg$e92); }
4456
+ if (peg$silentFails === 0) { peg$fail(peg$e86); }
5001
4457
  }
5002
4458
  if (s0 === peg$FAILED) {
5003
4459
  if (input.charCodeAt(peg$currPos) === 62) {
5004
- s0 = peg$c2;
4460
+ s0 = peg$c37;
5005
4461
  peg$currPos++;
5006
4462
  } else {
5007
4463
  s0 = peg$FAILED;
5008
- if (peg$silentFails === 0) { peg$fail(peg$e3); }
4464
+ if (peg$silentFails === 0) { peg$fail(peg$e53); }
5009
4465
  }
5010
4466
  }
5011
4467
  }
@@ -5019,17 +4475,17 @@ function peg$parse(input, options) {
5019
4475
 
5020
4476
  s0 = peg$currPos;
5021
4477
  if (input.charCodeAt(peg$currPos) === 47) {
5022
- s1 = peg$c3;
4478
+ s1 = peg$c48;
5023
4479
  peg$currPos++;
5024
4480
  } else {
5025
4481
  s1 = peg$FAILED;
5026
- if (peg$silentFails === 0) { peg$fail(peg$e4); }
4482
+ if (peg$silentFails === 0) { peg$fail(peg$e78); }
5027
4483
  }
5028
4484
  if (s1 !== peg$FAILED) {
5029
4485
  s2 = peg$parsepathKey();
5030
4486
  if (s2 !== peg$FAILED) {
5031
4487
  peg$savedPos = s0;
5032
- s0 = peg$f86(s2);
4488
+ s0 = peg$f75(s2);
5033
4489
  } else {
5034
4490
  peg$currPos = s0;
5035
4491
  s0 = peg$FAILED;
@@ -5041,21 +4497,21 @@ function peg$parse(input, options) {
5041
4497
  if (s0 === peg$FAILED) {
5042
4498
  s0 = peg$currPos;
5043
4499
  if (input.charCodeAt(peg$currPos) === 47) {
5044
- s1 = peg$c3;
4500
+ s1 = peg$c48;
5045
4501
  peg$currPos++;
5046
4502
  } else {
5047
4503
  s1 = peg$FAILED;
5048
- if (peg$silentFails === 0) { peg$fail(peg$e4); }
4504
+ if (peg$silentFails === 0) { peg$fail(peg$e78); }
5049
4505
  }
5050
4506
  if (s1 !== peg$FAILED) {
5051
4507
  s2 = peg$currPos;
5052
4508
  peg$silentFails++;
5053
4509
  if (input.charCodeAt(peg$currPos) === 47) {
5054
- s3 = peg$c3;
4510
+ s3 = peg$c48;
5055
4511
  peg$currPos++;
5056
4512
  } else {
5057
4513
  s3 = peg$FAILED;
5058
- if (peg$silentFails === 0) { peg$fail(peg$e4); }
4514
+ if (peg$silentFails === 0) { peg$fail(peg$e78); }
5059
4515
  }
5060
4516
  peg$silentFails--;
5061
4517
  if (s3 === peg$FAILED) {
@@ -5066,7 +4522,7 @@ function peg$parse(input, options) {
5066
4522
  }
5067
4523
  if (s2 !== peg$FAILED) {
5068
4524
  peg$savedPos = s0;
5069
- s0 = peg$f87();
4525
+ s0 = peg$f76();
5070
4526
  } else {
5071
4527
  peg$currPos = s0;
5072
4528
  s0 = peg$FAILED;
@@ -5092,7 +4548,7 @@ function peg$parse(input, options) {
5092
4548
  s2 = null;
5093
4549
  }
5094
4550
  peg$savedPos = s0;
5095
- s0 = peg$f88(s1, s2);
4551
+ s0 = peg$f77(s1, s2);
5096
4552
  } else {
5097
4553
  peg$currPos = s0;
5098
4554
  s0 = peg$FAILED;
@@ -5100,7 +4556,7 @@ function peg$parse(input, options) {
5100
4556
  peg$silentFails--;
5101
4557
  if (s0 === peg$FAILED) {
5102
4558
  s1 = peg$FAILED;
5103
- if (peg$silentFails === 0) { peg$fail(peg$e93); }
4559
+ if (peg$silentFails === 0) { peg$fail(peg$e87); }
5104
4560
  }
5105
4561
 
5106
4562
  return s0;
@@ -5112,11 +4568,11 @@ function peg$parse(input, options) {
5112
4568
  s0 = peg$currPos;
5113
4569
  s1 = peg$parse__();
5114
4570
  if (input.charCodeAt(peg$currPos) === 44) {
5115
- s2 = peg$c12;
4571
+ s2 = peg$c7;
5116
4572
  peg$currPos++;
5117
4573
  } else {
5118
4574
  s2 = peg$FAILED;
5119
- if (peg$silentFails === 0) { peg$fail(peg$e17); }
4575
+ if (peg$silentFails === 0) { peg$fail(peg$e11); }
5120
4576
  }
5121
4577
  if (s2 !== peg$FAILED) {
5122
4578
  s3 = peg$parse__();
@@ -5127,20 +4583,7 @@ function peg$parse(input, options) {
5127
4583
  s0 = peg$FAILED;
5128
4584
  }
5129
4585
  if (s0 === peg$FAILED) {
5130
- s0 = peg$currPos;
5131
- s1 = peg$parseshellMode();
5132
- if (s1 !== peg$FAILED) {
5133
- s2 = peg$parsewhitespaceWithNewLine();
5134
- if (s2 !== peg$FAILED) {
5135
- s0 = s2;
5136
- } else {
5137
- peg$currPos = s0;
5138
- s0 = peg$FAILED;
5139
- }
5140
- } else {
5141
- peg$currPos = s0;
5142
- s0 = peg$FAILED;
5143
- }
4586
+ s0 = peg$parsewhitespaceWithNewLine();
5144
4587
  }
5145
4588
 
5146
4589
  return s0;
@@ -5150,34 +4593,34 @@ function peg$parse(input, options) {
5150
4593
  var s0, s1, s2, s3;
5151
4594
 
5152
4595
  s0 = peg$currPos;
5153
- if (input.substr(peg$currPos, 2) === peg$c55) {
5154
- s1 = peg$c55;
4596
+ if (input.substr(peg$currPos, 2) === peg$c53) {
4597
+ s1 = peg$c53;
5155
4598
  peg$currPos += 2;
5156
4599
  } else {
5157
4600
  s1 = peg$FAILED;
5158
- if (peg$silentFails === 0) { peg$fail(peg$e94); }
4601
+ if (peg$silentFails === 0) { peg$fail(peg$e88); }
5159
4602
  }
5160
4603
  if (s1 !== peg$FAILED) {
5161
4604
  s2 = [];
5162
4605
  s3 = input.charAt(peg$currPos);
5163
- if (peg$r10.test(s3)) {
4606
+ if (peg$r7.test(s3)) {
5164
4607
  peg$currPos++;
5165
4608
  } else {
5166
4609
  s3 = peg$FAILED;
5167
- if (peg$silentFails === 0) { peg$fail(peg$e95); }
4610
+ if (peg$silentFails === 0) { peg$fail(peg$e89); }
5168
4611
  }
5169
4612
  while (s3 !== peg$FAILED) {
5170
4613
  s2.push(s3);
5171
4614
  s3 = input.charAt(peg$currPos);
5172
- if (peg$r10.test(s3)) {
4615
+ if (peg$r7.test(s3)) {
5173
4616
  peg$currPos++;
5174
4617
  } else {
5175
4618
  s3 = peg$FAILED;
5176
- if (peg$silentFails === 0) { peg$fail(peg$e95); }
4619
+ if (peg$silentFails === 0) { peg$fail(peg$e89); }
5177
4620
  }
5178
4621
  }
5179
4622
  peg$savedPos = s0;
5180
- s0 = peg$f89();
4623
+ s0 = peg$f78();
5181
4624
  } else {
5182
4625
  peg$currPos = s0;
5183
4626
  s0 = peg$FAILED;
@@ -5186,20 +4629,6 @@ function peg$parse(input, options) {
5186
4629
  return s0;
5187
4630
  }
5188
4631
 
5189
- function peg$parseshellMode() {
5190
- var s0;
5191
-
5192
- peg$savedPos = peg$currPos;
5193
- s0 = peg$f90();
5194
- if (s0) {
5195
- s0 = undefined;
5196
- } else {
5197
- s0 = peg$FAILED;
5198
- }
5199
-
5200
- return s0;
5201
- }
5202
-
5203
4632
  function peg$parseshiftExpression() {
5204
4633
  var s0, s1, s2, s3, s4, s5, s6, s7;
5205
4634
 
@@ -5243,7 +4672,7 @@ function peg$parse(input, options) {
5243
4672
  }
5244
4673
  }
5245
4674
  peg$savedPos = s0;
5246
- s0 = peg$f91(s1, s2);
4675
+ s0 = peg$f79(s1, s2);
5247
4676
  } else {
5248
4677
  peg$currPos = s0;
5249
4678
  s0 = peg$FAILED;
@@ -5255,28 +4684,28 @@ function peg$parse(input, options) {
5255
4684
  function peg$parseshiftOperator() {
5256
4685
  var s0;
5257
4686
 
5258
- if (input.substr(peg$currPos, 2) === peg$c56) {
5259
- s0 = peg$c56;
4687
+ if (input.substr(peg$currPos, 2) === peg$c54) {
4688
+ s0 = peg$c54;
5260
4689
  peg$currPos += 2;
5261
4690
  } else {
5262
4691
  s0 = peg$FAILED;
5263
- if (peg$silentFails === 0) { peg$fail(peg$e96); }
4692
+ if (peg$silentFails === 0) { peg$fail(peg$e90); }
5264
4693
  }
5265
4694
  if (s0 === peg$FAILED) {
5266
- if (input.substr(peg$currPos, 3) === peg$c57) {
5267
- s0 = peg$c57;
4695
+ if (input.substr(peg$currPos, 3) === peg$c55) {
4696
+ s0 = peg$c55;
5268
4697
  peg$currPos += 3;
5269
4698
  } else {
5270
4699
  s0 = peg$FAILED;
5271
- if (peg$silentFails === 0) { peg$fail(peg$e97); }
4700
+ if (peg$silentFails === 0) { peg$fail(peg$e91); }
5272
4701
  }
5273
4702
  if (s0 === peg$FAILED) {
5274
- if (input.substr(peg$currPos, 2) === peg$c58) {
5275
- s0 = peg$c58;
4703
+ if (input.substr(peg$currPos, 2) === peg$c56) {
4704
+ s0 = peg$c56;
5276
4705
  peg$currPos += 2;
5277
4706
  } else {
5278
4707
  s0 = peg$FAILED;
5279
- if (peg$silentFails === 0) { peg$fail(peg$e98); }
4708
+ if (peg$silentFails === 0) { peg$fail(peg$e92); }
5280
4709
  }
5281
4710
  }
5282
4711
  }
@@ -5285,46 +4714,40 @@ function peg$parse(input, options) {
5285
4714
  }
5286
4715
 
5287
4716
  function peg$parseshorthandFunction() {
5288
- var s0, s1, s2, s3, s4, s5;
4717
+ var s0, s1, s2, s3, s4;
5289
4718
 
5290
4719
  peg$silentFails++;
5291
4720
  s0 = peg$currPos;
5292
- 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
+ }
5293
4728
  if (s1 !== peg$FAILED) {
4729
+ s2 = peg$currPos;
4730
+ peg$silentFails++;
5294
4731
  if (input.charCodeAt(peg$currPos) === 61) {
5295
- s2 = peg$c51;
4732
+ s3 = peg$c47;
5296
4733
  peg$currPos++;
5297
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;
5298
4743
  s2 = peg$FAILED;
5299
- if (peg$silentFails === 0) { peg$fail(peg$e80); }
5300
4744
  }
5301
4745
  if (s2 !== peg$FAILED) {
5302
- s3 = peg$currPos;
5303
- peg$silentFails++;
5304
- if (input.charCodeAt(peg$currPos) === 61) {
5305
- s4 = peg$c51;
5306
- peg$currPos++;
5307
- } else {
5308
- s4 = peg$FAILED;
5309
- if (peg$silentFails === 0) { peg$fail(peg$e80); }
5310
- }
5311
- peg$silentFails--;
5312
- if (s4 === peg$FAILED) {
5313
- s3 = undefined;
5314
- } else {
5315
- peg$currPos = s3;
5316
- s3 = peg$FAILED;
5317
- }
5318
- if (s3 !== peg$FAILED) {
5319
- s4 = peg$parse__();
5320
- s5 = peg$parseimplicitParenthesesCallExpression();
5321
- if (s5 !== peg$FAILED) {
5322
- peg$savedPos = s0;
5323
- s0 = peg$f92(s5);
5324
- } else {
5325
- peg$currPos = s0;
5326
- s0 = peg$FAILED;
5327
- }
4746
+ s3 = peg$parse__();
4747
+ s4 = peg$parseimplicitParenthesesCallExpression();
4748
+ if (s4 !== peg$FAILED) {
4749
+ peg$savedPos = s0;
4750
+ s0 = peg$f80(s4);
5328
4751
  } else {
5329
4752
  peg$currPos = s0;
5330
4753
  s0 = peg$FAILED;
@@ -5343,7 +4766,7 @@ function peg$parse(input, options) {
5343
4766
  peg$silentFails--;
5344
4767
  if (s0 === peg$FAILED) {
5345
4768
  s1 = peg$FAILED;
5346
- if (peg$silentFails === 0) { peg$fail(peg$e99); }
4769
+ if (peg$silentFails === 0) { peg$fail(peg$e93); }
5347
4770
  }
5348
4771
 
5349
4772
  return s0;
@@ -5353,19 +4776,19 @@ function peg$parse(input, options) {
5353
4776
  var s0;
5354
4777
 
5355
4778
  if (input.charCodeAt(peg$currPos) === 8594) {
5356
- s0 = peg$c59;
4779
+ s0 = peg$c57;
5357
4780
  peg$currPos++;
5358
4781
  } else {
5359
4782
  s0 = peg$FAILED;
5360
- if (peg$silentFails === 0) { peg$fail(peg$e100); }
4783
+ if (peg$silentFails === 0) { peg$fail(peg$e94); }
5361
4784
  }
5362
4785
  if (s0 === peg$FAILED) {
5363
- if (input.substr(peg$currPos, 2) === peg$c60) {
5364
- s0 = peg$c60;
4786
+ if (input.substr(peg$currPos, 2) === peg$c58) {
4787
+ s0 = peg$c58;
5365
4788
  peg$currPos += 2;
5366
4789
  } else {
5367
4790
  s0 = peg$FAILED;
5368
- if (peg$silentFails === 0) { peg$fail(peg$e101); }
4791
+ if (peg$silentFails === 0) { peg$fail(peg$e95); }
5369
4792
  }
5370
4793
  }
5371
4794
 
@@ -5376,34 +4799,34 @@ function peg$parse(input, options) {
5376
4799
  var s0, s1, s2, s3;
5377
4800
 
5378
4801
  s0 = peg$currPos;
5379
- if (input.substr(peg$currPos, 2) === peg$c1) {
5380
- s1 = peg$c1;
4802
+ if (input.substr(peg$currPos, 2) === peg$c49) {
4803
+ s1 = peg$c49;
5381
4804
  peg$currPos += 2;
5382
4805
  } else {
5383
4806
  s1 = peg$FAILED;
5384
- if (peg$silentFails === 0) { peg$fail(peg$e2); }
4807
+ if (peg$silentFails === 0) { peg$fail(peg$e83); }
5385
4808
  }
5386
4809
  if (s1 !== peg$FAILED) {
5387
4810
  s2 = [];
5388
4811
  s3 = input.charAt(peg$currPos);
5389
- if (peg$r10.test(s3)) {
4812
+ if (peg$r7.test(s3)) {
5390
4813
  peg$currPos++;
5391
4814
  } else {
5392
4815
  s3 = peg$FAILED;
5393
- if (peg$silentFails === 0) { peg$fail(peg$e95); }
4816
+ if (peg$silentFails === 0) { peg$fail(peg$e89); }
5394
4817
  }
5395
4818
  while (s3 !== peg$FAILED) {
5396
4819
  s2.push(s3);
5397
4820
  s3 = input.charAt(peg$currPos);
5398
- if (peg$r10.test(s3)) {
4821
+ if (peg$r7.test(s3)) {
5399
4822
  peg$currPos++;
5400
4823
  } else {
5401
4824
  s3 = peg$FAILED;
5402
- if (peg$silentFails === 0) { peg$fail(peg$e95); }
4825
+ if (peg$silentFails === 0) { peg$fail(peg$e89); }
5403
4826
  }
5404
4827
  }
5405
4828
  peg$savedPos = s0;
5406
- s0 = peg$f93();
4829
+ s0 = peg$f81();
5407
4830
  } else {
5408
4831
  peg$currPos = s0;
5409
4832
  s0 = peg$FAILED;
@@ -5418,11 +4841,11 @@ function peg$parse(input, options) {
5418
4841
  peg$silentFails++;
5419
4842
  s0 = peg$currPos;
5420
4843
  if (input.charCodeAt(peg$currPos) === 39) {
5421
- s1 = peg$c34;
4844
+ s1 = peg$c30;
5422
4845
  peg$currPos++;
5423
4846
  } else {
5424
4847
  s1 = peg$FAILED;
5425
- if (peg$silentFails === 0) { peg$fail(peg$e44); }
4848
+ if (peg$silentFails === 0) { peg$fail(peg$e39); }
5426
4849
  }
5427
4850
  if (s1 !== peg$FAILED) {
5428
4851
  s2 = [];
@@ -5434,7 +4857,7 @@ function peg$parse(input, options) {
5434
4857
  s3 = peg$parseexpectSingleQuote();
5435
4858
  if (s3 !== peg$FAILED) {
5436
4859
  peg$savedPos = s0;
5437
- s0 = peg$f94(s2);
4860
+ s0 = peg$f82(s2);
5438
4861
  } else {
5439
4862
  peg$currPos = s0;
5440
4863
  s0 = peg$FAILED;
@@ -5446,7 +4869,7 @@ function peg$parse(input, options) {
5446
4869
  peg$silentFails--;
5447
4870
  if (s0 === peg$FAILED) {
5448
4871
  s1 = peg$FAILED;
5449
- if (peg$silentFails === 0) { peg$fail(peg$e102); }
4872
+ if (peg$silentFails === 0) { peg$fail(peg$e96); }
5450
4873
  }
5451
4874
 
5452
4875
  return s0;
@@ -5459,11 +4882,11 @@ function peg$parse(input, options) {
5459
4882
  s1 = peg$currPos;
5460
4883
  peg$silentFails++;
5461
4884
  if (input.charCodeAt(peg$currPos) === 39) {
5462
- s2 = peg$c34;
4885
+ s2 = peg$c30;
5463
4886
  peg$currPos++;
5464
4887
  } else {
5465
4888
  s2 = peg$FAILED;
5466
- if (peg$silentFails === 0) { peg$fail(peg$e44); }
4889
+ if (peg$silentFails === 0) { peg$fail(peg$e39); }
5467
4890
  }
5468
4891
  if (s2 === peg$FAILED) {
5469
4892
  s2 = peg$parsenewLine();
@@ -5498,7 +4921,7 @@ function peg$parse(input, options) {
5498
4921
  s1 = peg$parseslashFollows();
5499
4922
  if (s1 !== peg$FAILED) {
5500
4923
  peg$savedPos = s0;
5501
- s1 = peg$f95();
4924
+ s1 = peg$f83();
5502
4925
  }
5503
4926
  s0 = s1;
5504
4927
 
@@ -5512,11 +4935,11 @@ function peg$parse(input, options) {
5512
4935
  s1 = peg$currPos;
5513
4936
  peg$silentFails++;
5514
4937
  if (input.charCodeAt(peg$currPos) === 47) {
5515
- s2 = peg$c3;
4938
+ s2 = peg$c48;
5516
4939
  peg$currPos++;
5517
4940
  } else {
5518
4941
  s2 = peg$FAILED;
5519
- if (peg$silentFails === 0) { peg$fail(peg$e4); }
4942
+ if (peg$silentFails === 0) { peg$fail(peg$e78); }
5520
4943
  }
5521
4944
  peg$silentFails--;
5522
4945
  if (s2 !== peg$FAILED) {
@@ -5527,7 +4950,7 @@ function peg$parse(input, options) {
5527
4950
  }
5528
4951
  if (s1 !== peg$FAILED) {
5529
4952
  peg$savedPos = s0;
5530
- s1 = peg$f96();
4953
+ s1 = peg$f84();
5531
4954
  }
5532
4955
  s0 = s1;
5533
4956
 
@@ -5544,7 +4967,7 @@ function peg$parse(input, options) {
5544
4967
  s3 = peg$parsepipelineExpression();
5545
4968
  if (s3 !== peg$FAILED) {
5546
4969
  peg$savedPos = s0;
5547
- s0 = peg$f97(s3);
4970
+ s0 = peg$f85(s3);
5548
4971
  } else {
5549
4972
  peg$currPos = s0;
5550
4973
  s0 = peg$FAILED;
@@ -5558,33 +4981,20 @@ function peg$parse(input, options) {
5558
4981
  }
5559
4982
 
5560
4983
  function peg$parsestringLiteral() {
5561
- var s0, s1, s2;
4984
+ var s0, s1;
5562
4985
 
5563
4986
  peg$silentFails++;
5564
4987
  s0 = peg$parsedoubleQuoteString();
5565
4988
  if (s0 === peg$FAILED) {
5566
4989
  s0 = peg$parsesingleQuoteString();
5567
4990
  if (s0 === peg$FAILED) {
5568
- s0 = peg$currPos;
5569
- s1 = peg$parseshellMode();
5570
- if (s1 !== peg$FAILED) {
5571
- s2 = peg$parseguillemetString();
5572
- if (s2 !== peg$FAILED) {
5573
- s0 = s2;
5574
- } else {
5575
- peg$currPos = s0;
5576
- s0 = peg$FAILED;
5577
- }
5578
- } else {
5579
- peg$currPos = s0;
5580
- s0 = peg$FAILED;
5581
- }
4991
+ s0 = peg$parseguillemetString();
5582
4992
  }
5583
4993
  }
5584
4994
  peg$silentFails--;
5585
4995
  if (s0 === peg$FAILED) {
5586
4996
  s1 = peg$FAILED;
5587
- if (peg$silentFails === 0) { peg$fail(peg$e103); }
4997
+ if (peg$silentFails === 0) { peg$fail(peg$e97); }
5588
4998
  }
5589
4999
 
5590
5000
  return s0;
@@ -5621,10 +5031,10 @@ function peg$parse(input, options) {
5621
5031
  }
5622
5032
  }
5623
5033
  peg$savedPos = s0;
5624
- s0 = peg$f98(s1, s2);
5034
+ s0 = peg$f86(s1, s2);
5625
5035
  peg$silentFails--;
5626
5036
  s1 = peg$FAILED;
5627
- if (peg$silentFails === 0) { peg$fail(peg$e104); }
5037
+ if (peg$silentFails === 0) { peg$fail(peg$e98); }
5628
5038
 
5629
5039
  return s0;
5630
5040
  }
@@ -5635,12 +5045,12 @@ function peg$parse(input, options) {
5635
5045
  s0 = peg$currPos;
5636
5046
  s1 = peg$currPos;
5637
5047
  peg$silentFails++;
5638
- if (input.substr(peg$currPos, 2) === peg$c61) {
5639
- s2 = peg$c61;
5048
+ if (input.substr(peg$currPos, 2) === peg$c59) {
5049
+ s2 = peg$c59;
5640
5050
  peg$currPos += 2;
5641
5051
  } else {
5642
5052
  s2 = peg$FAILED;
5643
- if (peg$silentFails === 0) { peg$fail(peg$e105); }
5053
+ if (peg$silentFails === 0) { peg$fail(peg$e99); }
5644
5054
  }
5645
5055
  peg$silentFails--;
5646
5056
  if (s2 === peg$FAILED) {
@@ -5677,11 +5087,11 @@ function peg$parse(input, options) {
5677
5087
  s2 = peg$parsetemplateBodyChar();
5678
5088
  }
5679
5089
  peg$savedPos = s0;
5680
- s1 = peg$f99(s1);
5090
+ s1 = peg$f87(s1);
5681
5091
  s0 = s1;
5682
5092
  peg$silentFails--;
5683
5093
  s1 = peg$FAILED;
5684
- if (peg$silentFails === 0) { peg$fail(peg$e106); }
5094
+ if (peg$silentFails === 0) { peg$fail(peg$e100); }
5685
5095
 
5686
5096
  return s0;
5687
5097
  }
@@ -5696,7 +5106,7 @@ function peg$parse(input, options) {
5696
5106
  s2 = peg$parse__();
5697
5107
  s3 = peg$parsetemplateBody();
5698
5108
  peg$savedPos = s0;
5699
- s0 = peg$f100(s1, s3);
5109
+ s0 = peg$f88(s1, s3);
5700
5110
  } else {
5701
5111
  peg$currPos = s0;
5702
5112
  s0 = peg$FAILED;
@@ -5709,12 +5119,12 @@ function peg$parse(input, options) {
5709
5119
  }
5710
5120
  s2 = peg$parsetemplateBody();
5711
5121
  peg$savedPos = s0;
5712
- s0 = peg$f101(s1, s2);
5122
+ s0 = peg$f89(s1, s2);
5713
5123
  }
5714
5124
  peg$silentFails--;
5715
5125
  if (s0 === peg$FAILED) {
5716
5126
  s1 = peg$FAILED;
5717
- if (peg$silentFails === 0) { peg$fail(peg$e107); }
5127
+ if (peg$silentFails === 0) { peg$fail(peg$e101); }
5718
5128
  }
5719
5129
 
5720
5130
  return s0;
@@ -5726,11 +5136,11 @@ function peg$parse(input, options) {
5726
5136
  peg$silentFails++;
5727
5137
  s0 = peg$currPos;
5728
5138
  if (input.charCodeAt(peg$currPos) === 96) {
5729
- s1 = peg$c31;
5139
+ s1 = peg$c27;
5730
5140
  peg$currPos++;
5731
5141
  } else {
5732
5142
  s1 = peg$FAILED;
5733
- if (peg$silentFails === 0) { peg$fail(peg$e41); }
5143
+ if (peg$silentFails === 0) { peg$fail(peg$e36); }
5734
5144
  }
5735
5145
  if (s1 !== peg$FAILED) {
5736
5146
  s2 = peg$parsetemplateLiteralText();
@@ -5761,7 +5171,7 @@ function peg$parse(input, options) {
5761
5171
  s4 = peg$parseexpectBacktick();
5762
5172
  if (s4 !== peg$FAILED) {
5763
5173
  peg$savedPos = s0;
5764
- s0 = peg$f102(s2, s3);
5174
+ s0 = peg$f90(s2, s3);
5765
5175
  } else {
5766
5176
  peg$currPos = s0;
5767
5177
  s0 = peg$FAILED;
@@ -5773,7 +5183,7 @@ function peg$parse(input, options) {
5773
5183
  peg$silentFails--;
5774
5184
  if (s0 === peg$FAILED) {
5775
5185
  s1 = peg$FAILED;
5776
- if (peg$silentFails === 0) { peg$fail(peg$e108); }
5186
+ if (peg$silentFails === 0) { peg$fail(peg$e102); }
5777
5187
  }
5778
5188
 
5779
5189
  return s0;
@@ -5786,19 +5196,19 @@ function peg$parse(input, options) {
5786
5196
  s1 = peg$currPos;
5787
5197
  peg$silentFails++;
5788
5198
  if (input.charCodeAt(peg$currPos) === 96) {
5789
- s2 = peg$c31;
5199
+ s2 = peg$c27;
5790
5200
  peg$currPos++;
5791
5201
  } else {
5792
5202
  s2 = peg$FAILED;
5793
- if (peg$silentFails === 0) { peg$fail(peg$e41); }
5203
+ if (peg$silentFails === 0) { peg$fail(peg$e36); }
5794
5204
  }
5795
5205
  if (s2 === peg$FAILED) {
5796
- if (input.substr(peg$currPos, 2) === peg$c61) {
5797
- s2 = peg$c61;
5206
+ if (input.substr(peg$currPos, 2) === peg$c59) {
5207
+ s2 = peg$c59;
5798
5208
  peg$currPos += 2;
5799
5209
  } else {
5800
5210
  s2 = peg$FAILED;
5801
- if (peg$silentFails === 0) { peg$fail(peg$e105); }
5211
+ if (peg$silentFails === 0) { peg$fail(peg$e99); }
5802
5212
  }
5803
5213
  }
5804
5214
  peg$silentFails--;
@@ -5835,7 +5245,7 @@ function peg$parse(input, options) {
5835
5245
  s2 = peg$parsetemplateLiteralChar();
5836
5246
  }
5837
5247
  peg$savedPos = s0;
5838
- s1 = peg$f103(s1);
5248
+ s1 = peg$f91(s1);
5839
5249
  s0 = s1;
5840
5250
 
5841
5251
  return s0;
@@ -5846,26 +5256,26 @@ function peg$parse(input, options) {
5846
5256
 
5847
5257
  peg$silentFails++;
5848
5258
  s0 = peg$currPos;
5849
- if (input.substr(peg$currPos, 2) === peg$c61) {
5850
- s1 = peg$c61;
5259
+ if (input.substr(peg$currPos, 2) === peg$c59) {
5260
+ s1 = peg$c59;
5851
5261
  peg$currPos += 2;
5852
5262
  } else {
5853
5263
  s1 = peg$FAILED;
5854
- if (peg$silentFails === 0) { peg$fail(peg$e105); }
5264
+ if (peg$silentFails === 0) { peg$fail(peg$e99); }
5855
5265
  }
5856
5266
  if (s1 !== peg$FAILED) {
5857
5267
  s2 = peg$parseexpectExpression();
5858
5268
  if (s2 !== peg$FAILED) {
5859
5269
  if (input.charCodeAt(peg$currPos) === 125) {
5860
- s3 = peg$c32;
5270
+ s3 = peg$c28;
5861
5271
  peg$currPos++;
5862
5272
  } else {
5863
5273
  s3 = peg$FAILED;
5864
- if (peg$silentFails === 0) { peg$fail(peg$e42); }
5274
+ if (peg$silentFails === 0) { peg$fail(peg$e37); }
5865
5275
  }
5866
5276
  if (s3 !== peg$FAILED) {
5867
5277
  peg$savedPos = s0;
5868
- s0 = peg$f104(s2);
5278
+ s0 = peg$f92(s2);
5869
5279
  } else {
5870
5280
  peg$currPos = s0;
5871
5281
  s0 = peg$FAILED;
@@ -5881,7 +5291,7 @@ function peg$parse(input, options) {
5881
5291
  peg$silentFails--;
5882
5292
  if (s0 === peg$FAILED) {
5883
5293
  s1 = peg$FAILED;
5884
- if (peg$silentFails === 0) { peg$fail(peg$e109); }
5294
+ if (peg$silentFails === 0) { peg$fail(peg$e103); }
5885
5295
  }
5886
5296
 
5887
5297
  return s0;
@@ -5897,7 +5307,7 @@ function peg$parse(input, options) {
5897
5307
  peg$currPos++;
5898
5308
  } else {
5899
5309
  s0 = peg$FAILED;
5900
- if (peg$silentFails === 0) { peg$fail(peg$e40); }
5310
+ if (peg$silentFails === 0) { peg$fail(peg$e35); }
5901
5311
  }
5902
5312
  }
5903
5313
 
@@ -5914,7 +5324,7 @@ function peg$parse(input, options) {
5914
5324
  s3 = peg$parseunaryExpression();
5915
5325
  if (s3 !== peg$FAILED) {
5916
5326
  peg$savedPos = s0;
5917
- s0 = peg$f105(s1, s3);
5327
+ s0 = peg$f93(s1, s3);
5918
5328
  } else {
5919
5329
  peg$currPos = s0;
5920
5330
  s0 = peg$FAILED;
@@ -5931,60 +5341,14 @@ function peg$parse(input, options) {
5931
5341
  }
5932
5342
 
5933
5343
  function peg$parseunaryOperator() {
5934
- var s0, s1, s2, s3;
5344
+ var s0;
5935
5345
 
5936
5346
  s0 = input.charAt(peg$currPos);
5937
- if (peg$r11.test(s0)) {
5347
+ if (peg$r8.test(s0)) {
5938
5348
  peg$currPos++;
5939
5349
  } else {
5940
5350
  s0 = peg$FAILED;
5941
- if (peg$silentFails === 0) { peg$fail(peg$e110); }
5942
- }
5943
- if (s0 === peg$FAILED) {
5944
- s0 = peg$currPos;
5945
- if (input.charCodeAt(peg$currPos) === 45) {
5946
- s1 = peg$c40;
5947
- peg$currPos++;
5948
- } else {
5949
- s1 = peg$FAILED;
5950
- if (peg$silentFails === 0) { peg$fail(peg$e57); }
5951
- }
5952
- if (s1 !== peg$FAILED) {
5953
- s2 = peg$currPos;
5954
- peg$silentFails++;
5955
- if (input.substr(peg$currPos, 2) === peg$c62) {
5956
- s3 = peg$c62;
5957
- peg$currPos += 2;
5958
- } else {
5959
- s3 = peg$FAILED;
5960
- if (peg$silentFails === 0) { peg$fail(peg$e111); }
5961
- }
5962
- peg$silentFails--;
5963
- if (s3 === peg$FAILED) {
5964
- s2 = undefined;
5965
- } else {
5966
- peg$currPos = s2;
5967
- s2 = peg$FAILED;
5968
- }
5969
- if (s2 !== peg$FAILED) {
5970
- s0 = s1;
5971
- } else {
5972
- peg$currPos = s0;
5973
- s0 = peg$FAILED;
5974
- }
5975
- } else {
5976
- peg$currPos = s0;
5977
- s0 = peg$FAILED;
5978
- }
5979
- if (s0 === peg$FAILED) {
5980
- if (input.charCodeAt(peg$currPos) === 126) {
5981
- s0 = peg$c39;
5982
- peg$currPos++;
5983
- } else {
5984
- s0 = peg$FAILED;
5985
- if (peg$silentFails === 0) { peg$fail(peg$e53); }
5986
- }
5987
- }
5351
+ if (peg$silentFails === 0) { peg$fail(peg$e104); }
5988
5352
  }
5989
5353
 
5990
5354
  return s0;
@@ -6004,40 +5368,6 @@ function peg$parse(input, options) {
6004
5368
  return s0;
6005
5369
  }
6006
5370
 
6007
- function peg$parsewhitespaceShell() {
6008
- var s0, s1, s2;
6009
-
6010
- s0 = peg$currPos;
6011
- s1 = peg$parseshellMode();
6012
- if (s1 !== peg$FAILED) {
6013
- s2 = peg$parsewhitespace();
6014
- if (s2 !== peg$FAILED) {
6015
- s1 = [s1, s2];
6016
- s0 = s1;
6017
- } else {
6018
- peg$currPos = s0;
6019
- s0 = peg$FAILED;
6020
- }
6021
- } else {
6022
- peg$currPos = s0;
6023
- s0 = peg$FAILED;
6024
- }
6025
- if (s0 === peg$FAILED) {
6026
- s0 = peg$currPos;
6027
- s1 = peg$parsejseMode();
6028
- if (s1 !== peg$FAILED) {
6029
- s2 = peg$parse__();
6030
- s1 = [s1, s2];
6031
- s0 = s1;
6032
- } else {
6033
- peg$currPos = s0;
6034
- s0 = peg$FAILED;
6035
- }
6036
- }
6037
-
6038
- return s0;
6039
- }
6040
-
6041
5371
  function peg$parsewhitespaceWithNewLine() {
6042
5372
  var s0, s1, s2, s3, s4;
6043
5373
 
@@ -6097,11 +5427,6 @@ const peg$allowedStartRules = [
6097
5427
  "__",
6098
5428
  "additiveExpression",
6099
5429
  "additiveOperator",
6100
- "angleBracketLiteral",
6101
- "angleBracketPath",
6102
- "angleBracketPathKey",
6103
- "angleBracketPathChar",
6104
- "angleBracketProtocol",
6105
5430
  "arguments",
6106
5431
  "arrayLiteral",
6107
5432
  "arrayEntries",
@@ -6152,22 +5477,21 @@ const peg$allowedStartRules = [
6152
5477
  "identifierChar",
6153
5478
  "implicitParenthesesCallExpression",
6154
5479
  "implicitParensthesesArguments",
5480
+ "inherited",
6155
5481
  "inlineSpace",
6156
5482
  "integerLiteral",
6157
- "jseMode",
6158
5483
  "jsIdentifier",
6159
5484
  "jsIdentifierPart",
6160
5485
  "jsIdentifierStart",
6161
5486
  "jsPropertyAccess",
6162
- "jsReference",
6163
5487
  "list",
5488
+ "literal",
6164
5489
  "logicalAndExpression",
6165
5490
  "logicalOrExpression",
6166
5491
  "multiLineComment",
6167
5492
  "multiplicativeExpression",
6168
5493
  "multiplicativeOperator",
6169
5494
  "namespace",
6170
- "newExpression",
6171
5495
  "newLine",
6172
5496
  "numericLiteral",
6173
5497
  "nullishCoalescingExpression",
@@ -6180,7 +5504,6 @@ const peg$allowedStartRules = [
6180
5504
  "objectProperty",
6181
5505
  "objectShorthandProperty",
6182
5506
  "objectPublicKey",
6183
- "optionalChaining",
6184
5507
  "parameter",
6185
5508
  "parameterList",
6186
5509
  "parameterSingleton",
@@ -6192,21 +5515,15 @@ const peg$allowedStartRules = [
6192
5515
  "pathSegmentChar",
6193
5516
  "pipelineExpression",
6194
5517
  "primary",
6195
- "primaryJse",
6196
- "primaryShell",
6197
5518
  "program",
6198
5519
  "protocolExpression",
6199
5520
  "qualifiedReference",
6200
- "regexFlags",
6201
- "regexLiteral",
6202
- "regexLiteralChar",
6203
5521
  "relationalExpression",
6204
5522
  "relationalOperator",
6205
5523
  "rootDirectory",
6206
5524
  "scopeReference",
6207
5525
  "separator",
6208
5526
  "shebang",
6209
- "shellMode",
6210
5527
  "shiftExpression",
6211
5528
  "shiftOperator",
6212
5529
  "shorthandFunction",
@@ -6230,7 +5547,6 @@ const peg$allowedStartRules = [
6230
5547
  "unaryExpression",
6231
5548
  "unaryOperator",
6232
5549
  "whitespace",
6233
- "whitespaceShell",
6234
5550
  "whitespaceWithNewLine"
6235
5551
  ];
6236
5552