@env-spec/parser 0.3.0 → 0.3.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.
package/dist/index.mjs CHANGED
@@ -1,5 +1,5 @@
1
- import { __name, ParsedEnvSpecCommentBlock, ParsedEnvSpecDivider, ParsedEnvSpecComment, ParsedEnvSpecBlankLine, ParsedEnvSpecDecoratorComment, ParsedEnvSpecConfigItem, ParsedEnvSpecFile, ParsedEnvSpecDecorator, ParsedEnvSpecFunctionCall, ParsedEnvSpecKeyValuePair, ParsedEnvSpecFunctionArgs, ParsedEnvSpecStaticValue, ParsedEnvSpecRegexLiteral } from './chunk-RRVAHNIY.mjs';
2
- export { ParsedEnvSpecBlankLine, ParsedEnvSpecComment, ParsedEnvSpecCommentBlock, ParsedEnvSpecConfigItem, ParsedEnvSpecDecorator, ParsedEnvSpecDecoratorComment, ParsedEnvSpecDivider, ParsedEnvSpecFile, ParsedEnvSpecFunctionArgs, ParsedEnvSpecFunctionCall, ParsedEnvSpecKeyValuePair, ParsedEnvSpecRegexLiteral, ParsedEnvSpecStaticValue, expand } from './chunk-RRVAHNIY.mjs';
1
+ import { __name, ParsedEnvSpecCommentBlock, ParsedEnvSpecDivider, ParsedEnvSpecComment, ParsedEnvSpecBlankLine, ParsedEnvSpecDecoratorComment, ParsedEnvSpecConfigItem, ParsedEnvSpecFile, ParsedEnvSpecDecorator, ParsedEnvSpecFunctionCall, ParsedEnvSpecKeyValuePair, ParsedEnvSpecFunctionArgs, ParsedEnvSpecStaticValue } from './chunk-AVMDB47P.mjs';
2
+ export { ParsedEnvSpecBlankLine, ParsedEnvSpecComment, ParsedEnvSpecCommentBlock, ParsedEnvSpecConfigItem, ParsedEnvSpecDecorator, ParsedEnvSpecDecoratorComment, ParsedEnvSpecDivider, ParsedEnvSpecFile, ParsedEnvSpecFunctionArgs, ParsedEnvSpecFunctionCall, ParsedEnvSpecKeyValuePair, ParsedEnvSpecStaticValue, expand } from './chunk-AVMDB47P.mjs';
3
3
 
4
4
  // src/updater.ts
