@weborigami/language 0.3.2 → 0.3.3-jse.1

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