5
5
  function ensureHeader(file, newHeaderContents) {
@@ -250,15 +250,13 @@ function peg$parse(input, options) {
250
250
  const peg$c6 = "(";
251
251
  const peg$c7 = ",";
252
252
  const peg$c8 = ")";
253
- const peg$c9 = "/";
254
- const peg$c10 = "\\/";
255
- const peg$c11 = '\\"';
256
- const peg$c12 = "\\'";
257
- const peg$c13 = "\\`";
258
- const peg$c14 = '"""';
259
- const peg$c15 = '\\"""';
260
- const peg$c16 = "```";
261
- const peg$c17 = "\\```";
253
+ const peg$c9 = '\\"';
254
+ const peg$c10 = "\\'";
255
+ const peg$c11 = "\\`";
256
+ const peg$c12 = '"""';
257
+ const peg$c13 = '\\"""';
258
+ const peg$c14 = "```";
259
+ const peg$c15 = "\\```";
262
260
  const peg$r0 = /^[a-zA-Z_]/;
263
261
  const peg$r1 = /^[a-zA-Z0-9_.\-]/;
264
262
  const peg$r2 = /^[^\n]/;
@@ -269,17 +267,15 @@ function peg$parse(input, options) {
269
267
  const peg$r7 = /^[ \t]/;
270
268
  const peg$r8 = /^[ \t\n]/;
271
269
  const peg$r9 = /^[\-=*#]/;
272
- const peg$r10 = /^[^\/\n]/;
273
- const peg$r11 = /^[gimsuy]/;
274
- const peg$r12 = /^['"`]/;
275
- const peg$r13 = /^[^#\n]/;
276
- const peg$r14 = /^[^# \n]/;
277
- const peg$r15 = /^["]/;
278
- const peg$r16 = /^[^"\n]/;
279
- const peg$r17 = /^[']/;
280
- const peg$r18 = /^[^'\n]/;
281
- const peg$r19 = /^[`]/;
282
- const peg$r20 = /^[^`\n]/;
270
+ const peg$r10 = /^['"`]/;
271
+ const peg$r11 = /^[^#\n]/;
272
+ const peg$r12 = /^[^# \n]/;
273
+ const peg$r13 = /^["]/;
274
+ const peg$r14 = /^[^"\n]/;
275
+ const peg$r15 = /^[']/;
276
+ const peg$r16 = /^[^'\n]/;
277
+ const peg$r17 = /^[`]/;
278
+ const peg$r18 = /^[^`\n]/;
283
279
  const peg$e0 = peg$literalExpectation("\n", false);
284
280
  const peg$e1 = peg$literalExpectation("export ", false);
285
281
  const peg$e2 = peg$literalExpectation("=", false);
@@ -299,27 +295,23 @@ function peg$parse(input, options) {
299
295
  const peg$e16 = peg$classExpectation([" ", " "], false, false, false);
300
296
  const peg$e17 = peg$classExpectation([" ", " ", "\n"], false, false, false);
301
297
  const peg$e18 = peg$classExpectation(["-", "=", "*", "#"], false, false, false);
302
- const peg$e19 = peg$literalExpectation("/", false);
303
- const peg$e20 = peg$literalExpectation("\\/", false);
304
- const peg$e21 = peg$classExpectation(["/", "\n"], true, false, false);
305
- const peg$e22 = peg$classExpectation(["g", "i", "m", "s", "u", "y"], false, false, false);
306
- const peg$e23 = peg$classExpectation(["'", '"', "`"], false, false, false);
307
- const peg$e24 = peg$classExpectation(["#", "\n"], true, false, false);
308
- const peg$e25 = peg$classExpectation(["#", " ", "\n"], true, false, false);
309
- const peg$e26 = peg$classExpectation(['"'], false, false, false);
310
- const peg$e27 = peg$literalExpectation('\\"', false);
311
- const peg$e28 = peg$classExpectation(['"', "\n"], true, false, false);
312
- const peg$e29 = peg$classExpectation(["'"], false, false, false);
313
- const peg$e30 = peg$literalExpectation("\\'", false);
314
- const peg$e31 = peg$classExpectation(["'", "\n"], true, false, false);
315
- const peg$e32 = peg$classExpectation(["`"], false, false, false);
316
- const peg$e33 = peg$literalExpectation("\\`", false);
317
- const peg$e34 = peg$classExpectation(["`", "\n"], true, false, false);
318
- const peg$e35 = peg$literalExpectation('"""', false);
319
- const peg$e36 = peg$literalExpectation('\\"""', false);
320
- const peg$e37 = peg$literalExpectation("```", false);
321
- const peg$e38 = peg$literalExpectation("\\```", false);
322
- const peg$e39 = peg$anyExpectation();
298
+ const peg$e19 = peg$classExpectation(["'", '"', "`"], false, false, false);
299
+ const peg$e20 = peg$classExpectation(["#", "\n"], true, false, false);
300
+ const peg$e21 = peg$classExpectation(["#", " ", "\n"], true, false, false);
301
+ const peg$e22 = peg$classExpectation(['"'], false, false, false);
302
+ const peg$e23 = peg$literalExpectation('\\"', false);
303
+ const peg$e24 = peg$classExpectation(['"', "\n"], true, false, false);
304
+ const peg$e25 = peg$classExpectation(["'"], false, false, false);
305
+ const peg$e26 = peg$literalExpectation("\\'", false);
306
+ const peg$e27 = peg$classExpectation(["'", "\n"], true, false, false);
307
+ const peg$e28 = peg$classExpectation(["`"], false, false, false);
308
+ const peg$e29 = peg$literalExpectation("\\`", false);
309
+ const peg$e30 = peg$classExpectation(["`", "\n"], true, false, false);
310
+ const peg$e31 = peg$literalExpectation('"""', false);
311
+ const peg$e32 = peg$literalExpectation('\\"""', false);
312
+ const peg$e33 = peg$literalExpectation("```", false);
313
+ const peg$e34 = peg$literalExpectation("\\```", false);
314
+ const peg$e35 = peg$anyExpectation();
323
315
  function peg$f0() {
324
316
  return new ParsedEnvSpecBlankLine({ _location: location() });
325
317
  }
@@ -430,21 +422,16 @@ function peg$parse(input, options) {
430
422
  });
431
423
  }
432
424
  __name(peg$f16, "peg$f16");
433
- function peg$f17(pattern, flags) {
434
- return new ParsedEnvSpecRegexLiteral({
435
- rawValue: text(),
436
- pattern: pattern.replaceAll("\\/", "/"),
437
- flags,
438
- _location: location()
439
- });
425
+ function peg$f17() {
426
+ return new ParsedEnvSpecStaticValue({ rawValue: text(), _location: location() });
440
427
  }
441
428
  __name(peg$f17, "peg$f17");
442
429
  function peg$f18() {
443
430
  return new ParsedEnvSpecStaticValue({ rawValue: text(), _location: location() });
444
431
  }
445
432
  __name(peg$f18, "peg$f18");
446
- function peg$f19() {
447
- return new ParsedEnvSpecStaticValue({ rawValue: text(), _location: location() });
433
+ function peg$f19(quote) {
434
+ return new ParsedEnvSpecStaticValue({ quote, rawValue: text(), _location: location() });
448
435
  }
449
436
  __name(peg$f19, "peg$f19");
450
437
  function peg$f20(quote) {
@@ -456,7 +443,7 @@ function peg$parse(input, options) {
456
443
  }
457
444
  __name(peg$f21, "peg$f21");
458
445
  function peg$f22(quote) {
459
- return new ParsedEnvSpecStaticValue({ quote, rawValue: text(), _location: location() });
446
+ return new ParsedEnvSpecStaticValue({ quote, isMultiLine: true, rawValue: text(), _location: location() });
460
447
  }
461
448
  __name(peg$f22, "peg$f22");
462
449
  function peg$f23(quote) {
@@ -471,10 +458,6 @@ function peg$parse(input, options) {
471
458
  return new ParsedEnvSpecStaticValue({ quote, isMultiLine: true, rawValue: text(), _location: location() });
472
459
  }
473
460
  __name(peg$f25, "peg$f25");
474
- function peg$f26(quote) {
475
- return new ParsedEnvSpecStaticValue({ quote, isMultiLine: true, rawValue: text(), _location: location() });
476
- }
477
- __name(peg$f26, "peg$f26");
478
461
  let peg$currPos = options.peg$currPos | 0;
479
462
  let peg$savedPos = peg$currPos;
480
463
  const peg$posDetailsCache = [{ line: 1, column: 1 }];
@@ -884,14 +867,11 @@ function peg$parse(input, options) {
884
867
  let s0;
885
868
  s0 = peg$parseFunctionCall();
886
869
  if (s0 === peg$FAILED) {
887
- s0 = peg$parseRegexLiteral();
870
+ s0 = peg$parsemultiLineString();
888
871
  if (s0 === peg$FAILED) {
889
- s0 = peg$parsemultiLineString();
872
+ s0 = peg$parsequotedString();
890
873
  if (s0 === peg$FAILED) {
891
- s0 = peg$parsequotedString();
892
- if (s0 === peg$FAILED) {
893
- s0 = peg$parseunquotedString();
894
- }
874
+ s0 = peg$parseunquotedString();
895
875
  }
896
876
  }
897
877
  }
@@ -1503,12 +1483,9 @@ function peg$parse(input, options) {
1503
1483
  let s0;
1504
1484
  s0 = peg$parseDecoratorFunctionCall();
1505
1485
  if (s0 === peg$FAILED) {
1506
- s0 = peg$parseRegexLiteral();
1486
+ s0 = peg$parsequotedString();
1507
1487
  if (s0 === peg$FAILED) {
1508
- s0 = peg$parsequotedString();
1509
- if (s0 === peg$FAILED) {
1510
- s0 = peg$parseunquotedStringWithoutSpaces();
1511
- }
1488
+ s0 = peg$parseunquotedStringWithoutSpaces();
1512
1489
  }
1513
1490
  }
1514
1491
  return s0;
@@ -1705,49 +1682,46 @@ function peg$parse(input, options) {
1705
1682
  let s0, s1, s2, s3;
1706
1683
  s0 = peg$parseDecoratorFunctionCall();
1707
1684
  if (s0 === peg$FAILED) {
1708
- s0 = peg$parseRegexLiteral();
1685
+ s0 = peg$parsequotedString();
1709
1686
  if (s0 === peg$FAILED) {
1710
- s0 = peg$parsequotedString();
1711
- if (s0 === peg$FAILED) {
1712
- s0 = peg$currPos;
1713
- s1 = peg$currPos;
1714
- s2 = [];
1715
- s3 = input.charAt(peg$currPos);
1716
- if (peg$r6.test(s3)) {
1717
- peg$currPos++;
1718
- } else {
1719
- s3 = peg$FAILED;
1720
- if (peg$silentFails === 0) {
1721
- peg$fail(peg$e15);
1722
- }
1687
+ s0 = peg$currPos;
1688
+ s1 = peg$currPos;
1689
+ s2 = [];
1690
+ s3 = input.charAt(peg$currPos);
1691
+ if (peg$r6.test(s3)) {
1692
+ peg$currPos++;
1693
+ } else {
1694
+ s3 = peg$FAILED;
1695
+ if (peg$silentFails === 0) {
1696
+ peg$fail(peg$e15);
1723
1697
  }
1724
- if (s3 !== peg$FAILED) {
1725
- while (s3 !== peg$FAILED) {
1726
- s2.push(s3);
1727
- s3 = input.charAt(peg$currPos);
1728
- if (peg$r6.test(s3)) {
1729
- peg$currPos++;
1730
- } else {
1731
- s3 = peg$FAILED;
1732
- if (peg$silentFails === 0) {
1733
- peg$fail(peg$e15);
1734
- }
1698
+ }
1699
+ if (s3 !== peg$FAILED) {
1700
+ while (s3 !== peg$FAILED) {
1701
+ s2.push(s3);
1702
+ s3 = input.charAt(peg$currPos);
1703
+ if (peg$r6.test(s3)) {
1704
+ peg$currPos++;
1705
+ } else {
1706
+ s3 = peg$FAILED;
1707
+ if (peg$silentFails === 0) {
1708
+ peg$fail(peg$e15);
1735
1709
  }
1736
1710
  }
1737
- } else {
1738
- s2 = peg$FAILED;
1739
1711
  }
1740
- if (s2 !== peg$FAILED) {
1741
- s1 = input.substring(s1, peg$currPos);
1742
- } else {
1743
- s1 = s2;
1744
- }
1745
- if (s1 !== peg$FAILED) {
1746
- peg$savedPos = s0;
1747
- s1 = peg$f11();
1748
- }
1749
- s0 = s1;
1712
+ } else {
1713
+ s2 = peg$FAILED;
1750
1714
  }
1715
+ if (s2 !== peg$FAILED) {
1716
+ s1 = input.substring(s1, peg$currPos);
1717
+ } else {
1718
+ s1 = s2;
1719
+ }
1720
+ if (s1 !== peg$FAILED) {
1721
+ peg$savedPos = s0;
1722
+ s1 = peg$f11();
1723
+ }
1724
+ s0 = s1;
1751
1725
  }
1752
1726
  }
1753
1727
  return s0;
@@ -2225,49 +2199,46 @@ function peg$parse(input, options) {
2225
2199
  let s0, s1, s2, s3;
2226
2200
  s0 = peg$parseFunctionCall();
2227
2201
  if (s0 === peg$FAILED) {
2228
- s0 = peg$parseRegexLiteral();
2202
+ s0 = peg$parsequotedString();
2229
2203
  if (s0 === peg$FAILED) {
2230
- s0 = peg$parsequotedString();
2231
- if (s0 === peg$FAILED) {
2232
- s0 = peg$currPos;
2233
- s1 = peg$currPos;
2234
- s2 = [];
2235
- s3 = input.charAt(peg$currPos);
2236
- if (peg$r6.test(s3)) {
2237
- peg$currPos++;
2238
- } else {
2239
- s3 = peg$FAILED;
2240
- if (peg$silentFails === 0) {
2241
- peg$fail(peg$e15);
2242
- }
2204
+ s0 = peg$currPos;
2205
+ s1 = peg$currPos;
2206
+ s2 = [];
2207
+ s3 = input.charAt(peg$currPos);
2208
+ if (peg$r6.test(s3)) {
2209
+ peg$currPos++;
2210
+ } else {
2211
+ s3 = peg$FAILED;
2212
+ if (peg$silentFails === 0) {
2213
+ peg$fail(peg$e15);
2243
2214
  }
2244
- if (s3 !== peg$FAILED) {
2245
- while (s3 !== peg$FAILED) {
2246
- s2.push(s3);
2247
- s3 = input.charAt(peg$currPos);
2248
- if (peg$r6.test(s3)) {
2249
- peg$currPos++;
2250
- } else {
2251
- s3 = peg$FAILED;
2252
- if (peg$silentFails === 0) {
2253
- peg$fail(peg$e15);
2254
- }
2215
+ }
2216
+ if (s3 !== peg$FAILED) {
2217
+ while (s3 !== peg$FAILED) {
2218
+ s2.push(s3);
2219
+ s3 = input.charAt(peg$currPos);
2220
+ if (peg$r6.test(s3)) {
2221
+ peg$currPos++;
2222
+ } else {
2223
+ s3 = peg$FAILED;
2224
+ if (peg$silentFails === 0) {
2225
+ peg$fail(peg$e15);
2255
2226
  }
2256
2227
  }
2257
- } else {
2258
- s2 = peg$FAILED;
2259
- }
2260
- if (s2 !== peg$FAILED) {
2261
- s1 = input.substring(s1, peg$currPos);
2262
- } else {
2263
- s1 = s2;
2264
2228
  }
2265
- if (s1 !== peg$FAILED) {
2266
- peg$savedPos = s0;
2267
- s1 = peg$f15();
2268
- }
2269
- s0 = s1;
2229
+ } else {
2230
+ s2 = peg$FAILED;
2270
2231
  }
2232
+ if (s2 !== peg$FAILED) {
2233
+ s1 = input.substring(s1, peg$currPos);
2234
+ } else {
2235
+ s1 = s2;
2236
+ }
2237
+ if (s1 !== peg$FAILED) {
2238
+ peg$savedPos = s0;
2239
+ s1 = peg$f15();
2240
+ }
2241
+ s0 = s1;
2271
2242
  }
2272
2243
  }
2273
2244
  return s0;
@@ -2401,112 +2372,6 @@ function peg$parse(input, options) {
2401
2372
  return s0;
2402
2373
  }
2403
2374
  __name(peg$parseDivider, "peg$parseDivider");
2404
- function peg$parseRegexLiteral() {
2405
- let s0, s1, s2, s3, s4, s5, s6;
2406
- s0 = peg$currPos;
2407
- if (input.charCodeAt(peg$currPos) === 47) {
2408
- s1 = peg$c9;
2409
- peg$currPos++;
2410
- } else {
2411
- s1 = peg$FAILED;
2412
- if (peg$silentFails === 0) {
2413
- peg$fail(peg$e19);
2414
- }
2415
- }
2416
- if (s1 !== peg$FAILED) {
2417
- s2 = peg$currPos;
2418
- s3 = [];
2419
- if (input.substr(peg$currPos, 2) === peg$c10) {
2420
- s4 = peg$c10;
2421
- peg$currPos += 2;
2422
- } else {
2423
- s4 = peg$FAILED;
2424
- if (peg$silentFails === 0) {
2425
- peg$fail(peg$e20);
2426
- }
2427
- }
2428
- if (s4 === peg$FAILED) {
2429
- s4 = input.charAt(peg$currPos);
2430
- if (peg$r10.test(s4)) {
2431
- peg$currPos++;
2432
- } else {
2433
- s4 = peg$FAILED;
2434
- if (peg$silentFails === 0) {
2435
- peg$fail(peg$e21);
2436
- }
2437
- }
2438
- }
2439
- while (s4 !== peg$FAILED) {
2440
- s3.push(s4);
2441
- if (input.substr(peg$currPos, 2) === peg$c10) {
2442
- s4 = peg$c10;
2443
- peg$currPos += 2;
2444
- } else {
2445
- s4 = peg$FAILED;
2446
- if (peg$silentFails === 0) {
2447
- peg$fail(peg$e20);
2448
- }
2449
- }
2450
- if (s4 === peg$FAILED) {
2451
- s4 = input.charAt(peg$currPos);
2452
- if (peg$r10.test(s4)) {
2453
- peg$currPos++;
2454
- } else {
2455
- s4 = peg$FAILED;
2456
- if (peg$silentFails === 0) {
2457
- peg$fail(peg$e21);
2458
- }
2459
- }
2460
- }
2461
- }
2462
- s2 = input.substring(s2, peg$currPos);
2463
- if (input.charCodeAt(peg$currPos) === 47) {
2464
- s3 = peg$c9;
2465
- peg$currPos++;
2466
- } else {
2467
- s3 = peg$FAILED;
2468
- if (peg$silentFails === 0) {
2469
- peg$fail(peg$e19);
2470
- }
2471
- }
2472
- if (s3 !== peg$FAILED) {
2473
- s4 = peg$currPos;
2474
- s5 = [];
2475
- s6 = input.charAt(peg$currPos);
2476
- if (peg$r11.test(s6)) {
2477
- peg$currPos++;
2478
- } else {
2479
- s6 = peg$FAILED;
2480
- if (peg$silentFails === 0) {
2481
- peg$fail(peg$e22);
2482
- }
2483
- }
2484
- while (s6 !== peg$FAILED) {
2485
- s5.push(s6);
2486
- s6 = input.charAt(peg$currPos);
2487
- if (peg$r11.test(s6)) {
2488
- peg$currPos++;
2489
- } else {
2490
- s6 = peg$FAILED;
2491
- if (peg$silentFails === 0) {
2492
- peg$fail(peg$e22);
2493
- }
2494
- }
2495
- }
2496
- s4 = input.substring(s4, peg$currPos);
2497
- peg$savedPos = s0;
2498
- s0 = peg$f17(s2, s4);
2499
- } else {
2500
- peg$currPos = s0;
2501
- s0 = peg$FAILED;
2502
- }
2503
- } else {
2504
- peg$currPos = s0;
2505
- s0 = peg$FAILED;
2506
- }
2507
- return s0;
2508
- }
2509
- __name(peg$parseRegexLiteral, "peg$parseRegexLiteral");
2510
2375
  function peg$parseunquotedString() {
2511
2376
  let s0, s1, s2, s3, s4, s5, s6;
2512
2377
  s0 = peg$currPos;
@@ -2516,12 +2381,12 @@ function peg$parse(input, options) {
2516
2381
  s4 = peg$currPos;
2517
2382
  peg$silentFails++;
2518
2383
  s5 = input.charAt(peg$currPos);
2519
- if (peg$r12.test(s5)) {
2384
+ if (peg$r10.test(s5)) {
2520
2385
  peg$currPos++;
2521
2386
  } else {
2522
2387
  s5 = peg$FAILED;
2523
2388
  if (peg$silentFails === 0) {
2524
- peg$fail(peg$e23);
2389
+ peg$fail(peg$e19);
2525
2390
  }
2526
2391
  }
2527
2392
  peg$silentFails--;
@@ -2534,24 +2399,24 @@ function peg$parse(input, options) {
2534
2399
  if (s4 !== peg$FAILED) {
2535
2400
  s5 = [];
2536
2401
  s6 = input.charAt(peg$currPos);
2537
- if (peg$r13.test(s6)) {
2402
+ if (peg$r11.test(s6)) {
2538
2403
  peg$currPos++;
2539
2404
  } else {
2540
2405
  s6 = peg$FAILED;
2541
2406
  if (peg$silentFails === 0) {
2542
- peg$fail(peg$e24);
2407
+ peg$fail(peg$e20);
2543
2408
  }
2544
2409
  }
2545
2410
  if (s6 !== peg$FAILED) {
2546
2411
  while (s6 !== peg$FAILED) {
2547
2412
  s5.push(s6);
2548
2413
  s6 = input.charAt(peg$currPos);
2549
- if (peg$r13.test(s6)) {
2414
+ if (peg$r11.test(s6)) {
2550
2415
  peg$currPos++;
2551
2416
  } else {
2552
2417
  s6 = peg$FAILED;
2553
2418
  if (peg$silentFails === 0) {
2554
- peg$fail(peg$e24);
2419
+ peg$fail(peg$e20);
2555
2420
  }
2556
2421
  }
2557
2422
  }
@@ -2576,7 +2441,7 @@ function peg$parse(input, options) {
2576
2441
  }
2577
2442
  if (s1 !== peg$FAILED) {
2578
2443
  peg$savedPos = s0;
2579
- s1 = peg$f18();
2444
+ s1 = peg$f17();
2580
2445
  }
2581
2446
  s0 = s1;
2582
2447
  return s0;
@@ -2590,12 +2455,12 @@ function peg$parse(input, options) {
2590
2455
  s3 = peg$currPos;
2591
2456
  peg$silentFails++;
2592
2457
  s4 = input.charAt(peg$currPos);
2593
- if (peg$r12.test(s4)) {
2458
+ if (peg$r10.test(s4)) {
2594
2459
  peg$currPos++;
2595
2460
  } else {
2596
2461
  s4 = peg$FAILED;
2597
2462
  if (peg$silentFails === 0) {
2598
- peg$fail(peg$e23);
2463
+ peg$fail(peg$e19);
2599
2464
  }
2600
2465
  }
2601
2466
  peg$silentFails--;
@@ -2608,24 +2473,24 @@ function peg$parse(input, options) {
2608
2473
  if (s3 !== peg$FAILED) {
2609
2474
  s4 = [];
2610
2475
  s5 = input.charAt(peg$currPos);
2611
- if (peg$r14.test(s5)) {
2476
+ if (peg$r12.test(s5)) {
2612
2477
  peg$currPos++;
2613
2478
  } else {
2614
2479
  s5 = peg$FAILED;
2615
2480
  if (peg$silentFails === 0) {
2616
- peg$fail(peg$e25);
2481
+ peg$fail(peg$e21);
2617
2482
  }
2618
2483
  }
2619
2484
  if (s5 !== peg$FAILED) {
2620
2485
  while (s5 !== peg$FAILED) {
2621
2486
  s4.push(s5);
2622
2487
  s5 = input.charAt(peg$currPos);
2623
- if (peg$r14.test(s5)) {
2488
+ if (peg$r12.test(s5)) {
2624
2489
  peg$currPos++;
2625
2490
  } else {
2626
2491
  s5 = peg$FAILED;
2627
2492
  if (peg$silentFails === 0) {
2628
- peg$fail(peg$e25);
2493
+ peg$fail(peg$e21);
2629
2494
  }
2630
2495
  }
2631
2496
  }
@@ -2650,7 +2515,7 @@ function peg$parse(input, options) {
2650
2515
  }
2651
2516
  if (s1 !== peg$FAILED) {
2652
2517
  peg$savedPos = s0;
2653
- s1 = peg$f19();
2518
+ s1 = peg$f18();
2654
2519
  }
2655
2520
  s0 = s1;
2656
2521
  return s0;
@@ -2672,71 +2537,71 @@ function peg$parse(input, options) {
2672
2537
  let s0, s1, s2, s3;
2673
2538
  s0 = peg$currPos;
2674
2539
  s1 = input.charAt(peg$currPos);
2675
- if (peg$r15.test(s1)) {
2540
+ if (peg$r13.test(s1)) {
2676
2541
  peg$currPos++;
2677
2542
  } else {
2678
2543
  s1 = peg$FAILED;
2679
2544
  if (peg$silentFails === 0) {
2680
- peg$fail(peg$e26);
2545
+ peg$fail(peg$e22);
2681
2546
  }
2682
2547
  }
2683
2548
  if (s1 !== peg$FAILED) {
2684
2549
  s2 = [];
2685
- if (input.substr(peg$currPos, 2) === peg$c11) {
2686
- s3 = peg$c11;
2550
+ if (input.substr(peg$currPos, 2) === peg$c9) {
2551
+ s3 = peg$c9;
2687
2552
  peg$currPos += 2;
2688
2553
  } else {
2689
2554
  s3 = peg$FAILED;
2690
2555
  if (peg$silentFails === 0) {
2691
- peg$fail(peg$e27);
2556
+ peg$fail(peg$e23);
2692
2557
  }
2693
2558
  }
2694
2559
  if (s3 === peg$FAILED) {
2695
2560
  s3 = input.charAt(peg$currPos);
2696
- if (peg$r16.test(s3)) {
2561
+ if (peg$r14.test(s3)) {
2697
2562
  peg$currPos++;
2698
2563
  } else {
2699
2564
  s3 = peg$FAILED;
2700
2565
  if (peg$silentFails === 0) {
2701
- peg$fail(peg$e28);
2566
+ peg$fail(peg$e24);
2702
2567
  }
2703
2568
  }
2704
2569
  }
2705
2570
  while (s3 !== peg$FAILED) {
2706
2571
  s2.push(s3);
2707
- if (input.substr(peg$currPos, 2) === peg$c11) {
2708
- s3 = peg$c11;
2572
+ if (input.substr(peg$currPos, 2) === peg$c9) {
2573
+ s3 = peg$c9;
2709
2574
  peg$currPos += 2;
2710
2575
  } else {
2711
2576
  s3 = peg$FAILED;
2712
2577
  if (peg$silentFails === 0) {
2713
- peg$fail(peg$e27);
2578
+ peg$fail(peg$e23);
2714
2579
  }
2715
2580
  }
2716
2581
  if (s3 === peg$FAILED) {
2717
2582
  s3 = input.charAt(peg$currPos);
2718
- if (peg$r16.test(s3)) {
2583
+ if (peg$r14.test(s3)) {
2719
2584
  peg$currPos++;
2720
2585
  } else {
2721
2586
  s3 = peg$FAILED;
2722
2587
  if (peg$silentFails === 0) {
2723
- peg$fail(peg$e28);
2588
+ peg$fail(peg$e24);
2724
2589
  }
2725
2590
  }
2726
2591
  }
2727
2592
  }
2728
2593
  s3 = input.charAt(peg$currPos);
2729
- if (peg$r15.test(s3)) {
2594
+ if (peg$r13.test(s3)) {
2730
2595
  peg$currPos++;
2731
2596
  } else {
2732
2597
  s3 = peg$FAILED;
2733
2598
  if (peg$silentFails === 0) {
2734
- peg$fail(peg$e26);
2599
+ peg$fail(peg$e22);
2735
2600
  }
2736
2601
  }
2737
2602
  if (s3 !== peg$FAILED) {
2738
2603
  peg$savedPos = s0;
2739
- s0 = peg$f20(s1);
2604
+ s0 = peg$f19(s1);
2740
2605
  } else {
2741
2606
  peg$currPos = s0;
2742
2607
  s0 = peg$FAILED;
@@ -2752,71 +2617,71 @@ function peg$parse(input, options) {
2752
2617
  let s0, s1, s2, s3;
2753
2618
  s0 = peg$currPos;
2754
2619
  s1 = input.charAt(peg$currPos);
2755
- if (peg$r17.test(s1)) {
2620
+ if (peg$r15.test(s1)) {
2756
2621
  peg$currPos++;
2757
2622
  } else {
2758
2623
  s1 = peg$FAILED;
2759
2624
  if (peg$silentFails === 0) {
2760
- peg$fail(peg$e29);
2625
+ peg$fail(peg$e25);
2761
2626
  }
2762
2627
  }
2763
2628
  if (s1 !== peg$FAILED) {
2764
2629
  s2 = [];
2765
- if (input.substr(peg$currPos, 2) === peg$c12) {
2766
- s3 = peg$c12;
2630
+ if (input.substr(peg$currPos, 2) === peg$c10) {
2631
+ s3 = peg$c10;
2767
2632
  peg$currPos += 2;
2768
2633
  } else {
2769
2634
  s3 = peg$FAILED;
2770
2635
  if (peg$silentFails === 0) {
2771
- peg$fail(peg$e30);
2636
+ peg$fail(peg$e26);
2772
2637
  }
2773
2638
  }
2774
2639
  if (s3 === peg$FAILED) {
2775
2640
  s3 = input.charAt(peg$currPos);
2776
- if (peg$r18.test(s3)) {
2641
+ if (peg$r16.test(s3)) {
2777
2642
  peg$currPos++;
2778
2643
  } else {
2779
2644
  s3 = peg$FAILED;
2780
2645
  if (peg$silentFails === 0) {
2781
- peg$fail(peg$e31);
2646
+ peg$fail(peg$e27);
2782
2647
  }
2783
2648
  }
2784
2649
  }
2785
2650
  while (s3 !== peg$FAILED) {
2786
2651
  s2.push(s3);
2787
- if (input.substr(peg$currPos, 2) === peg$c12) {
2788
- s3 = peg$c12;
2652
+ if (input.substr(peg$currPos, 2) === peg$c10) {
2653
+ s3 = peg$c10;
2789
2654
  peg$currPos += 2;
2790
2655
  } else {
2791
2656
  s3 = peg$FAILED;
2792
2657
  if (peg$silentFails === 0) {
2793
- peg$fail(peg$e30);
2658
+ peg$fail(peg$e26);
2794
2659
  }
2795
2660
  }
2796
2661
  if (s3 === peg$FAILED) {
2797
2662
  s3 = input.charAt(peg$currPos);
2798
- if (peg$r18.test(s3)) {
2663
+ if (peg$r16.test(s3)) {
2799
2664
  peg$currPos++;
2800
2665
  } else {
2801
2666
  s3 = peg$FAILED;
2802
2667
  if (peg$silentFails === 0) {
2803
- peg$fail(peg$e31);
2668
+ peg$fail(peg$e27);
2804
2669
  }
2805
2670
  }
2806
2671
  }
2807
2672
  }
2808
2673
  s3 = input.charAt(peg$currPos);
2809
- if (peg$r17.test(s3)) {
2674
+ if (peg$r15.test(s3)) {
2810
2675
  peg$currPos++;
2811
2676
  } else {
2812
2677
  s3 = peg$FAILED;
2813
2678
  if (peg$silentFails === 0) {
2814
- peg$fail(peg$e29);
2679
+ peg$fail(peg$e25);
2815
2680
  }
2816
2681
  }
2817
2682
  if (s3 !== peg$FAILED) {
2818
2683
  peg$savedPos = s0;
2819
- s0 = peg$f21(s1);
2684
+ s0 = peg$f20(s1);
2820
2685
  } else {
2821
2686
  peg$currPos = s0;
2822
2687
  s0 = peg$FAILED;
@@ -2832,71 +2697,71 @@ function peg$parse(input, options) {
2832
2697
  let s0, s1, s2, s3;
2833
2698
  s0 = peg$currPos;
2834
2699
  s1 = input.charAt(peg$currPos);
2835
- if (peg$r19.test(s1)) {
2700
+ if (peg$r17.test(s1)) {
2836
2701
  peg$currPos++;
2837
2702
  } else {
2838
2703
  s1 = peg$FAILED;
2839
2704
  if (peg$silentFails === 0) {
2840
- peg$fail(peg$e32);
2705
+ peg$fail(peg$e28);
2841
2706
  }
2842
2707
  }
2843
2708
  if (s1 !== peg$FAILED) {
2844
2709
  s2 = [];
2845
- if (input.substr(peg$currPos, 2) === peg$c13) {
2846
- s3 = peg$c13;
2710
+ if (input.substr(peg$currPos, 2) === peg$c11) {
2711
+ s3 = peg$c11;
2847
2712
  peg$currPos += 2;
2848
2713
  } else {
2849
2714
  s3 = peg$FAILED;
2850
2715
  if (peg$silentFails === 0) {
2851
- peg$fail(peg$e33);
2716
+ peg$fail(peg$e29);
2852
2717
  }
2853
2718
  }
2854
2719
  if (s3 === peg$FAILED) {
2855
2720
  s3 = input.charAt(peg$currPos);
2856
- if (peg$r20.test(s3)) {
2721
+ if (peg$r18.test(s3)) {
2857
2722
  peg$currPos++;
2858
2723
  } else {
2859
2724
  s3 = peg$FAILED;
2860
2725
  if (peg$silentFails === 0) {
2861
- peg$fail(peg$e34);
2726
+ peg$fail(peg$e30);
2862
2727
  }
2863
2728
  }
2864
2729
  }
2865
2730
  while (s3 !== peg$FAILED) {
2866
2731
  s2.push(s3);
2867
- if (input.substr(peg$currPos, 2) === peg$c13) {
2868
- s3 = peg$c13;
2732
+ if (input.substr(peg$currPos, 2) === peg$c11) {
2733
+ s3 = peg$c11;
2869
2734
  peg$currPos += 2;
2870
2735
  } else {
2871
2736
  s3 = peg$FAILED;
2872
2737
  if (peg$silentFails === 0) {
2873
- peg$fail(peg$e33);
2738
+ peg$fail(peg$e29);
2874
2739
  }
2875
2740
  }
2876
2741
  if (s3 === peg$FAILED) {
2877
2742
  s3 = input.charAt(peg$currPos);
2878
- if (peg$r20.test(s3)) {
2743
+ if (peg$r18.test(s3)) {
2879
2744
  peg$currPos++;
2880
2745
  } else {
2881
2746
  s3 = peg$FAILED;
2882
2747
  if (peg$silentFails === 0) {
2883
- peg$fail(peg$e34);
2748
+ peg$fail(peg$e30);
2884
2749
  }
2885
2750
  }
2886
2751
  }
2887
2752
  }
2888
2753
  s3 = input.charAt(peg$currPos);
2889
- if (peg$r19.test(s3)) {
2754
+ if (peg$r17.test(s3)) {
2890
2755
  peg$currPos++;
2891
2756
  } else {
2892
2757
  s3 = peg$FAILED;
2893
2758
  if (peg$silentFails === 0) {
2894
- peg$fail(peg$e32);
2759
+ peg$fail(peg$e28);
2895
2760
  }
2896
2761
  }
2897
2762
  if (s3 !== peg$FAILED) {
2898
2763
  peg$savedPos = s0;
2899
- s0 = peg$f22(s1);
2764
+ s0 = peg$f21(s1);
2900
2765
  } else {
2901
2766
  peg$currPos = s0;
2902
2767
  s0 = peg$FAILED;
@@ -2927,57 +2792,57 @@ function peg$parse(input, options) {
2927
2792
  let s0, s1, s2, s3, s4, s5;
2928
2793
  s0 = peg$currPos;
2929
2794
  s1 = input.charAt(peg$currPos);
2930
- if (peg$r17.test(s1)) {
2795
+ if (peg$r15.test(s1)) {
2931
2796
  peg$currPos++;
2932
2797
  } else {
2933
2798
  s1 = peg$FAILED;
2934
2799
  if (peg$silentFails === 0) {
2935
- peg$fail(peg$e29);
2800
+ peg$fail(peg$e25);
2936
2801
  }
2937
2802
  }
2938
2803
  if (s1 !== peg$FAILED) {
2939
2804
  s2 = [];
2940
2805
  s3 = peg$currPos;
2941
2806
  s4 = [];
2942
- if (input.substr(peg$currPos, 2) === peg$c12) {
2943
- s5 = peg$c12;
2807
+ if (input.substr(peg$currPos, 2) === peg$c10) {
2808
+ s5 = peg$c10;
2944
2809
  peg$currPos += 2;
2945
2810
  } else {
2946
2811
  s5 = peg$FAILED;
2947
2812
  if (peg$silentFails === 0) {
2948
- peg$fail(peg$e30);
2813
+ peg$fail(peg$e26);
2949
2814
  }
2950
2815
  }
2951
2816
  if (s5 === peg$FAILED) {
2952
2817
  s5 = input.charAt(peg$currPos);
2953
- if (peg$r18.test(s5)) {
2818
+ if (peg$r16.test(s5)) {
2954
2819
  peg$currPos++;
2955
2820
  } else {
2956
2821
  s5 = peg$FAILED;
2957
2822
  if (peg$silentFails === 0) {
2958
- peg$fail(peg$e31);
2823
+ peg$fail(peg$e27);
2959
2824
  }
2960
2825
  }
2961
2826
  }
2962
2827
  while (s5 !== peg$FAILED) {
2963
2828
  s4.push(s5);
2964
- if (input.substr(peg$currPos, 2) === peg$c12) {
2965
- s5 = peg$c12;
2829
+ if (input.substr(peg$currPos, 2) === peg$c10) {
2830
+ s5 = peg$c10;
2966
2831
  peg$currPos += 2;
2967
2832
  } else {
2968
2833
  s5 = peg$FAILED;
2969
2834
  if (peg$silentFails === 0) {
2970
- peg$fail(peg$e30);
2835
+ peg$fail(peg$e26);
2971
2836
  }
2972
2837
  }
2973
2838
  if (s5 === peg$FAILED) {
2974
2839
  s5 = input.charAt(peg$currPos);
2975
- if (peg$r18.test(s5)) {
2840
+ if (peg$r16.test(s5)) {
2976
2841
  peg$currPos++;
2977
2842
  } else {
2978
2843
  s5 = peg$FAILED;
2979
2844
  if (peg$silentFails === 0) {
2980
- peg$fail(peg$e31);
2845
+ peg$fail(peg$e27);
2981
2846
  }
2982
2847
  }
2983
2848
  }
@@ -3003,45 +2868,45 @@ function peg$parse(input, options) {
3003
2868
  s2.push(s3);
3004
2869
  s3 = peg$currPos;
3005
2870
  s4 = [];
3006
- if (input.substr(peg$currPos, 2) === peg$c12) {
3007
- s5 = peg$c12;
2871
+ if (input.substr(peg$currPos, 2) === peg$c10) {
2872
+ s5 = peg$c10;
3008
2873
  peg$currPos += 2;
3009
2874
  } else {
3010
2875
  s5 = peg$FAILED;
3011
2876
  if (peg$silentFails === 0) {
3012
- peg$fail(peg$e30);
2877
+ peg$fail(peg$e26);
3013
2878
  }
3014
2879
  }
3015
2880
  if (s5 === peg$FAILED) {
3016
2881
  s5 = input.charAt(peg$currPos);
3017
- if (peg$r18.test(s5)) {
2882
+ if (peg$r16.test(s5)) {
3018
2883
  peg$currPos++;
3019
2884
  } else {
3020
2885
  s5 = peg$FAILED;
3021
2886
  if (peg$silentFails === 0) {
3022
- peg$fail(peg$e31);
2887
+ peg$fail(peg$e27);
3023
2888
  }
3024
2889
  }
3025
2890
  }
3026
2891
  while (s5 !== peg$FAILED) {
3027
2892
  s4.push(s5);
3028
- if (input.substr(peg$currPos, 2) === peg$c12) {
3029
- s5 = peg$c12;
2893
+ if (input.substr(peg$currPos, 2) === peg$c10) {
2894
+ s5 = peg$c10;
3030
2895
  peg$currPos += 2;
3031
2896
  } else {
3032
2897
  s5 = peg$FAILED;
3033
2898
  if (peg$silentFails === 0) {
3034
- peg$fail(peg$e30);
2899
+ peg$fail(peg$e26);
3035
2900
  }
3036
2901
  }
3037
2902
  if (s5 === peg$FAILED) {
3038
2903
  s5 = input.charAt(peg$currPos);
3039
- if (peg$r18.test(s5)) {
2904
+ if (peg$r16.test(s5)) {
3040
2905
  peg$currPos++;
3041
2906
  } else {
3042
2907
  s5 = peg$FAILED;
3043
2908
  if (peg$silentFails === 0) {
3044
- peg$fail(peg$e31);
2909
+ peg$fail(peg$e27);
3045
2910
  }
3046
2911
  }
3047
2912
  }
@@ -3068,61 +2933,61 @@ function peg$parse(input, options) {
3068
2933
  }
3069
2934
  if (s2 !== peg$FAILED) {
3070
2935
  s3 = [];
3071
- if (input.substr(peg$currPos, 2) === peg$c12) {
3072
- s4 = peg$c12;
2936
+ if (input.substr(peg$currPos, 2) === peg$c10) {
2937
+ s4 = peg$c10;
3073
2938
  peg$currPos += 2;
3074
2939
  } else {
3075
2940
  s4 = peg$FAILED;
3076
2941
  if (peg$silentFails === 0) {
3077
- peg$fail(peg$e30);
2942
+ peg$fail(peg$e26);
3078
2943
  }
3079
2944
  }
3080
2945
  if (s4 === peg$FAILED) {
3081
2946
  s4 = input.charAt(peg$currPos);
3082
- if (peg$r18.test(s4)) {
2947
+ if (peg$r16.test(s4)) {
3083
2948
  peg$currPos++;
3084
2949
  } else {
3085
2950
  s4 = peg$FAILED;
3086
2951
  if (peg$silentFails === 0) {
3087
- peg$fail(peg$e31);
2952
+ peg$fail(peg$e27);
3088
2953
  }
3089
2954
  }
3090
2955
  }
3091
2956
  while (s4 !== peg$FAILED) {
3092
2957
  s3.push(s4);
3093
- if (input.substr(peg$currPos, 2) === peg$c12) {
3094
- s4 = peg$c12;
2958
+ if (input.substr(peg$currPos, 2) === peg$c10) {
2959
+ s4 = peg$c10;
3095
2960
  peg$currPos += 2;
3096
2961
  } else {
3097
2962
  s4 = peg$FAILED;
3098
2963
  if (peg$silentFails === 0) {
3099
- peg$fail(peg$e30);
2964
+ peg$fail(peg$e26);
3100
2965
  }
3101
2966
  }
3102
2967
  if (s4 === peg$FAILED) {
3103
2968
  s4 = input.charAt(peg$currPos);
3104
- if (peg$r18.test(s4)) {
2969
+ if (peg$r16.test(s4)) {
3105
2970
  peg$currPos++;
3106
2971
  } else {
3107
2972
  s4 = peg$FAILED;
3108
2973
  if (peg$silentFails === 0) {
3109
- peg$fail(peg$e31);
2974
+ peg$fail(peg$e27);
3110
2975
  }
3111
2976
  }
3112
2977
  }
3113
2978
  }
3114
2979
  s4 = input.charAt(peg$currPos);
3115
- if (peg$r17.test(s4)) {
2980
+ if (peg$r15.test(s4)) {
3116
2981
  peg$currPos++;
3117
2982
  } else {
3118
2983
  s4 = peg$FAILED;
3119
2984
  if (peg$silentFails === 0) {
3120
- peg$fail(peg$e29);
2985
+ peg$fail(peg$e25);
3121
2986
  }
3122
2987
  }
3123
2988
  if (s4 !== peg$FAILED) {
3124
2989
  peg$savedPos = s0;
3125
- s0 = peg$f23(s1);
2990
+ s0 = peg$f22(s1);
3126
2991
  } else {
3127
2992
  peg$currPos = s0;
3128
2993
  s0 = peg$FAILED;
@@ -3142,57 +3007,57 @@ function peg$parse(input, options) {
3142
3007
  let s0, s1, s2, s3, s4, s5;
3143
3008
  s0 = peg$currPos;
3144
3009
  s1 = input.charAt(peg$currPos);
3145
- if (peg$r15.test(s1)) {
3010
+ if (peg$r13.test(s1)) {
3146
3011
  peg$currPos++;
3147
3012
  } else {
3148
3013
  s1 = peg$FAILED;
3149
3014
  if (peg$silentFails === 0) {
3150
- peg$fail(peg$e26);
3015
+ peg$fail(peg$e22);
3151
3016
  }
3152
3017
  }
3153
3018
  if (s1 !== peg$FAILED) {
3154
3019
  s2 = [];
3155
3020
  s3 = peg$currPos;
3156
3021
  s4 = [];
3157
- if (input.substr(peg$currPos, 2) === peg$c11) {
3158
- s5 = peg$c11;
3022
+ if (input.substr(peg$currPos, 2) === peg$c9) {
3023
+ s5 = peg$c9;
3159
3024
  peg$currPos += 2;
3160
3025
  } else {
3161
3026
  s5 = peg$FAILED;
3162
3027
  if (peg$silentFails === 0) {
3163
- peg$fail(peg$e27);
3028
+ peg$fail(peg$e23);
3164
3029
  }
3165
3030
  }
3166
3031
  if (s5 === peg$FAILED) {
3167
3032
  s5 = input.charAt(peg$currPos);
3168
- if (peg$r16.test(s5)) {
3033
+ if (peg$r14.test(s5)) {
3169
3034
  peg$currPos++;
3170
3035
  } else {
3171
3036
  s5 = peg$FAILED;
3172
3037
  if (peg$silentFails === 0) {
3173
- peg$fail(peg$e28);
3038
+ peg$fail(peg$e24);
3174
3039
  }
3175
3040
  }
3176
3041
  }
3177
3042
  while (s5 !== peg$FAILED) {
3178
3043
  s4.push(s5);
3179
- if (input.substr(peg$currPos, 2) === peg$c11) {
3180
- s5 = peg$c11;
3044
+ if (input.substr(peg$currPos, 2) === peg$c9) {
3045
+ s5 = peg$c9;
3181
3046
  peg$currPos += 2;
3182
3047
  } else {
3183
3048
  s5 = peg$FAILED;
3184
3049
  if (peg$silentFails === 0) {
3185
- peg$fail(peg$e27);
3050
+ peg$fail(peg$e23);
3186
3051
  }
3187
3052
  }
3188
3053
  if (s5 === peg$FAILED) {
3189
3054
  s5 = input.charAt(peg$currPos);
3190
- if (peg$r16.test(s5)) {
3055
+ if (peg$r14.test(s5)) {
3191
3056
  peg$currPos++;
3192
3057
  } else {
3193
3058
  s5 = peg$FAILED;
3194
3059
  if (peg$silentFails === 0) {
3195
- peg$fail(peg$e28);
3060
+ peg$fail(peg$e24);
3196
3061
  }
3197
3062
  }
3198
3063
  }
@@ -3218,45 +3083,45 @@ function peg$parse(input, options) {
3218
3083
  s2.push(s3);
3219
3084
  s3 = peg$currPos;
3220
3085
  s4 = [];
3221
- if (input.substr(peg$currPos, 2) === peg$c11) {
3222
- s5 = peg$c11;
3086
+ if (input.substr(peg$currPos, 2) === peg$c9) {
3087
+ s5 = peg$c9;
3223
3088
  peg$currPos += 2;
3224
3089
  } else {
3225
3090
  s5 = peg$FAILED;
3226
3091
  if (peg$silentFails === 0) {
3227
- peg$fail(peg$e27);
3092
+ peg$fail(peg$e23);
3228
3093
  }
3229
3094
  }
3230
3095
  if (s5 === peg$FAILED) {
3231
3096
  s5 = input.charAt(peg$currPos);
3232
- if (peg$r16.test(s5)) {
3097
+ if (peg$r14.test(s5)) {
3233
3098
  peg$currPos++;
3234
3099
  } else {
3235
3100
  s5 = peg$FAILED;
3236
3101
  if (peg$silentFails === 0) {
3237
- peg$fail(peg$e28);
3102
+ peg$fail(peg$e24);
3238
3103
  }
3239
3104
  }
3240
3105
  }
3241
3106
  while (s5 !== peg$FAILED) {
3242
3107
  s4.push(s5);
3243
- if (input.substr(peg$currPos, 2) === peg$c11) {
3244
- s5 = peg$c11;
3108
+ if (input.substr(peg$currPos, 2) === peg$c9) {
3109
+ s5 = peg$c9;
3245
3110
  peg$currPos += 2;
3246
3111
  } else {
3247
3112
  s5 = peg$FAILED;
3248
3113
  if (peg$silentFails === 0) {
3249
- peg$fail(peg$e27);
3114
+ peg$fail(peg$e23);
3250
3115
  }
3251
3116
  }
3252
3117
  if (s5 === peg$FAILED) {
3253
3118
  s5 = input.charAt(peg$currPos);
3254
- if (peg$r16.test(s5)) {
3119
+ if (peg$r14.test(s5)) {
3255
3120
  peg$currPos++;
3256
3121
  } else {
3257
3122
  s5 = peg$FAILED;
3258
3123
  if (peg$silentFails === 0) {
3259
- peg$fail(peg$e28);
3124
+ peg$fail(peg$e24);
3260
3125
  }
3261
3126
  }
3262
3127
  }
@@ -3283,61 +3148,61 @@ function peg$parse(input, options) {
3283
3148
  }
3284
3149
  if (s2 !== peg$FAILED) {
3285
3150
  s3 = [];
3286
- if (input.substr(peg$currPos, 2) === peg$c11) {
3287
- s4 = peg$c11;
3151
+ if (input.substr(peg$currPos, 2) === peg$c9) {
3152
+ s4 = peg$c9;
3288
3153
  peg$currPos += 2;
3289
3154
  } else {
3290
3155
  s4 = peg$FAILED;
3291
3156
  if (peg$silentFails === 0) {
3292
- peg$fail(peg$e27);
3157
+ peg$fail(peg$e23);
3293
3158
  }
3294
3159
  }
3295
3160
  if (s4 === peg$FAILED) {
3296
3161
  s4 = input.charAt(peg$currPos);
3297
- if (peg$r16.test(s4)) {
3162
+ if (peg$r14.test(s4)) {
3298
3163
  peg$currPos++;
3299
3164
  } else {
3300
3165
  s4 = peg$FAILED;
3301
3166
  if (peg$silentFails === 0) {
3302
- peg$fail(peg$e28);
3167
+ peg$fail(peg$e24);
3303
3168
  }
3304
3169
  }
3305
3170
  }
3306
3171
  while (s4 !== peg$FAILED) {
3307
3172
  s3.push(s4);
3308
- if (input.substr(peg$currPos, 2) === peg$c11) {
3309
- s4 = peg$c11;
3173
+ if (input.substr(peg$currPos, 2) === peg$c9) {
3174
+ s4 = peg$c9;
3310
3175
  peg$currPos += 2;
3311
3176
  } else {
3312
3177
  s4 = peg$FAILED;
3313
3178
  if (peg$silentFails === 0) {
3314
- peg$fail(peg$e27);
3179
+ peg$fail(peg$e23);
3315
3180
  }
3316
3181
  }
3317
3182
  if (s4 === peg$FAILED) {
3318
3183
  s4 = input.charAt(peg$currPos);
3319
- if (peg$r16.test(s4)) {
3184
+ if (peg$r14.test(s4)) {
3320
3185
  peg$currPos++;
3321
3186
  } else {
3322
3187
  s4 = peg$FAILED;
3323
3188
  if (peg$silentFails === 0) {
3324
- peg$fail(peg$e28);
3189
+ peg$fail(peg$e24);
3325
3190
  }
3326
3191
  }
3327
3192
  }
3328
3193
  }
3329
3194
  s4 = input.charAt(peg$currPos);
3330
- if (peg$r15.test(s4)) {
3195
+ if (peg$r13.test(s4)) {
3331
3196
  peg$currPos++;
3332
3197
  } else {
3333
3198
  s4 = peg$FAILED;
3334
3199
  if (peg$silentFails === 0) {
3335
- peg$fail(peg$e26);
3200
+ peg$fail(peg$e22);
3336
3201
  }
3337
3202
  }
3338
3203
  if (s4 !== peg$FAILED) {
3339
3204
  peg$savedPos = s0;
3340
- s0 = peg$f24(s1);
3205
+ s0 = peg$f23(s1);
3341
3206
  } else {
3342
3207
  peg$currPos = s0;
3343
3208
  s0 = peg$FAILED;
@@ -3356,39 +3221,39 @@ function peg$parse(input, options) {
3356
3221
  function peg$parsetripleDQuotedMultiLineString() {
3357
3222
  let s0, s1, s2, s3, s4, s5, s6, s7;
3358
3223
  s0 = peg$currPos;
3359
- if (input.substr(peg$currPos, 3) === peg$c14) {
3360
- s1 = peg$c14;
3224
+ if (input.substr(peg$currPos, 3) === peg$c12) {
3225
+ s1 = peg$c12;
3361
3226
  peg$currPos += 3;
3362
3227
  } else {
3363
3228
  s1 = peg$FAILED;
3364
3229
  if (peg$silentFails === 0) {
3365
- peg$fail(peg$e35);
3230
+ peg$fail(peg$e31);
3366
3231
  }
3367
3232
  }
3368
3233
  if (s1 !== peg$FAILED) {
3369
3234
  s2 = [];
3370
3235
  s3 = peg$currPos;
3371
3236
  s4 = [];
3372
- if (input.substr(peg$currPos, 4) === peg$c15) {
3373
- s5 = peg$c15;
3237
+ if (input.substr(peg$currPos, 4) === peg$c13) {
3238
+ s5 = peg$c13;
3374
3239
  peg$currPos += 4;
3375
3240
  } else {
3376
3241
  s5 = peg$FAILED;
3377
3242
  if (peg$silentFails === 0) {
3378
- peg$fail(peg$e36);
3243
+ peg$fail(peg$e32);
3379
3244
  }
3380
3245
  }
3381
3246
  if (s5 === peg$FAILED) {
3382
3247
  s5 = peg$currPos;
3383
3248
  s6 = peg$currPos;
3384
3249
  peg$silentFails++;
3385
- if (input.substr(peg$currPos, 3) === peg$c14) {
3386
- s7 = peg$c14;
3250
+ if (input.substr(peg$currPos, 3) === peg$c12) {
3251
+ s7 = peg$c12;
3387
3252
  peg$currPos += 3;
3388
3253
  } else {
3389
3254
  s7 = peg$FAILED;
3390
3255
  if (peg$silentFails === 0) {
3391
- peg$fail(peg$e35);
3256
+ peg$fail(peg$e31);
3392
3257
  }
3393
3258
  }
3394
3259
  peg$silentFails--;
@@ -3422,26 +3287,26 @@ function peg$parse(input, options) {
3422
3287
  }
3423
3288
  while (s5 !== peg$FAILED) {
3424
3289
  s4.push(s5);
3425
- if (input.substr(peg$currPos, 4) === peg$c15) {
3426
- s5 = peg$c15;
3290
+ if (input.substr(peg$currPos, 4) === peg$c13) {
3291
+ s5 = peg$c13;
3427
3292
  peg$currPos += 4;
3428
3293
  } else {
3429
3294
  s5 = peg$FAILED;
3430
3295
  if (peg$silentFails === 0) {
3431
- peg$fail(peg$e36);
3296
+ peg$fail(peg$e32);
3432
3297
  }
3433
3298
  }
3434
3299
  if (s5 === peg$FAILED) {
3435
3300
  s5 = peg$currPos;
3436
3301
  s6 = peg$currPos;
3437
3302
  peg$silentFails++;
3438
- if (input.substr(peg$currPos, 3) === peg$c14) {
3439
- s7 = peg$c14;
3303
+ if (input.substr(peg$currPos, 3) === peg$c12) {
3304
+ s7 = peg$c12;
3440
3305
  peg$currPos += 3;
3441
3306
  } else {
3442
3307
  s7 = peg$FAILED;
3443
3308
  if (peg$silentFails === 0) {
3444
- peg$fail(peg$e35);
3309
+ peg$fail(peg$e31);
3445
3310
  }
3446
3311
  }
3447
3312
  peg$silentFails--;
@@ -3495,26 +3360,26 @@ function peg$parse(input, options) {
3495
3360
  s2.push(s3);
3496
3361
  s3 = peg$currPos;
3497
3362
  s4 = [];
3498
- if (input.substr(peg$currPos, 4) === peg$c15) {
3499
- s5 = peg$c15;
3363
+ if (input.substr(peg$currPos, 4) === peg$c13) {
3364
+ s5 = peg$c13;
3500
3365
  peg$currPos += 4;
3501
3366
  } else {
3502
3367
  s5 = peg$FAILED;
3503
3368
  if (peg$silentFails === 0) {
3504
- peg$fail(peg$e36);
3369
+ peg$fail(peg$e32);
3505
3370
  }
3506
3371
  }
3507
3372
  if (s5 === peg$FAILED) {
3508
3373
  s5 = peg$currPos;
3509
3374
  s6 = peg$currPos;
3510
3375
  peg$silentFails++;
3511
- if (input.substr(peg$currPos, 3) === peg$c14) {
3512
- s7 = peg$c14;
3376
+ if (input.substr(peg$currPos, 3) === peg$c12) {
3377
+ s7 = peg$c12;
3513
3378
  peg$currPos += 3;
3514
3379
  } else {
3515
3380
  s7 = peg$FAILED;
3516
3381
  if (peg$silentFails === 0) {
3517
- peg$fail(peg$e35);
3382
+ peg$fail(peg$e31);
3518
3383
  }
3519
3384
  }
3520
3385
  peg$silentFails--;
@@ -3548,26 +3413,26 @@ function peg$parse(input, options) {
3548
3413
  }
3549
3414
  while (s5 !== peg$FAILED) {
3550
3415
  s4.push(s5);
3551
- if (input.substr(peg$currPos, 4) === peg$c15) {
3552
- s5 = peg$c15;
3416
+ if (input.substr(peg$currPos, 4) === peg$c13) {
3417
+ s5 = peg$c13;
3553
3418
  peg$currPos += 4;
3554
3419
  } else {
3555
3420
  s5 = peg$FAILED;
3556
3421
  if (peg$silentFails === 0) {
3557
- peg$fail(peg$e36);
3422
+ peg$fail(peg$e32);
3558
3423
  }
3559
3424
  }
3560
3425
  if (s5 === peg$FAILED) {
3561
3426
  s5 = peg$currPos;
3562
3427
  s6 = peg$currPos;
3563
3428
  peg$silentFails++;
3564
- if (input.substr(peg$currPos, 3) === peg$c14) {
3565
- s7 = peg$c14;
3429
+ if (input.substr(peg$currPos, 3) === peg$c12) {
3430
+ s7 = peg$c12;
3566
3431
  peg$currPos += 3;
3567
3432
  } else {
3568
3433
  s7 = peg$FAILED;
3569
3434
  if (peg$silentFails === 0) {
3570
- peg$fail(peg$e35);
3435
+ peg$fail(peg$e31);
3571
3436
  }
3572
3437
  }
3573
3438
  peg$silentFails--;
@@ -3622,26 +3487,26 @@ function peg$parse(input, options) {
3622
3487
  }
3623
3488
  if (s2 !== peg$FAILED) {
3624
3489
  s3 = [];
3625
- if (input.substr(peg$currPos, 4) === peg$c15) {
3626
- s4 = peg$c15;
3490
+ if (input.substr(peg$currPos, 4) === peg$c13) {
3491
+ s4 = peg$c13;
3627
3492
  peg$currPos += 4;
3628
3493
  } else {
3629
3494
  s4 = peg$FAILED;
3630
3495
  if (peg$silentFails === 0) {
3631
- peg$fail(peg$e36);
3496
+ peg$fail(peg$e32);
3632
3497
  }
3633
3498
  }
3634
3499
  if (s4 === peg$FAILED) {
3635
3500
  s4 = peg$currPos;
3636
3501
  s5 = peg$currPos;
3637
3502
  peg$silentFails++;
3638
- if (input.substr(peg$currPos, 3) === peg$c14) {
3639
- s6 = peg$c14;
3503
+ if (input.substr(peg$currPos, 3) === peg$c12) {
3504
+ s6 = peg$c12;
3640
3505
  peg$currPos += 3;
3641
3506
  } else {
3642
3507
  s6 = peg$FAILED;
3643
3508
  if (peg$silentFails === 0) {
3644
- peg$fail(peg$e35);
3509
+ peg$fail(peg$e31);
3645
3510
  }
3646
3511
  }
3647
3512
  peg$silentFails--;
@@ -3675,26 +3540,26 @@ function peg$parse(input, options) {
3675
3540
  }
3676
3541
  while (s4 !== peg$FAILED) {
3677
3542
  s3.push(s4);
3678
- if (input.substr(peg$currPos, 4) === peg$c15) {
3679
- s4 = peg$c15;
3543
+ if (input.substr(peg$currPos, 4) === peg$c13) {
3544
+ s4 = peg$c13;
3680
3545
  peg$currPos += 4;
3681
3546
  } else {
3682
3547
  s4 = peg$FAILED;
3683
3548
  if (peg$silentFails === 0) {
3684
- peg$fail(peg$e36);
3549
+ peg$fail(peg$e32);
3685
3550
  }
3686
3551
  }
3687
3552
  if (s4 === peg$FAILED) {
3688
3553
  s4 = peg$currPos;
3689
3554
  s5 = peg$currPos;
3690
3555
  peg$silentFails++;
3691
- if (input.substr(peg$currPos, 3) === peg$c14) {
3692
- s6 = peg$c14;
3556
+ if (input.substr(peg$currPos, 3) === peg$c12) {
3557
+ s6 = peg$c12;
3693
3558
  peg$currPos += 3;
3694
3559
  } else {
3695
3560
  s6 = peg$FAILED;
3696
3561
  if (peg$silentFails === 0) {
3697
- peg$fail(peg$e35);
3562
+ peg$fail(peg$e31);
3698
3563
  }
3699
3564
  }
3700
3565
  peg$silentFails--;
@@ -3727,18 +3592,18 @@ function peg$parse(input, options) {
3727
3592
  }
3728
3593
  }
3729
3594
  }
3730
- if (input.substr(peg$currPos, 3) === peg$c14) {
3731
- s4 = peg$c14;
3595
+ if (input.substr(peg$currPos, 3) === peg$c12) {
3596
+ s4 = peg$c12;
3732
3597
  peg$currPos += 3;
3733
3598
  } else {
3734
3599
  s4 = peg$FAILED;
3735
3600
  if (peg$silentFails === 0) {
3736
- peg$fail(peg$e35);
3601
+ peg$fail(peg$e31);
3737
3602
  }
3738
3603
  }
3739
3604
  if (s4 !== peg$FAILED) {
3740
3605
  peg$savedPos = s0;
3741
- s0 = peg$f25(s1);
3606
+ s0 = peg$f24(s1);
3742
3607
  } else {
3743
3608
  peg$currPos = s0;
3744
3609
  s0 = peg$FAILED;
@@ -3757,39 +3622,39 @@ function peg$parse(input, options) {
3757
3622
  function peg$parsetripleBQuotedMultiLineString() {
3758
3623
  let s0, s1, s2, s3, s4, s5, s6, s7;
3759
3624
  s0 = peg$currPos;
3760
- if (input.substr(peg$currPos, 3) === peg$c16) {
3761
- s1 = peg$c16;
3625
+ if (input.substr(peg$currPos, 3) === peg$c14) {
3626
+ s1 = peg$c14;
3762
3627
  peg$currPos += 3;
3763
3628
  } else {
3764
3629
  s1 = peg$FAILED;
3765
3630
  if (peg$silentFails === 0) {
3766
- peg$fail(peg$e37);
3631
+ peg$fail(peg$e33);
3767
3632
  }
3768
3633
  }
3769
3634
  if (s1 !== peg$FAILED) {
3770
3635
  s2 = [];
3771
3636
  s3 = peg$currPos;
3772
3637
  s4 = [];
3773
- if (input.substr(peg$currPos, 4) === peg$c17) {
3774
- s5 = peg$c17;
3638
+ if (input.substr(peg$currPos, 4) === peg$c15) {
3639
+ s5 = peg$c15;
3775
3640
  peg$currPos += 4;
3776
3641
  } else {
3777
3642
  s5 = peg$FAILED;
3778
3643
  if (peg$silentFails === 0) {
3779
- peg$fail(peg$e38);
3644
+ peg$fail(peg$e34);
3780
3645
  }
3781
3646
  }
3782
3647
  if (s5 === peg$FAILED) {
3783
3648
  s5 = peg$currPos;
3784
3649
  s6 = peg$currPos;
3785
3650
  peg$silentFails++;
3786
- if (input.substr(peg$currPos, 3) === peg$c16) {
3787
- s7 = peg$c16;
3651
+ if (input.substr(peg$currPos, 3) === peg$c14) {
3652
+ s7 = peg$c14;
3788
3653
  peg$currPos += 3;
3789
3654
  } else {
3790
3655
  s7 = peg$FAILED;
3791
3656
  if (peg$silentFails === 0) {
3792
- peg$fail(peg$e37);
3657
+ peg$fail(peg$e33);
3793
3658
  }
3794
3659
  }
3795
3660
  peg$silentFails--;
@@ -3823,26 +3688,26 @@ function peg$parse(input, options) {
3823
3688
  }
3824
3689
  while (s5 !== peg$FAILED) {
3825
3690
  s4.push(s5);
3826
- if (input.substr(peg$currPos, 4) === peg$c17) {
3827
- s5 = peg$c17;
3691
+ if (input.substr(peg$currPos, 4) === peg$c15) {
3692
+ s5 = peg$c15;
3828
3693
  peg$currPos += 4;
3829
3694
  } else {
3830
3695
  s5 = peg$FAILED;
3831
3696
  if (peg$silentFails === 0) {
3832
- peg$fail(peg$e38);
3697
+ peg$fail(peg$e34);
3833
3698
  }
3834
3699
  }
3835
3700
  if (s5 === peg$FAILED) {
3836
3701
  s5 = peg$currPos;
3837
3702
  s6 = peg$currPos;
3838
3703
  peg$silentFails++;
3839
- if (input.substr(peg$currPos, 3) === peg$c16) {
3840
- s7 = peg$c16;
3704
+ if (input.substr(peg$currPos, 3) === peg$c14) {
3705
+ s7 = peg$c14;
3841
3706
  peg$currPos += 3;
3842
3707
  } else {
3843
3708
  s7 = peg$FAILED;
3844
3709
  if (peg$silentFails === 0) {
3845
- peg$fail(peg$e37);
3710
+ peg$fail(peg$e33);
3846
3711
  }
3847
3712
  }
3848
3713
  peg$silentFails--;
@@ -3896,26 +3761,26 @@ function peg$parse(input, options) {
3896
3761
  s2.push(s3);
3897
3762
  s3 = peg$currPos;
3898
3763
  s4 = [];
3899
- if (input.substr(peg$currPos, 4) === peg$c17) {
3900
- s5 = peg$c17;
3764
+ if (input.substr(peg$currPos, 4) === peg$c15) {
3765
+ s5 = peg$c15;
3901
3766
  peg$currPos += 4;
3902
3767
  } else {
3903
3768
  s5 = peg$FAILED;
3904
3769
  if (peg$silentFails === 0) {
3905
- peg$fail(peg$e38);
3770
+ peg$fail(peg$e34);
3906
3771
  }
3907
3772
  }
3908
3773
  if (s5 === peg$FAILED) {
3909
3774
  s5 = peg$currPos;
3910
3775
  s6 = peg$currPos;
3911
3776
  peg$silentFails++;
3912
- if (input.substr(peg$currPos, 3) === peg$c16) {
3913
- s7 = peg$c16;
3777
+ if (input.substr(peg$currPos, 3) === peg$c14) {
3778
+ s7 = peg$c14;
3914
3779
  peg$currPos += 3;
3915
3780
  } else {
3916
3781
  s7 = peg$FAILED;
3917
3782
  if (peg$silentFails === 0) {
3918
- peg$fail(peg$e37);
3783
+ peg$fail(peg$e33);
3919
3784
  }
3920
3785
  }
3921
3786
  peg$silentFails--;
@@ -3949,26 +3814,26 @@ function peg$parse(input, options) {
3949
3814
  }
3950
3815
  while (s5 !== peg$FAILED) {
3951
3816
  s4.push(s5);
3952
- if (input.substr(peg$currPos, 4) === peg$c17) {
3953
- s5 = peg$c17;
3817
+ if (input.substr(peg$currPos, 4) === peg$c15) {
3818
+ s5 = peg$c15;
3954
3819
  peg$currPos += 4;
3955
3820
  } else {
3956
3821
  s5 = peg$FAILED;
3957
3822
  if (peg$silentFails === 0) {
3958
- peg$fail(peg$e38);
3823
+ peg$fail(peg$e34);
3959
3824
  }
3960
3825
  }
3961
3826
  if (s5 === peg$FAILED) {
3962
3827
  s5 = peg$currPos;
3963
3828
  s6 = peg$currPos;
3964
3829
  peg$silentFails++;
3965
- if (input.substr(peg$currPos, 3) === peg$c16) {
3966
- s7 = peg$c16;
3830
+ if (input.substr(peg$currPos, 3) === peg$c14) {
3831
+ s7 = peg$c14;
3967
3832
  peg$currPos += 3;
3968
3833
  } else {
3969
3834
  s7 = peg$FAILED;
3970
3835
  if (peg$silentFails === 0) {
3971
- peg$fail(peg$e37);
3836
+ peg$fail(peg$e33);
3972
3837
  }
3973
3838
  }
3974
3839
  peg$silentFails--;
@@ -4023,26 +3888,26 @@ function peg$parse(input, options) {
4023
3888
  }
4024
3889
  if (s2 !== peg$FAILED) {
4025
3890
  s3 = [];
4026
- if (input.substr(peg$currPos, 4) === peg$c17) {
4027
- s4 = peg$c17;
3891
+ if (input.substr(peg$currPos, 4) === peg$c15) {
3892
+ s4 = peg$c15;
4028
3893
  peg$currPos += 4;
4029
3894
  } else {
4030
3895
  s4 = peg$FAILED;
4031
3896
  if (peg$silentFails === 0) {
4032
- peg$fail(peg$e38);
3897
+ peg$fail(peg$e34);
4033
3898
  }
4034
3899
  }
4035
3900
  if (s4 === peg$FAILED) {
4036
3901
  s4 = peg$currPos;
4037
3902
  s5 = peg$currPos;
4038
3903
  peg$silentFails++;
4039
- if (input.substr(peg$currPos, 3) === peg$c16) {
4040
- s6 = peg$c16;
3904
+ if (input.substr(peg$currPos, 3) === peg$c14) {
3905
+ s6 = peg$c14;
4041
3906
  peg$currPos += 3;
4042
3907
  } else {
4043
3908
  s6 = peg$FAILED;
4044
3909
  if (peg$silentFails === 0) {
4045
- peg$fail(peg$e37);
3910
+ peg$fail(peg$e33);
4046
3911
  }
4047
3912
  }
4048
3913
  peg$silentFails--;
@@ -4076,26 +3941,26 @@ function peg$parse(input, options) {
4076
3941
  }
4077
3942
  while (s4 !== peg$FAILED) {
4078
3943
  s3.push(s4);
4079
- if (input.substr(peg$currPos, 4) === peg$c17) {
4080
- s4 = peg$c17;
3944
+ if (input.substr(peg$currPos, 4) === peg$c15) {
3945
+ s4 = peg$c15;
4081
3946
  peg$currPos += 4;
4082
3947
  } else {
4083
3948
  s4 = peg$FAILED;
4084
3949
  if (peg$silentFails === 0) {
4085
- peg$fail(peg$e38);
3950
+ peg$fail(peg$e34);
4086
3951
  }
4087
3952
  }
4088
3953
  if (s4 === peg$FAILED) {
4089
3954
  s4 = peg$currPos;
4090
3955
  s5 = peg$currPos;
4091
3956
  peg$silentFails++;
4092
- if (input.substr(peg$currPos, 3) === peg$c16) {
4093
- s6 = peg$c16;
3957
+ if (input.substr(peg$currPos, 3) === peg$c14) {
3958
+ s6 = peg$c14;
4094
3959
  peg$currPos += 3;
4095
3960
  } else {
4096
3961
  s6 = peg$FAILED;
4097
3962
  if (peg$silentFails === 0) {
4098
- peg$fail(peg$e37);
3963
+ peg$fail(peg$e33);
4099
3964
  }
4100
3965
  }
4101
3966
  peg$silentFails--;
@@ -4128,18 +3993,18 @@ function peg$parse(input, options) {
4128
3993
  }
4129
3994
  }
4130
3995
  }
4131
- if (input.substr(peg$currPos, 3) === peg$c16) {
4132
- s4 = peg$c16;
3996
+ if (input.substr(peg$currPos, 3) === peg$c14) {
3997
+ s4 = peg$c14;
4133
3998
  peg$currPos += 3;
4134
3999
  } else {
4135
4000
  s4 = peg$FAILED;
4136
4001
  if (peg$silentFails === 0) {
4137
- peg$fail(peg$e37);
4002
+ peg$fail(peg$e33);
4138
4003
  }
4139
4004
  }
4140
4005
  if (s4 !== peg$FAILED) {
4141
4006
  peg$savedPos = s0;
4142
- s0 = peg$f26(s1);
4007
+ s0 = peg$f25(s1);
4143
4008
  } else {
4144
4009
  peg$currPos = s0;
4145
4010
  s0 = peg$FAILED;
@@ -4175,7 +4040,7 @@ function peg$parse(input, options) {
4175
4040
  } else {
4176
4041
  s1 = peg$FAILED;
4177
4042
  if (peg$silentFails === 0) {
4178
- peg$fail(peg$e39);
4043
+ peg$fail(peg$e35);
4179
4044
  }
4180
4045
  }
4181
4046
  peg$silentFails--;