jssm 5.141.9 → 5.141.10

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/README.md +2 -2
  2. package/dist/cdn/instance.js +2 -969
  3. package/dist/cdn/viz.js +2 -969
  4. package/dist/cli/fsl-render.cjs +1 -1
  5. package/dist/cli/fsl.cjs +1 -1
  6. package/dist/deno/README.md +2 -2
  7. package/dist/deno/jssm.js +1 -1
  8. package/dist/jssm.es5.cjs +1 -1
  9. package/dist/jssm.es5.iife.js +1 -1
  10. package/dist/jssm.es6.mjs +1 -1
  11. package/dist/jssm_viz.cjs +1 -1
  12. package/dist/jssm_viz.iife.cjs +1 -1
  13. package/dist/jssm_viz.mjs +1 -1
  14. package/package.json +2 -2
package/dist/cdn/instance.js CHANGED
@@ -215,7 +215,6 @@ function arrow_right_kind(arrow) {
215
215
  }
216
216
  }
217
217
 
218
- // @ts-nocheck
219
218
  /*
220
219
  * Generated by PEG.js 0.10.0.
221
220
  *
@@ -433,7 +432,7 @@ function peg$parse(input, options) {
433
432
  return { key: 'state_property', name, value };
434
433
  }, peg$c1504 = "required", peg$c1505 = peg$literalExpectation("required", false), peg$c1506 = function (name, value) {
435
434
  return { key: 'state_property', name, value, required: true };
436
- }, peg$c1507 = function (name, value) { return { key: 'state_declaration', name, value }; }, peg$c1508 = "&", peg$c1509 = peg$literalExpectation("&", false), peg$c1510 = function (name, value) { return { key: 'named_list', name, value }; }, peg$c1511 = function (name, default_value) { return { key: 'property_definition', name, default_value, required: true }; }, peg$c1512 = function (name) { return { key: 'property_definition', name, required: true }; }, peg$c1513 = function (name, default_value) { return { key: 'property_definition', name, default_value }; }, peg$c1514 = function (name) { return { key: 'property_definition', name }; }, peg$c1515 = "arrange", peg$c1516 = peg$literalExpectation("arrange", false), peg$c1517 = function (value) { return { key: 'arrange_declaration', value }; }, peg$c1518 = "arrange-start", peg$c1519 = peg$literalExpectation("arrange-start", false), peg$c1520 = function (value) { return { key: 'arrange_start_declaration', value }; }, peg$c1521 = "arrange-end", peg$c1522 = peg$literalExpectation("arrange-end", false), peg$c1523 = function (value) { return { key: 'arrange_end_declaration', value }; }, peg$c1524 = peg$otherExpectation("arrange declaration"), peg$currPos = 0, peg$savedPos = 0, peg$posDetailsCache = [{ line: 1, column: 1 }], peg$maxFailPos = 0, peg$maxFailExpected = [], peg$silentFails = 0, peg$resultsCache = {}, peg$result;
435
+ }, peg$c1507 = function (name, value) { return { key: 'state_declaration', name, value }; }, peg$c1508 = "&", peg$c1509 = peg$literalExpectation("&", false), peg$c1510 = function (name, value) { return { key: 'named_list', name, value }; }, peg$c1511 = function (name, default_value) { return { key: 'property_definition', name, default_value, required: true }; }, peg$c1512 = function (name) { return { key: 'property_definition', name, required: true }; }, peg$c1513 = function (name, default_value) { return { key: 'property_definition', name, default_value }; }, peg$c1514 = function (name) { return { key: 'property_definition', name }; }, peg$c1515 = "arrange", peg$c1516 = peg$literalExpectation("arrange", false), peg$c1517 = function (value) { return { key: 'arrange_declaration', value }; }, peg$c1518 = "arrange-start", peg$c1519 = peg$literalExpectation("arrange-start", false), peg$c1520 = function (value) { return { key: 'arrange_start_declaration', value }; }, peg$c1521 = "arrange-end", peg$c1522 = peg$literalExpectation("arrange-end", false), peg$c1523 = function (value) { return { key: 'arrange_end_declaration', value }; }, peg$c1524 = peg$otherExpectation("arrange declaration"), peg$currPos = 0, peg$savedPos = 0, peg$posDetailsCache = [{ line: 1, column: 1 }], peg$maxFailPos = 0, peg$maxFailExpected = [], peg$silentFails = 0, peg$result;
437
436
  if ("startRule" in options) {
438
437
  if (!(options.startRule in peg$startRuleFunctions)) {
439
438
  throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
@@ -527,11 +526,6 @@ function peg$parse(input, options) {
527
526
  }
528
527
  function peg$parseDocument() {
529
528
  var s0, s1, s2, s3;
530
- var key = peg$currPos * 164 + 0, cached = peg$resultsCache[key];
531
- if (cached) {
532
- peg$currPos = cached.nextPos;
533
- return cached.result;
534
- }
535
529
  s0 = peg$currPos;
536
530
  s1 = peg$parseWS();
537
531
  if (s1 === peg$FAILED) {
@@ -563,16 +557,10 @@ function peg$parse(input, options) {
563
557
  peg$currPos = s0;
564
558
  s0 = peg$FAILED;
565
559
  }
566
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
567
560
  return s0;
568
561
  }
569
562
  function peg$parseTheme() {
570
563
  var s0;
571
- var key = peg$currPos * 164 + 1, cached = peg$resultsCache[key];
572
- if (cached) {
573
- peg$currPos = cached.nextPos;
574
- return cached.result;
575
- }
576
564
  if (input.substr(peg$currPos, 7) === peg$c1) {
577
565
  s0 = peg$c1;
578
566
  peg$currPos += 7;
@@ -631,16 +619,10 @@ function peg$parse(input, options) {
631
619
  }
632
620
  }
633
621
  }
634
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
635
622
  return s0;
636
623
  }
637
624
  function peg$parseThemeOrThemeList() {
638
625
  var s0, s1, s2, s3, s4, s5, s6;
639
- var key = peg$currPos * 164 + 2, cached = peg$resultsCache[key];
640
- if (cached) {
641
- peg$currPos = cached.nextPos;
642
- return cached.result;
643
- }
644
626
  s0 = peg$currPos;
645
627
  if (input.charCodeAt(peg$currPos) === 91) {
646
628
  s1 = peg$c11;
@@ -750,16 +732,10 @@ function peg$parse(input, options) {
750
732
  }
751
733
  s0 = s1;
752
734
  }
753
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
754
735
  return s0;
755
736
  }
756
737
  function peg$parseGvizShape() {
757
738
  var s0;
758
- var key = peg$currPos * 164 + 3, cached = peg$resultsCache[key];
759
- if (cached) {
760
- peg$currPos = cached.nextPos;
761
- return cached.result;
762
- }
763
739
  if (input.substr(peg$currPos, 5) === peg$c17) {
764
740
  s0 = peg$c17;
765
741
  peg$currPos += 5;
@@ -1478,16 +1454,10 @@ function peg$parse(input, options) {
1478
1454
  }
1479
1455
  }
1480
1456
  }
1481
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1482
1457
  return s0;
1483
1458
  }
1484
1459
  function peg$parseForwardLightArrow() {
1485
1460
  var s0, s1;
1486
- var key = peg$currPos * 164 + 4, cached = peg$resultsCache[key];
1487
- if (cached) {
1488
- peg$currPos = cached.nextPos;
1489
- return cached.result;
1490
- }
1491
1461
  peg$silentFails++;
1492
1462
  if (input.substr(peg$currPos, 2) === peg$c136) {
1493
1463
  s0 = peg$c136;
@@ -1524,16 +1494,10 @@ function peg$parse(input, options) {
1524
1494
  peg$fail(peg$c135);
1525
1495
  }
1526
1496
  }
1527
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1528
1497
  return s0;
1529
1498
  }
1530
1499
  function peg$parseTwoWayLightArrow() {
1531
1500
  var s0, s1;
1532
- var key = peg$currPos * 164 + 5, cached = peg$resultsCache[key];
1533
- if (cached) {
1534
- peg$currPos = cached.nextPos;
1535
- return cached.result;
1536
- }
1537
1501
  peg$silentFails++;
1538
1502
  if (input.substr(peg$currPos, 3) === peg$c142) {
1539
1503
  s0 = peg$c142;
@@ -1570,16 +1534,10 @@ function peg$parse(input, options) {
1570
1534
  peg$fail(peg$c141);
1571
1535
  }
1572
1536
  }
1573
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1574
1537
  return s0;
1575
1538
  }
1576
1539
  function peg$parseBackLightArrow() {
1577
1540
  var s0, s1;
1578
- var key = peg$currPos * 164 + 6, cached = peg$resultsCache[key];
1579
- if (cached) {
1580
- peg$currPos = cached.nextPos;
1581
- return cached.result;
1582
- }
1583
1541
  peg$silentFails++;
1584
1542
  if (input.substr(peg$currPos, 2) === peg$c148) {
1585
1543
  s0 = peg$c148;
@@ -1616,16 +1574,10 @@ function peg$parse(input, options) {
1616
1574
  peg$fail(peg$c147);
1617
1575
  }
1618
1576
  }
1619
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1620
1577
  return s0;
1621
1578
  }
1622
1579
  function peg$parseForwardFatArrow() {
1623
1580
  var s0, s1;
1624
- var key = peg$currPos * 164 + 7, cached = peg$resultsCache[key];
1625
- if (cached) {
1626
- peg$currPos = cached.nextPos;
1627
- return cached.result;
1628
- }
1629
1581
  peg$silentFails++;
1630
1582
  if (input.substr(peg$currPos, 2) === peg$c154) {
1631
1583
  s0 = peg$c154;
@@ -1662,16 +1614,10 @@ function peg$parse(input, options) {
1662
1614
  peg$fail(peg$c153);
1663
1615
  }
1664
1616
  }
1665
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1666
1617
  return s0;
1667
1618
  }
1668
1619
  function peg$parseTwoWayFatArrow() {
1669
1620
  var s0, s1;
1670
- var key = peg$currPos * 164 + 8, cached = peg$resultsCache[key];
1671
- if (cached) {
1672
- peg$currPos = cached.nextPos;
1673
- return cached.result;
1674
- }
1675
1621
  peg$silentFails++;
1676
1622
  if (input.substr(peg$currPos, 3) === peg$c160) {
1677
1623
  s0 = peg$c160;
@@ -1708,16 +1654,10 @@ function peg$parse(input, options) {
1708
1654
  peg$fail(peg$c159);
1709
1655
  }
1710
1656
  }
1711
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1712
1657
  return s0;
1713
1658
  }
1714
1659
  function peg$parseBackFatArrow() {
1715
1660
  var s0, s1;
1716
- var key = peg$currPos * 164 + 9, cached = peg$resultsCache[key];
1717
- if (cached) {
1718
- peg$currPos = cached.nextPos;
1719
- return cached.result;
1720
- }
1721
1661
  peg$silentFails++;
1722
1662
  if (input.substr(peg$currPos, 2) === peg$c166) {
1723
1663
  s0 = peg$c166;
@@ -1754,16 +1694,10 @@ function peg$parse(input, options) {
1754
1694
  peg$fail(peg$c165);
1755
1695
  }
1756
1696
  }
1757
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1758
1697
  return s0;
1759
1698
  }
1760
1699
  function peg$parseForwardTildeArrow() {
1761
1700
  var s0, s1;
1762
- var key = peg$currPos * 164 + 10, cached = peg$resultsCache[key];
1763
- if (cached) {
1764
- peg$currPos = cached.nextPos;
1765
- return cached.result;
1766
- }
1767
1701
  peg$silentFails++;
1768
1702
  if (input.substr(peg$currPos, 2) === peg$c172) {
1769
1703
  s0 = peg$c172;
@@ -1800,16 +1734,10 @@ function peg$parse(input, options) {
1800
1734
  peg$fail(peg$c171);
1801
1735
  }
1802
1736
  }
1803
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1804
1737
  return s0;
1805
1738
  }
1806
1739
  function peg$parseTwoWayTildeArrow() {
1807
1740
  var s0, s1;
1808
- var key = peg$currPos * 164 + 11, cached = peg$resultsCache[key];
1809
- if (cached) {
1810
- peg$currPos = cached.nextPos;
1811
- return cached.result;
1812
- }
1813
1741
  peg$silentFails++;
1814
1742
  if (input.substr(peg$currPos, 3) === peg$c178) {
1815
1743
  s0 = peg$c178;
@@ -1846,16 +1774,10 @@ function peg$parse(input, options) {
1846
1774
  peg$fail(peg$c177);
1847
1775
  }
1848
1776
  }
1849
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1850
1777
  return s0;
1851
1778
  }
1852
1779
  function peg$parseBackTildeArrow() {
1853
1780
  var s0, s1;
1854
- var key = peg$currPos * 164 + 12, cached = peg$resultsCache[key];
1855
- if (cached) {
1856
- peg$currPos = cached.nextPos;
1857
- return cached.result;
1858
- }
1859
1781
  peg$silentFails++;
1860
1782
  if (input.substr(peg$currPos, 2) === peg$c184) {
1861
1783
  s0 = peg$c184;
@@ -1892,16 +1814,10 @@ function peg$parse(input, options) {
1892
1814
  peg$fail(peg$c183);
1893
1815
  }
1894
1816
  }
1895
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1896
1817
  return s0;
1897
1818
  }
1898
1819
  function peg$parseLightFatArrow() {
1899
1820
  var s0, s1;
1900
- var key = peg$currPos * 164 + 13, cached = peg$resultsCache[key];
1901
- if (cached) {
1902
- peg$currPos = cached.nextPos;
1903
- return cached.result;
1904
- }
1905
1821
  peg$silentFails++;
1906
1822
  if (input.substr(peg$currPos, 4) === peg$c190) {
1907
1823
  s0 = peg$c190;
@@ -1938,16 +1854,10 @@ function peg$parse(input, options) {
1938
1854
  peg$fail(peg$c189);
1939
1855
  }
1940
1856
  }
1941
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1942
1857
  return s0;
1943
1858
  }
1944
1859
  function peg$parseLightTildeArrow() {
1945
1860
  var s0, s1;
1946
- var key = peg$currPos * 164 + 14, cached = peg$resultsCache[key];
1947
- if (cached) {
1948
- peg$currPos = cached.nextPos;
1949
- return cached.result;
1950
- }
1951
1861
  peg$silentFails++;
1952
1862
  if (input.substr(peg$currPos, 4) === peg$c196) {
1953
1863
  s0 = peg$c196;
@@ -1984,16 +1894,10 @@ function peg$parse(input, options) {
1984
1894
  peg$fail(peg$c195);
1985
1895
  }
1986
1896
  }
1987
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1988
1897
  return s0;
1989
1898
  }
1990
1899
  function peg$parseFatLightArrow() {
1991
1900
  var s0, s1;
1992
- var key = peg$currPos * 164 + 15, cached = peg$resultsCache[key];
1993
- if (cached) {
1994
- peg$currPos = cached.nextPos;
1995
- return cached.result;
1996
- }
1997
1901
  peg$silentFails++;
1998
1902
  if (input.substr(peg$currPos, 4) === peg$c202) {
1999
1903
  s0 = peg$c202;
@@ -2030,16 +1934,10 @@ function peg$parse(input, options) {
2030
1934
  peg$fail(peg$c201);
2031
1935
  }
2032
1936
  }
2033
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2034
1937
  return s0;
2035
1938
  }
2036
1939
  function peg$parseFatTildeArrow() {
2037
1940
  var s0, s1;
2038
- var key = peg$currPos * 164 + 16, cached = peg$resultsCache[key];
2039
- if (cached) {
2040
- peg$currPos = cached.nextPos;
2041
- return cached.result;
2042
- }
2043
1941
  peg$silentFails++;
2044
1942
  if (input.substr(peg$currPos, 4) === peg$c208) {
2045
1943
  s0 = peg$c208;
@@ -2076,16 +1974,10 @@ function peg$parse(input, options) {
2076
1974
  peg$fail(peg$c207);
2077
1975
  }
2078
1976
  }
2079
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2080
1977
  return s0;
2081
1978
  }
2082
1979
  function peg$parseTildeLightArrow() {
2083
1980
  var s0, s1;
2084
- var key = peg$currPos * 164 + 17, cached = peg$resultsCache[key];
2085
- if (cached) {
2086
- peg$currPos = cached.nextPos;
2087
- return cached.result;
2088
- }
2089
1981
  peg$silentFails++;
2090
1982
  if (input.substr(peg$currPos, 4) === peg$c214) {
2091
1983
  s0 = peg$c214;
@@ -2122,16 +2014,10 @@ function peg$parse(input, options) {
2122
2014
  peg$fail(peg$c213);
2123
2015
  }
2124
2016
  }
2125
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2126
2017
  return s0;
2127
2018
  }
2128
2019
  function peg$parseTildeFatArrow() {
2129
2020
  var s0, s1;
2130
- var key = peg$currPos * 164 + 18, cached = peg$resultsCache[key];
2131
- if (cached) {
2132
- peg$currPos = cached.nextPos;
2133
- return cached.result;
2134
- }
2135
2021
  peg$silentFails++;
2136
2022
  if (input.substr(peg$currPos, 4) === peg$c220) {
2137
2023
  s0 = peg$c220;
@@ -2168,16 +2054,10 @@ function peg$parse(input, options) {
2168
2054
  peg$fail(peg$c219);
2169
2055
  }
2170
2056
  }
2171
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2172
2057
  return s0;
2173
2058
  }
2174
2059
  function peg$parseLightArrow() {
2175
2060
  var s0;
2176
- var key = peg$currPos * 164 + 19, cached = peg$resultsCache[key];
2177
- if (cached) {
2178
- peg$currPos = cached.nextPos;
2179
- return cached.result;
2180
- }
2181
2061
  peg$silentFails++;
2182
2062
  s0 = peg$parseForwardLightArrow();
2183
2063
  if (s0 === peg$FAILED) {
@@ -2192,16 +2072,10 @@ function peg$parse(input, options) {
2192
2072
  peg$fail(peg$c225);
2193
2073
  }
2194
2074
  }
2195
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2196
2075
  return s0;
2197
2076
  }
2198
2077
  function peg$parseFatArrow() {
2199
2078
  var s0;
2200
- var key = peg$currPos * 164 + 20, cached = peg$resultsCache[key];
2201
- if (cached) {
2202
- peg$currPos = cached.nextPos;
2203
- return cached.result;
2204
- }
2205
2079
  peg$silentFails++;
2206
2080
  s0 = peg$parseForwardFatArrow();
2207
2081
  if (s0 === peg$FAILED) {
@@ -2216,16 +2090,10 @@ function peg$parse(input, options) {
2216
2090
  peg$fail(peg$c226);
2217
2091
  }
2218
2092
  }
2219
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2220
2093
  return s0;
2221
2094
  }
2222
2095
  function peg$parseTildeArrow() {
2223
2096
  var s0;
2224
- var key = peg$currPos * 164 + 21, cached = peg$resultsCache[key];
2225
- if (cached) {
2226
- peg$currPos = cached.nextPos;
2227
- return cached.result;
2228
- }
2229
2097
  peg$silentFails++;
2230
2098
  s0 = peg$parseForwardTildeArrow();
2231
2099
  if (s0 === peg$FAILED) {
@@ -2240,16 +2108,10 @@ function peg$parse(input, options) {
2240
2108
  peg$fail(peg$c227);
2241
2109
  }
2242
2110
  }
2243
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2244
2111
  return s0;
2245
2112
  }
2246
2113
  function peg$parseMixedArrow() {
2247
2114
  var s0;
2248
- var key = peg$currPos * 164 + 22, cached = peg$resultsCache[key];
2249
- if (cached) {
2250
- peg$currPos = cached.nextPos;
2251
- return cached.result;
2252
- }
2253
2115
  peg$silentFails++;
2254
2116
  s0 = peg$parseLightFatArrow();
2255
2117
  if (s0 === peg$FAILED) {
@@ -2273,16 +2135,10 @@ function peg$parse(input, options) {
2273
2135
  peg$fail(peg$c228);
2274
2136
  }
2275
2137
  }
2276
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2277
2138
  return s0;
2278
2139
  }
2279
2140
  function peg$parseArrow() {
2280
2141
  var s0;
2281
- var key = peg$currPos * 164 + 23, cached = peg$resultsCache[key];
2282
- if (cached) {
2283
- peg$currPos = cached.nextPos;
2284
- return cached.result;
2285
- }
2286
2142
  peg$silentFails++;
2287
2143
  s0 = peg$parseMixedArrow();
2288
2144
  if (s0 === peg$FAILED) {
@@ -2300,16 +2156,10 @@ function peg$parse(input, options) {
2300
2156
  peg$fail(peg$c229);
2301
2157
  }
2302
2158
  }
2303
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2304
2159
  return s0;
2305
2160
  }
2306
2161
  function peg$parseBoolean() {
2307
2162
  var s0, s1;
2308
- var key = peg$currPos * 164 + 24, cached = peg$resultsCache[key];
2309
- if (cached) {
2310
- peg$currPos = cached.nextPos;
2311
- return cached.result;
2312
- }
2313
2163
  s0 = peg$currPos;
2314
2164
  if (input.substr(peg$currPos, 4) === peg$c230) {
2315
2165
  s1 = peg$c230;
@@ -2344,16 +2194,10 @@ function peg$parse(input, options) {
2344
2194
  }
2345
2195
  s0 = s1;
2346
2196
  }
2347
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2348
2197
  return s0;
2349
2198
  }
2350
2199
  function peg$parseCorners() {
2351
2200
  var s0;
2352
- var key = peg$currPos * 164 + 25, cached = peg$resultsCache[key];
2353
- if (cached) {
2354
- peg$currPos = cached.nextPos;
2355
- return cached.result;
2356
- }
2357
2201
  if (input.substr(peg$currPos, 7) === peg$c236) {
2358
2202
  s0 = peg$c236;
2359
2203
  peg$currPos += 7;
@@ -2388,16 +2232,10 @@ function peg$parse(input, options) {
2388
2232
  }
2389
2233
  }
2390
2234
  }
2391
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2392
2235
  return s0;
2393
2236
  }
2394
2237
  function peg$parseLineStyle() {
2395
2238
  var s0;
2396
- var key = peg$currPos * 164 + 26, cached = peg$resultsCache[key];
2397
- if (cached) {
2398
- peg$currPos = cached.nextPos;
2399
- return cached.result;
2400
- }
2401
2239
  if (input.substr(peg$currPos, 5) === peg$c242) {
2402
2240
  s0 = peg$c242;
2403
2241
  peg$currPos += 5;
@@ -2432,16 +2270,10 @@ function peg$parse(input, options) {
2432
2270
  }
2433
2271
  }
2434
2272
  }
2435
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2436
2273
  return s0;
2437
2274
  }
2438
2275
  function peg$parseChar() {
2439
2276
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2440
- var key = peg$currPos * 164 + 27, cached = peg$resultsCache[key];
2441
- if (cached) {
2442
- peg$currPos = cached.nextPos;
2443
- return cached.result;
2444
- }
2445
2277
  s0 = peg$parseUnescaped();
2446
2278
  if (s0 === peg$FAILED) {
2447
2279
  s0 = peg$currPos;
@@ -2670,16 +2502,10 @@ function peg$parse(input, options) {
2670
2502
  s0 = peg$FAILED;
2671
2503
  }
2672
2504
  }
2673
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2674
2505
  return s0;
2675
2506
  }
2676
2507
  function peg$parseNull() {
2677
2508
  var s0, s1;
2678
- var key = peg$currPos * 164 + 28, cached = peg$resultsCache[key];
2679
- if (cached) {
2680
- peg$currPos = cached.nextPos;
2681
- return cached.result;
2682
- }
2683
2509
  s0 = peg$currPos;
2684
2510
  if (input.substr(peg$currPos, 4) === peg$c276) {
2685
2511
  s1 = peg$c276;
@@ -2696,16 +2522,10 @@ function peg$parse(input, options) {
2696
2522
  s1 = peg$c278();
2697
2523
  }
2698
2524
  s0 = s1;
2699
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2700
2525
  return s0;
2701
2526
  }
2702
2527
  function peg$parseUndefined() {
2703
2528
  var s0, s1;
2704
- var key = peg$currPos * 164 + 29, cached = peg$resultsCache[key];
2705
- if (cached) {
2706
- peg$currPos = cached.nextPos;
2707
- return cached.result;
2708
- }
2709
2529
  s0 = peg$currPos;
2710
2530
  if (input.substr(peg$currPos, 9) === peg$c279) {
2711
2531
  s1 = peg$c279;
@@ -2722,16 +2542,10 @@ function peg$parse(input, options) {
2722
2542
  s1 = peg$c281();
2723
2543
  }
2724
2544
  s0 = s1;
2725
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2726
2545
  return s0;
2727
2546
  }
2728
2547
  function peg$parseEscape() {
2729
2548
  var s0;
2730
- var key = peg$currPos * 164 + 30, cached = peg$resultsCache[key];
2731
- if (cached) {
2732
- peg$currPos = cached.nextPos;
2733
- return cached.result;
2734
- }
2735
2549
  if (input.charCodeAt(peg$currPos) === 92) {
2736
2550
  s0 = peg$c250;
2737
2551
  peg$currPos++;
@@ -2742,16 +2556,10 @@ function peg$parse(input, options) {
2742
2556
  peg$fail(peg$c251);
2743
2557
  }
2744
2558
  }
2745
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2746
2559
  return s0;
2747
2560
  }
2748
2561
  function peg$parseQuoteMark() {
2749
2562
  var s0;
2750
- var key = peg$currPos * 164 + 31, cached = peg$resultsCache[key];
2751
- if (cached) {
2752
- peg$currPos = cached.nextPos;
2753
- return cached.result;
2754
- }
2755
2563
  if (input.charCodeAt(peg$currPos) === 34) {
2756
2564
  s0 = peg$c248;
2757
2565
  peg$currPos++;
@@ -2762,16 +2570,10 @@ function peg$parse(input, options) {
2762
2570
  peg$fail(peg$c249);
2763
2571
  }
2764
2572
  }
2765
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2766
2573
  return s0;
2767
2574
  }
2768
2575
  function peg$parseUnescaped() {
2769
2576
  var s0;
2770
- var key = peg$currPos * 164 + 32, cached = peg$resultsCache[key];
2771
- if (cached) {
2772
- peg$currPos = cached.nextPos;
2773
- return cached.result;
2774
- }
2775
2577
  if (peg$c282.test(input.charAt(peg$currPos))) {
2776
2578
  s0 = input.charAt(peg$currPos);
2777
2579
  peg$currPos++;
@@ -2782,16 +2584,10 @@ function peg$parse(input, options) {
2782
2584
  peg$fail(peg$c283);
2783
2585
  }
2784
2586
  }
2785
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2786
2587
  return s0;
2787
2588
  }
2788
2589
  function peg$parseActionLabelChar() {
2789
2590
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2790
- var key = peg$currPos * 164 + 33, cached = peg$resultsCache[key];
2791
- if (cached) {
2792
- peg$currPos = cached.nextPos;
2793
- return cached.result;
2794
- }
2795
2591
  s0 = peg$parseActionLabelUnescaped();
2796
2592
  if (s0 === peg$FAILED) {
2797
2593
  s0 = peg$currPos;
@@ -3020,16 +2816,10 @@ function peg$parse(input, options) {
3020
2816
  s0 = peg$FAILED;
3021
2817
  }
3022
2818
  }
3023
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3024
2819
  return s0;
3025
2820
  }
3026
2821
  function peg$parseActionLabelQuoteMark() {
3027
2822
  var s0;
3028
- var key = peg$currPos * 164 + 34, cached = peg$resultsCache[key];
3029
- if (cached) {
3030
- peg$currPos = cached.nextPos;
3031
- return cached.result;
3032
- }
3033
2823
  if (input.charCodeAt(peg$currPos) === 39) {
3034
2824
  s0 = peg$c284;
3035
2825
  peg$currPos++;
@@ -3040,16 +2830,10 @@ function peg$parse(input, options) {
3040
2830
  peg$fail(peg$c285);
3041
2831
  }
3042
2832
  }
3043
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3044
2833
  return s0;
3045
2834
  }
3046
2835
  function peg$parseActionLabelUnescaped() {
3047
2836
  var s0;
3048
- var key = peg$currPos * 164 + 35, cached = peg$resultsCache[key];
3049
- if (cached) {
3050
- peg$currPos = cached.nextPos;
3051
- return cached.result;
3052
- }
3053
2837
  if (peg$c286.test(input.charAt(peg$currPos))) {
3054
2838
  s0 = input.charAt(peg$currPos);
3055
2839
  peg$currPos++;
@@ -3060,16 +2844,10 @@ function peg$parse(input, options) {
3060
2844
  peg$fail(peg$c287);
3061
2845
  }
3062
2846
  }
3063
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3064
2847
  return s0;
3065
2848
  }
3066
2849
  function peg$parseActionLabel() {
3067
2850
  var s0, s1, s2, s3;
3068
- var key = peg$currPos * 164 + 36, cached = peg$resultsCache[key];
3069
- if (cached) {
3070
- peg$currPos = cached.nextPos;
3071
- return cached.result;
3072
- }
3073
2851
  peg$silentFails++;
3074
2852
  s0 = peg$currPos;
3075
2853
  s1 = peg$parseActionLabelQuoteMark();
@@ -3108,16 +2886,10 @@ function peg$parse(input, options) {
3108
2886
  peg$fail(peg$c288);
3109
2887
  }
3110
2888
  }
3111
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3112
2889
  return s0;
3113
2890
  }
3114
2891
  function peg$parseLineTerminator() {
3115
2892
  var s0;
3116
- var key = peg$currPos * 164 + 37, cached = peg$resultsCache[key];
3117
- if (cached) {
3118
- peg$currPos = cached.nextPos;
3119
- return cached.result;
3120
- }
3121
2893
  if (peg$c290.test(input.charAt(peg$currPos))) {
3122
2894
  s0 = input.charAt(peg$currPos);
3123
2895
  peg$currPos++;
@@ -3128,16 +2900,10 @@ function peg$parse(input, options) {
3128
2900
  peg$fail(peg$c291);
3129
2901
  }
3130
2902
  }
3131
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3132
2903
  return s0;
3133
2904
  }
3134
2905
  function peg$parseBlockComment() {
3135
2906
  var s0, s1, s2, s3, s4, s5;
3136
- var key = peg$currPos * 164 + 38, cached = peg$resultsCache[key];
3137
- if (cached) {
3138
- peg$currPos = cached.nextPos;
3139
- return cached.result;
3140
- }
3141
2907
  peg$silentFails++;
3142
2908
  s0 = peg$currPos;
3143
2909
  if (input.substr(peg$currPos, 2) === peg$c293) {
@@ -3281,16 +3047,10 @@ function peg$parse(input, options) {
3281
3047
  peg$fail(peg$c292);
3282
3048
  }
3283
3049
  }
3284
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3285
3050
  return s0;
3286
3051
  }
3287
3052
  function peg$parseEOF() {
3288
3053
  var s0, s1;
3289
- var key = peg$currPos * 164 + 39, cached = peg$resultsCache[key];
3290
- if (cached) {
3291
- peg$currPos = cached.nextPos;
3292
- return cached.result;
3293
- }
3294
3054
  s0 = peg$currPos;
3295
3055
  peg$silentFails++;
3296
3056
  if (input.length > peg$currPos) {
@@ -3311,16 +3071,10 @@ function peg$parse(input, options) {
3311
3071
  peg$currPos = s0;
3312
3072
  s0 = peg$FAILED;
3313
3073
  }
3314
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3315
3074
  return s0;
3316
3075
  }
3317
3076
  function peg$parseLineComment() {
3318
3077
  var s0, s1, s2, s3, s4, s5;
3319
- var key = peg$currPos * 164 + 40, cached = peg$resultsCache[key];
3320
- if (cached) {
3321
- peg$currPos = cached.nextPos;
3322
- return cached.result;
3323
- }
3324
3078
  peg$silentFails++;
3325
3079
  s0 = peg$currPos;
3326
3080
  if (input.substr(peg$currPos, 2) === peg$c299) {
@@ -3440,16 +3194,10 @@ function peg$parse(input, options) {
3440
3194
  peg$fail(peg$c298);
3441
3195
  }
3442
3196
  }
3443
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3444
3197
  return s0;
3445
3198
  }
3446
3199
  function peg$parseWS() {
3447
3200
  var s0, s1, s2;
3448
- var key = peg$currPos * 164 + 41, cached = peg$resultsCache[key];
3449
- if (cached) {
3450
- peg$currPos = cached.nextPos;
3451
- return cached.result;
3452
- }
3453
3201
  peg$silentFails++;
3454
3202
  s0 = [];
3455
3203
  s1 = [];
@@ -3537,16 +3285,10 @@ function peg$parse(input, options) {
3537
3285
  peg$fail(peg$c301);
3538
3286
  }
3539
3287
  }
3540
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3541
3288
  return s0;
3542
3289
  }
3543
3290
  function peg$parseString() {
3544
3291
  var s0, s1, s2, s3;
3545
- var key = peg$currPos * 164 + 42, cached = peg$resultsCache[key];
3546
- if (cached) {
3547
- peg$currPos = cached.nextPos;
3548
- return cached.result;
3549
- }
3550
3292
  peg$silentFails++;
3551
3293
  s0 = peg$currPos;
3552
3294
  s1 = peg$parseQuoteMark();
@@ -3585,16 +3327,10 @@ function peg$parse(input, options) {
3585
3327
  peg$fail(peg$c304);
3586
3328
  }
3587
3329
  }
3588
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3589
3330
  return s0;
3590
3331
  }
3591
3332
  function peg$parseAtomFirstLetter() {
3592
3333
  var s0;
3593
- var key = peg$currPos * 164 + 43, cached = peg$resultsCache[key];
3594
- if (cached) {
3595
- peg$currPos = cached.nextPos;
3596
- return cached.result;
3597
- }
3598
3334
  if (peg$c305.test(input.charAt(peg$currPos))) {
3599
3335
  s0 = input.charAt(peg$currPos);
3600
3336
  peg$currPos++;
@@ -3605,16 +3341,10 @@ function peg$parse(input, options) {
3605
3341
  peg$fail(peg$c306);
3606
3342
  }
3607
3343
  }
3608
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3609
3344
  return s0;
3610
3345
  }
3611
3346
  function peg$parseAtomLetter() {
3612
3347
  var s0;
3613
- var key = peg$currPos * 164 + 44, cached = peg$resultsCache[key];
3614
- if (cached) {
3615
- peg$currPos = cached.nextPos;
3616
- return cached.result;
3617
- }
3618
3348
  if (peg$c307.test(input.charAt(peg$currPos))) {
3619
3349
  s0 = input.charAt(peg$currPos);
3620
3350
  peg$currPos++;
@@ -3625,16 +3355,10 @@ function peg$parse(input, options) {
3625
3355
  peg$fail(peg$c308);
3626
3356
  }
3627
3357
  }
3628
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3629
3358
  return s0;
3630
3359
  }
3631
3360
  function peg$parseAtom() {
3632
3361
  var s0, s1, s2, s3;
3633
- var key = peg$currPos * 164 + 45, cached = peg$resultsCache[key];
3634
- if (cached) {
3635
- peg$currPos = cached.nextPos;
3636
- return cached.result;
3637
- }
3638
3362
  peg$silentFails++;
3639
3363
  s0 = peg$currPos;
3640
3364
  s1 = peg$parseAtomFirstLetter();
@@ -3666,16 +3390,10 @@ function peg$parse(input, options) {
3666
3390
  peg$fail(peg$c309);
3667
3391
  }
3668
3392
  }
3669
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3670
3393
  return s0;
3671
3394
  }
3672
3395
  function peg$parseLabel() {
3673
3396
  var s0;
3674
- var key = peg$currPos * 164 + 46, cached = peg$resultsCache[key];
3675
- if (cached) {
3676
- peg$currPos = cached.nextPos;
3677
- return cached.result;
3678
- }
3679
3397
  peg$silentFails++;
3680
3398
  s0 = peg$parseAtom();
3681
3399
  if (s0 === peg$FAILED) {
@@ -3687,16 +3405,10 @@ function peg$parse(input, options) {
3687
3405
  peg$fail(peg$c311);
3688
3406
  }
3689
3407
  }
3690
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3691
3408
  return s0;
3692
3409
  }
3693
3410
  function peg$parseIntegerLiteral() {
3694
3411
  var s0, s1, s2, s3, s4;
3695
- var key = peg$currPos * 164 + 47, cached = peg$resultsCache[key];
3696
- if (cached) {
3697
- peg$currPos = cached.nextPos;
3698
- return cached.result;
3699
- }
3700
3412
  s0 = peg$currPos;
3701
3413
  if (input.charCodeAt(peg$currPos) === 48) {
3702
3414
  s1 = peg$c312;
@@ -3738,16 +3450,10 @@ function peg$parse(input, options) {
3738
3450
  else {
3739
3451
  s0 = s1;
3740
3452
  }
3741
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3742
3453
  return s0;
3743
3454
  }
3744
3455
  function peg$parseDecimalDigit() {
3745
3456
  var s0;
3746
- var key = peg$currPos * 164 + 48, cached = peg$resultsCache[key];
3747
- if (cached) {
3748
- peg$currPos = cached.nextPos;
3749
- return cached.result;
3750
- }
3751
3457
  if (peg$c314.test(input.charAt(peg$currPos))) {
3752
3458
  s0 = input.charAt(peg$currPos);
3753
3459
  peg$currPos++;
@@ -3758,16 +3464,10 @@ function peg$parse(input, options) {
3758
3464
  peg$fail(peg$c315);
3759
3465
  }
3760
3466
  }
3761
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3762
3467
  return s0;
3763
3468
  }
3764
3469
  function peg$parseNonZeroDigit() {
3765
3470
  var s0;
3766
- var key = peg$currPos * 164 + 49, cached = peg$resultsCache[key];
3767
- if (cached) {
3768
- peg$currPos = cached.nextPos;
3769
- return cached.result;
3770
- }
3771
3471
  if (peg$c316.test(input.charAt(peg$currPos))) {
3772
3472
  s0 = input.charAt(peg$currPos);
3773
3473
  peg$currPos++;
@@ -3778,16 +3478,10 @@ function peg$parse(input, options) {
3778
3478
  peg$fail(peg$c317);
3779
3479
  }
3780
3480
  }
3781
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3782
3481
  return s0;
3783
3482
  }
3784
3483
  function peg$parseHexDigit() {
3785
3484
  var s0;
3786
- var key = peg$currPos * 164 + 50, cached = peg$resultsCache[key];
3787
- if (cached) {
3788
- peg$currPos = cached.nextPos;
3789
- return cached.result;
3790
- }
3791
3485
  if (peg$c318.test(input.charAt(peg$currPos))) {
3792
3486
  s0 = input.charAt(peg$currPos);
3793
3487
  peg$currPos++;
@@ -3798,16 +3492,10 @@ function peg$parse(input, options) {
3798
3492
  peg$fail(peg$c319);
3799
3493
  }
3800
3494
  }
3801
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3802
3495
  return s0;
3803
3496
  }
3804
3497
  function peg$parseBinaryDigit() {
3805
3498
  var s0;
3806
- var key = peg$currPos * 164 + 51, cached = peg$resultsCache[key];
3807
- if (cached) {
3808
- peg$currPos = cached.nextPos;
3809
- return cached.result;
3810
- }
3811
3499
  if (peg$c320.test(input.charAt(peg$currPos))) {
3812
3500
  s0 = input.charAt(peg$currPos);
3813
3501
  peg$currPos++;
@@ -3818,16 +3506,10 @@ function peg$parse(input, options) {
3818
3506
  peg$fail(peg$c321);
3819
3507
  }
3820
3508
  }
3821
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3822
3509
  return s0;
3823
3510
  }
3824
3511
  function peg$parseOctalDigit() {
3825
3512
  var s0;
3826
- var key = peg$currPos * 164 + 52, cached = peg$resultsCache[key];
3827
- if (cached) {
3828
- peg$currPos = cached.nextPos;
3829
- return cached.result;
3830
- }
3831
3513
  if (peg$c322.test(input.charAt(peg$currPos))) {
3832
3514
  s0 = input.charAt(peg$currPos);
3833
3515
  peg$currPos++;
@@ -3838,16 +3520,10 @@ function peg$parse(input, options) {
3838
3520
  peg$fail(peg$c323);
3839
3521
  }
3840
3522
  }
3841
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3842
3523
  return s0;
3843
3524
  }
3844
3525
  function peg$parseNonNegNumber() {
3845
3526
  var s0, s1, s2, s3, s4;
3846
- var key = peg$currPos * 164 + 53, cached = peg$resultsCache[key];
3847
- if (cached) {
3848
- peg$currPos = cached.nextPos;
3849
- return cached.result;
3850
- }
3851
3527
  peg$silentFails++;
3852
3528
  s0 = peg$currPos;
3853
3529
  s1 = peg$parseIntegerLiteral();
@@ -3928,16 +3604,10 @@ function peg$parse(input, options) {
3928
3604
  peg$fail(peg$c324);
3929
3605
  }
3930
3606
  }
3931
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3932
3607
  return s0;
3933
3608
  }
3934
3609
  function peg$parseJsNumericLiteral() {
3935
3610
  var s0, s1;
3936
- var key = peg$currPos * 164 + 54, cached = peg$resultsCache[key];
3937
- if (cached) {
3938
- peg$currPos = cached.nextPos;
3939
- return cached.result;
3940
- }
3941
3611
  peg$silentFails++;
3942
3612
  s0 = peg$currPos;
3943
3613
  s1 = peg$parseJsHexIntegerLiteral();
@@ -4772,16 +4442,10 @@ function peg$parse(input, options) {
4772
4442
  peg$fail(peg$c328);
4773
4443
  }
4774
4444
  }
4775
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
4776
4445
  return s0;
4777
4446
  }
4778
4447
  function peg$parseJsDecimalLiteral() {
4779
4448
  var s0, s1, s2, s3, s4;
4780
- var key = peg$currPos * 164 + 55, cached = peg$resultsCache[key];
4781
- if (cached) {
4782
- peg$currPos = cached.nextPos;
4783
- return cached.result;
4784
- }
4785
4449
  s0 = peg$currPos;
4786
4450
  s1 = peg$parseJsDecimalIntegerLiteral();
4787
4451
  if (s1 !== peg$FAILED) {
@@ -4903,16 +4567,10 @@ function peg$parse(input, options) {
4903
4567
  }
4904
4568
  }
4905
4569
  }
4906
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
4907
4570
  return s0;
4908
4571
  }
4909
4572
  function peg$parseJsDecimalIntegerLiteral() {
4910
4573
  var s0, s1, s2, s3;
4911
- var key = peg$currPos * 164 + 56, cached = peg$resultsCache[key];
4912
- if (cached) {
4913
- peg$currPos = cached.nextPos;
4914
- return cached.result;
4915
- }
4916
4574
  if (input.charCodeAt(peg$currPos) === 48) {
4917
4575
  s0 = peg$c312;
4918
4576
  peg$currPos++;
@@ -4947,16 +4605,10 @@ function peg$parse(input, options) {
4947
4605
  s0 = peg$FAILED;
4948
4606
  }
4949
4607
  }
4950
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
4951
4608
  return s0;
4952
4609
  }
4953
4610
  function peg$parseJsNExponentPart() {
4954
4611
  var s0, s1, s2;
4955
- var key = peg$currPos * 164 + 57, cached = peg$resultsCache[key];
4956
- if (cached) {
4957
- peg$currPos = cached.nextPos;
4958
- return cached.result;
4959
- }
4960
4612
  s0 = peg$currPos;
4961
4613
  s1 = peg$parseJsNExponentIndicator();
4962
4614
  if (s1 !== peg$FAILED) {
@@ -4974,16 +4626,10 @@ function peg$parse(input, options) {
4974
4626
  peg$currPos = s0;
4975
4627
  s0 = peg$FAILED;
4976
4628
  }
4977
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
4978
4629
  return s0;
4979
4630
  }
4980
4631
  function peg$parseJsNExponentIndicator() {
4981
4632
  var s0;
4982
- var key = peg$currPos * 164 + 58, cached = peg$resultsCache[key];
4983
- if (cached) {
4984
- peg$currPos = cached.nextPos;
4985
- return cached.result;
4986
- }
4987
4633
  if (input.substr(peg$currPos, 1).toLowerCase() === peg$c378) {
4988
4634
  s0 = input.charAt(peg$currPos);
4989
4635
  peg$currPos++;
@@ -4994,16 +4640,10 @@ function peg$parse(input, options) {
4994
4640
  peg$fail(peg$c436);
4995
4641
  }
4996
4642
  }
4997
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
4998
4643
  return s0;
4999
4644
  }
5000
4645
  function peg$parseJsNSignedInteger() {
5001
4646
  var s0, s1, s2, s3;
5002
- var key = peg$currPos * 164 + 59, cached = peg$resultsCache[key];
5003
- if (cached) {
5004
- peg$currPos = cached.nextPos;
5005
- return cached.result;
5006
- }
5007
4647
  s0 = peg$currPos;
5008
4648
  if (peg$c437.test(input.charAt(peg$currPos))) {
5009
4649
  s1 = input.charAt(peg$currPos);
@@ -5043,16 +4683,10 @@ function peg$parse(input, options) {
5043
4683
  peg$currPos = s0;
5044
4684
  s0 = peg$FAILED;
5045
4685
  }
5046
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
5047
4686
  return s0;
5048
4687
  }
5049
4688
  function peg$parseJsHexIntegerLiteral() {
5050
4689
  var s0, s1, s2, s3, s4;
5051
- var key = peg$currPos * 164 + 60, cached = peg$resultsCache[key];
5052
- if (cached) {
5053
- peg$currPos = cached.nextPos;
5054
- return cached.result;
5055
- }
5056
4690
  s0 = peg$currPos;
5057
4691
  if (input.substr(peg$currPos, 2).toLowerCase() === peg$c439) {
5058
4692
  s1 = input.substr(peg$currPos, 2);
@@ -5097,16 +4731,10 @@ function peg$parse(input, options) {
5097
4731
  peg$currPos = s0;
5098
4732
  s0 = peg$FAILED;
5099
4733
  }
5100
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
5101
4734
  return s0;
5102
4735
  }
5103
4736
  function peg$parseJsBinaryIntegerLiteral() {
5104
4737
  var s0, s1, s2, s3, s4;
5105
- var key = peg$currPos * 164 + 61, cached = peg$resultsCache[key];
5106
- if (cached) {
5107
- peg$currPos = cached.nextPos;
5108
- return cached.result;
5109
- }
5110
4738
  s0 = peg$currPos;
5111
4739
  if (input.substr(peg$currPos, 2).toLowerCase() === peg$c442) {
5112
4740
  s1 = input.substr(peg$currPos, 2);
@@ -5151,16 +4779,10 @@ function peg$parse(input, options) {
5151
4779
  peg$currPos = s0;
5152
4780
  s0 = peg$FAILED;
5153
4781
  }
5154
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
5155
4782
  return s0;
5156
4783
  }
5157
4784
  function peg$parseNonJsOctalIntegerLiteral() {
5158
4785
  var s0, s1, s2, s3, s4;
5159
- var key = peg$currPos * 164 + 62, cached = peg$resultsCache[key];
5160
- if (cached) {
5161
- peg$currPos = cached.nextPos;
5162
- return cached.result;
5163
- }
5164
4786
  s0 = peg$currPos;
5165
4787
  if (input.substr(peg$currPos, 2).toLowerCase() === peg$c445) {
5166
4788
  s1 = input.substr(peg$currPos, 2);
@@ -5205,16 +4827,10 @@ function peg$parse(input, options) {
5205
4827
  peg$currPos = s0;
5206
4828
  s0 = peg$FAILED;
5207
4829
  }
5208
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
5209
4830
  return s0;
5210
4831
  }
5211
4832
  function peg$parseSemVer() {
5212
4833
  var s0, s1, s2, s3, s4, s5;
5213
- var key = peg$currPos * 164 + 63, cached = peg$resultsCache[key];
5214
- if (cached) {
5215
- peg$currPos = cached.nextPos;
5216
- return cached.result;
5217
- }
5218
4834
  s0 = peg$currPos;
5219
4835
  s1 = peg$parseIntegerLiteral();
5220
4836
  if (s1 !== peg$FAILED) {
@@ -5272,16 +4888,10 @@ function peg$parse(input, options) {
5272
4888
  peg$currPos = s0;
5273
4889
  s0 = peg$FAILED;
5274
4890
  }
5275
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
5276
4891
  return s0;
5277
4892
  }
5278
4893
  function peg$parseUrlProtocol() {
5279
4894
  var s0;
5280
- var key = peg$currPos * 164 + 67, cached = peg$resultsCache[key];
5281
- if (cached) {
5282
- peg$currPos = cached.nextPos;
5283
- return cached.result;
5284
- }
5285
4895
  if (input.substr(peg$currPos, 7) === peg$c459) {
5286
4896
  s0 = peg$c459;
5287
4897
  peg$currPos += 7;
@@ -5304,16 +4914,10 @@ function peg$parse(input, options) {
5304
4914
  }
5305
4915
  }
5306
4916
  }
5307
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
5308
4917
  return s0;
5309
4918
  }
5310
4919
  function peg$parseURL() {
5311
4920
  var s0, s1, s2, s3;
5312
- var key = peg$currPos * 164 + 68, cached = peg$resultsCache[key];
5313
- if (cached) {
5314
- peg$currPos = cached.nextPos;
5315
- return cached.result;
5316
- }
5317
4921
  s0 = peg$currPos;
5318
4922
  s1 = peg$parseUrlProtocol();
5319
4923
  if (s1 !== peg$FAILED) {
@@ -5360,16 +4964,10 @@ function peg$parse(input, options) {
5360
4964
  peg$currPos = s0;
5361
4965
  s0 = peg$FAILED;
5362
4966
  }
5363
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
5364
4967
  return s0;
5365
4968
  }
5366
4969
  function peg$parseSvgColorLabel() {
5367
4970
  var s0, s1;
5368
- var key = peg$currPos * 164 + 69, cached = peg$resultsCache[key];
5369
- if (cached) {
5370
- peg$currPos = cached.nextPos;
5371
- return cached.result;
5372
- }
5373
4971
  s0 = peg$currPos;
5374
4972
  if (input.substr(peg$currPos, 9) === peg$c466) {
5375
4973
  s1 = peg$c466;
@@ -10660,16 +10258,10 @@ function peg$parse(input, options) {
10660
10258
  }
10661
10259
  }
10662
10260
  }
10663
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
10664
10261
  return s0;
10665
10262
  }
10666
10263
  function peg$parseSvgColor() {
10667
10264
  var s0, s1, s2;
10668
- var key = peg$currPos * 164 + 70, cached = peg$resultsCache[key];
10669
- if (cached) {
10670
- peg$currPos = cached.nextPos;
10671
- return cached.result;
10672
- }
10673
10265
  s0 = peg$currPos;
10674
10266
  s1 = peg$parseSvgColorLabel();
10675
10267
  if (s1 !== peg$FAILED) {
@@ -10691,16 +10283,10 @@ function peg$parse(input, options) {
10691
10283
  peg$currPos = s0;
10692
10284
  s0 = peg$FAILED;
10693
10285
  }
10694
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
10695
10286
  return s0;
10696
10287
  }
10697
10288
  function peg$parseRgb3() {
10698
10289
  var s0, s1, s2, s3, s4, s5;
10699
- var key = peg$currPos * 164 + 71, cached = peg$resultsCache[key];
10700
- if (cached) {
10701
- peg$currPos = cached.nextPos;
10702
- return cached.result;
10703
- }
10704
10290
  s0 = peg$currPos;
10705
10291
  if (input.charCodeAt(peg$currPos) === 35) {
10706
10292
  s1 = peg$c1193;
@@ -10752,16 +10338,10 @@ function peg$parse(input, options) {
10752
10338
  peg$currPos = s0;
10753
10339
  s0 = peg$FAILED;
10754
10340
  }
10755
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
10756
10341
  return s0;
10757
10342
  }
10758
10343
  function peg$parseRgb6() {
10759
10344
  var s0, s1, s2, s3, s4, s5, s6, s7, s8;
10760
- var key = peg$currPos * 164 + 72, cached = peg$resultsCache[key];
10761
- if (cached) {
10762
- peg$currPos = cached.nextPos;
10763
- return cached.result;
10764
- }
10765
10345
  s0 = peg$currPos;
10766
10346
  if (input.charCodeAt(peg$currPos) === 35) {
10767
10347
  s1 = peg$c1193;
@@ -10834,16 +10414,10 @@ function peg$parse(input, options) {
10834
10414
  peg$currPos = s0;
10835
10415
  s0 = peg$FAILED;
10836
10416
  }
10837
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
10838
10417
  return s0;
10839
10418
  }
10840
10419
  function peg$parseRgba4() {
10841
10420
  var s0, s1, s2, s3, s4, s5, s6;
10842
- var key = peg$currPos * 164 + 73, cached = peg$resultsCache[key];
10843
- if (cached) {
10844
- peg$currPos = cached.nextPos;
10845
- return cached.result;
10846
- }
10847
10421
  s0 = peg$currPos;
10848
10422
  if (input.charCodeAt(peg$currPos) === 35) {
10849
10423
  s1 = peg$c1193;
@@ -10902,16 +10476,10 @@ function peg$parse(input, options) {
10902
10476
  peg$currPos = s0;
10903
10477
  s0 = peg$FAILED;
10904
10478
  }
10905
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
10906
10479
  return s0;
10907
10480
  }
10908
10481
  function peg$parseRgba8() {
10909
10482
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
10910
- var key = peg$currPos * 164 + 74, cached = peg$resultsCache[key];
10911
- if (cached) {
10912
- peg$currPos = cached.nextPos;
10913
- return cached.result;
10914
- }
10915
10483
  s0 = peg$currPos;
10916
10484
  if (input.charCodeAt(peg$currPos) === 35) {
10917
10485
  s1 = peg$c1193;
@@ -10998,16 +10566,10 @@ function peg$parse(input, options) {
10998
10566
  peg$currPos = s0;
10999
10567
  s0 = peg$FAILED;
11000
10568
  }
11001
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
11002
10569
  return s0;
11003
10570
  }
11004
10571
  function peg$parseColor() {
11005
10572
  var s0;
11006
- var key = peg$currPos * 164 + 75, cached = peg$resultsCache[key];
11007
- if (cached) {
11008
- peg$currPos = cached.nextPos;
11009
- return cached.result;
11010
- }
11011
10573
  peg$silentFails++;
11012
10574
  s0 = peg$parseSvgColor();
11013
10575
  if (s0 === peg$FAILED) {
@@ -11028,16 +10590,10 @@ function peg$parse(input, options) {
11028
10590
  peg$fail(peg$c1199);
11029
10591
  }
11030
10592
  }
11031
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
11032
10593
  return s0;
11033
10594
  }
11034
10595
  function peg$parseArrowItemKey() {
11035
10596
  var s0;
11036
- var key = peg$currPos * 164 + 76, cached = peg$resultsCache[key];
11037
- if (cached) {
11038
- peg$currPos = cached.nextPos;
11039
- return cached.result;
11040
- }
11041
10597
  if (input.substr(peg$currPos, 9) === peg$c1200) {
11042
10598
  s0 = peg$c1200;
11043
10599
  peg$currPos += 9;
@@ -11072,16 +10628,10 @@ function peg$parse(input, options) {
11072
10628
  }
11073
10629
  }
11074
10630
  }
11075
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
11076
10631
  return s0;
11077
10632
  }
11078
10633
  function peg$parseArrowItem() {
11079
10634
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
11080
- var key = peg$currPos * 164 + 77, cached = peg$resultsCache[key];
11081
- if (cached) {
11082
- peg$currPos = cached.nextPos;
11083
- return cached.result;
11084
- }
11085
10635
  s0 = peg$currPos;
11086
10636
  s1 = peg$parseWS();
11087
10637
  if (s1 === peg$FAILED) {
@@ -11182,16 +10732,10 @@ function peg$parse(input, options) {
11182
10732
  peg$currPos = s0;
11183
10733
  s0 = peg$FAILED;
11184
10734
  }
11185
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
11186
10735
  return s0;
11187
10736
  }
11188
10737
  function peg$parseSingleEdgeColor() {
11189
10738
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
11190
- var key = peg$currPos * 164 + 78, cached = peg$resultsCache[key];
11191
- if (cached) {
11192
- peg$currPos = cached.nextPos;
11193
- return cached.result;
11194
- }
11195
10739
  peg$silentFails++;
11196
10740
  s0 = peg$currPos;
11197
10741
  s1 = peg$parseWS();
@@ -11420,16 +10964,10 @@ function peg$parse(input, options) {
11420
10964
  peg$fail(peg$c1211);
11421
10965
  }
11422
10966
  }
11423
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
11424
10967
  return s0;
11425
10968
  }
11426
10969
  function peg$parseTransitionLineStyle() {
11427
10970
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
11428
- var key = peg$currPos * 164 + 79, cached = peg$resultsCache[key];
11429
- if (cached) {
11430
- peg$currPos = cached.nextPos;
11431
- return cached.result;
11432
- }
11433
10971
  peg$silentFails++;
11434
10972
  s0 = peg$currPos;
11435
10973
  s1 = peg$parseWS();
@@ -11547,16 +11085,10 @@ function peg$parse(input, options) {
11547
11085
  peg$fail(peg$c1217);
11548
11086
  }
11549
11087
  }
11550
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
11551
11088
  return s0;
11552
11089
  }
11553
11090
  function peg$parseArrowItems() {
11554
11091
  var s0, s1;
11555
- var key = peg$currPos * 164 + 80, cached = peg$resultsCache[key];
11556
- if (cached) {
11557
- peg$currPos = cached.nextPos;
11558
- return cached.result;
11559
- }
11560
11092
  s0 = peg$parseSingleEdgeColor();
11561
11093
  if (s0 === peg$FAILED) {
11562
11094
  s0 = peg$parseTransitionLineStyle();
@@ -11574,16 +11106,10 @@ function peg$parse(input, options) {
11574
11106
  }
11575
11107
  }
11576
11108
  }
11577
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
11578
11109
  return s0;
11579
11110
  }
11580
11111
  function peg$parseArrowDesc() {
11581
11112
  var s0, s1, s2, s3, s4, s5;
11582
- var key = peg$currPos * 164 + 81, cached = peg$resultsCache[key];
11583
- if (cached) {
11584
- peg$currPos = cached.nextPos;
11585
- return cached.result;
11586
- }
11587
11113
  s0 = peg$currPos;
11588
11114
  if (input.charCodeAt(peg$currPos) === 123) {
11589
11115
  s1 = peg$c1221;
@@ -11650,16 +11176,10 @@ function peg$parse(input, options) {
11650
11176
  peg$currPos = s0;
11651
11177
  s0 = peg$FAILED;
11652
11178
  }
11653
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
11654
11179
  return s0;
11655
11180
  }
11656
11181
  function peg$parseArrowProbability() {
11657
11182
  var s0, s1, s2;
11658
- var key = peg$currPos * 164 + 82, cached = peg$resultsCache[key];
11659
- if (cached) {
11660
- peg$currPos = cached.nextPos;
11661
- return cached.result;
11662
- }
11663
11183
  s0 = peg$currPos;
11664
11184
  s1 = peg$parseNonNegNumber();
11665
11185
  if (s1 !== peg$FAILED) {
@@ -11687,16 +11207,10 @@ function peg$parse(input, options) {
11687
11207
  peg$currPos = s0;
11688
11208
  s0 = peg$FAILED;
11689
11209
  }
11690
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
11691
11210
  return s0;
11692
11211
  }
11693
11212
  function peg$parseTimeType() {
11694
11213
  var s0, s1;
11695
- var key = peg$currPos * 164 + 83, cached = peg$resultsCache[key];
11696
- if (cached) {
11697
- peg$currPos = cached.nextPos;
11698
- return cached.result;
11699
- }
11700
11214
  s0 = peg$currPos;
11701
11215
  if (input.substr(peg$currPos, 12) === peg$c1229) {
11702
11216
  s1 = peg$c1229;
@@ -12199,16 +11713,10 @@ function peg$parse(input, options) {
12199
11713
  }
12200
11714
  }
12201
11715
  }
12202
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
12203
11716
  return s0;
12204
11717
  }
12205
11718
  function peg$parseArrowAfter() {
12206
11719
  var s0, s1, s2, s3, s4, s5;
12207
- var key = peg$currPos * 164 + 84, cached = peg$resultsCache[key];
12208
- if (cached) {
12209
- peg$currPos = cached.nextPos;
12210
- return cached.result;
12211
- }
12212
11720
  s0 = peg$currPos;
12213
11721
  if (input.substr(peg$currPos, 5) === peg$c1291) {
12214
11722
  s1 = peg$c1291;
@@ -12263,16 +11771,10 @@ function peg$parse(input, options) {
12263
11771
  peg$currPos = s0;
12264
11772
  s0 = peg$FAILED;
12265
11773
  }
12266
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
12267
11774
  return s0;
12268
11775
  }
12269
11776
  function peg$parseLabelList() {
12270
11777
  var s0, s1, s2, s3, s4, s5, s6;
12271
- var key = peg$currPos * 164 + 85, cached = peg$resultsCache[key];
12272
- if (cached) {
12273
- peg$currPos = cached.nextPos;
12274
- return cached.result;
12275
- }
12276
11778
  s0 = peg$currPos;
12277
11779
  if (input.charCodeAt(peg$currPos) === 91) {
12278
11780
  s1 = peg$c11;
@@ -12369,30 +11871,18 @@ function peg$parse(input, options) {
12369
11871
  peg$currPos = s0;
12370
11872
  s0 = peg$FAILED;
12371
11873
  }
12372
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
12373
11874
  return s0;
12374
11875
  }
12375
11876
  function peg$parseLabelOrLabelList() {
12376
11877
  var s0;
12377
- var key = peg$currPos * 164 + 86, cached = peg$resultsCache[key];
12378
- if (cached) {
12379
- peg$currPos = cached.nextPos;
12380
- return cached.result;
12381
- }
12382
11878
  s0 = peg$parseLabelList();
12383
11879
  if (s0 === peg$FAILED) {
12384
11880
  s0 = peg$parseLabel();
12385
11881
  }
12386
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
12387
11882
  return s0;
12388
11883
  }
12389
11884
  function peg$parseStripe() {
12390
11885
  var s0, s1, s2, s3, s4, s5, s6;
12391
- var key = peg$currPos * 164 + 87, cached = peg$resultsCache[key];
12392
- if (cached) {
12393
- peg$currPos = cached.nextPos;
12394
- return cached.result;
12395
- }
12396
11886
  s0 = peg$currPos;
12397
11887
  if (input.substr(peg$currPos, 2) === peg$c1295) {
12398
11888
  s1 = peg$c1295;
@@ -12505,16 +11995,10 @@ function peg$parse(input, options) {
12505
11995
  s0 = peg$FAILED;
12506
11996
  }
12507
11997
  }
12508
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
12509
11998
  return s0;
12510
11999
  }
12511
12000
  function peg$parseCycle() {
12512
12001
  var s0, s1, s2, s3, s4, s5, s6;
12513
- var key = peg$currPos * 164 + 88, cached = peg$resultsCache[key];
12514
- if (cached) {
12515
- peg$currPos = cached.nextPos;
12516
- return cached.result;
12517
- }
12518
12002
  s0 = peg$currPos;
12519
12003
  if (input.charCodeAt(peg$currPos) === 43) {
12520
12004
  s1 = peg$c1301;
@@ -12645,16 +12129,10 @@ function peg$parse(input, options) {
12645
12129
  s0 = s1;
12646
12130
  }
12647
12131
  }
12648
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
12649
12132
  return s0;
12650
12133
  }
12651
12134
  function peg$parseArrowTarget() {
12652
12135
  var s0;
12653
- var key = peg$currPos * 164 + 89, cached = peg$resultsCache[key];
12654
- if (cached) {
12655
- peg$currPos = cached.nextPos;
12656
- return cached.result;
12657
- }
12658
12136
  s0 = peg$parseStripe();
12659
12137
  if (s0 === peg$FAILED) {
12660
12138
  s0 = peg$parseCycle();
@@ -12665,16 +12143,10 @@ function peg$parse(input, options) {
12665
12143
  }
12666
12144
  }
12667
12145
  }
12668
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
12669
12146
  return s0;
12670
12147
  }
12671
12148
  function peg$parseArrowDecoration() {
12672
12149
  var s0, s1;
12673
- var key = peg$currPos * 164 + 90, cached = peg$resultsCache[key];
12674
- if (cached) {
12675
- peg$currPos = cached.nextPos;
12676
- return cached.result;
12677
- }
12678
12150
  s0 = peg$currPos;
12679
12151
  s1 = peg$parseArrowAfter();
12680
12152
  if (s1 !== peg$FAILED) {
@@ -12709,16 +12181,10 @@ function peg$parse(input, options) {
12709
12181
  }
12710
12182
  }
12711
12183
  }
12712
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
12713
12184
  return s0;
12714
12185
  }
12715
12186
  function peg$parseArrowDecorations() {
12716
12187
  var s0, s1, s2, s3;
12717
- var key = peg$currPos * 164 + 91, cached = peg$resultsCache[key];
12718
- if (cached) {
12719
- peg$currPos = cached.nextPos;
12720
- return cached.result;
12721
- }
12722
12188
  s0 = [];
12723
12189
  s1 = peg$currPos;
12724
12190
  s2 = peg$parseArrowDecoration();
@@ -12765,16 +12231,10 @@ function peg$parse(input, options) {
12765
12231
  s1 = peg$FAILED;
12766
12232
  }
12767
12233
  }
12768
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
12769
12234
  return s0;
12770
12235
  }
12771
12236
  function peg$parseSubexp() {
12772
12237
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
12773
- var key = peg$currPos * 164 + 92, cached = peg$resultsCache[key];
12774
- if (cached) {
12775
- peg$currPos = cached.nextPos;
12776
- return cached.result;
12777
- }
12778
12238
  s0 = peg$currPos;
12779
12239
  s1 = peg$parseWS();
12780
12240
  if (s1 === peg$FAILED) {
@@ -12867,16 +12327,10 @@ function peg$parse(input, options) {
12867
12327
  peg$currPos = s0;
12868
12328
  s0 = peg$FAILED;
12869
12329
  }
12870
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
12871
12330
  return s0;
12872
12331
  }
12873
12332
  function peg$parseExp() {
12874
12333
  var s0, s1, s2, s3, s4, s5;
12875
- var key = peg$currPos * 164 + 93, cached = peg$resultsCache[key];
12876
- if (cached) {
12877
- peg$currPos = cached.nextPos;
12878
- return cached.result;
12879
- }
12880
12334
  s0 = peg$currPos;
12881
12335
  s1 = peg$parseArrowTarget();
12882
12336
  if (s1 !== peg$FAILED) {
@@ -12931,16 +12385,10 @@ function peg$parse(input, options) {
12931
12385
  peg$currPos = s0;
12932
12386
  s0 = peg$FAILED;
12933
12387
  }
12934
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
12935
12388
  return s0;
12936
12389
  }
12937
12390
  function peg$parseValidationKey() {
12938
12391
  var s0;
12939
- var key = peg$currPos * 164 + 94, cached = peg$resultsCache[key];
12940
- if (cached) {
12941
- peg$currPos = cached.nextPos;
12942
- return cached.result;
12943
- }
12944
12392
  if (input.substr(peg$currPos, 9) === peg$c1317) {
12945
12393
  s0 = peg$c1317;
12946
12394
  peg$currPos += 9;
@@ -12963,16 +12411,10 @@ function peg$parse(input, options) {
12963
12411
  }
12964
12412
  }
12965
12413
  }
12966
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
12967
12414
  return s0;
12968
12415
  }
12969
12416
  function peg$parseValidationItem() {
12970
12417
  var s0, s1, s2, s3, s4;
12971
- var key = peg$currPos * 164 + 95, cached = peg$resultsCache[key];
12972
- if (cached) {
12973
- peg$currPos = cached.nextPos;
12974
- return cached.result;
12975
- }
12976
12418
  s0 = peg$currPos;
12977
12419
  s1 = peg$parseValidationKey();
12978
12420
  if (s1 !== peg$FAILED) {
@@ -13023,16 +12465,10 @@ function peg$parse(input, options) {
13023
12465
  peg$currPos = s0;
13024
12466
  s0 = peg$FAILED;
13025
12467
  }
13026
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
13027
12468
  return s0;
13028
12469
  }
13029
12470
  function peg$parseValidationItems() {
13030
12471
  var s0, s1;
13031
- var key = peg$currPos * 164 + 96, cached = peg$resultsCache[key];
13032
- if (cached) {
13033
- peg$currPos = cached.nextPos;
13034
- return cached.result;
13035
- }
13036
12472
  s0 = [];
13037
12473
  s1 = peg$parseValidationItem();
13038
12474
  if (s1 !== peg$FAILED) {
@@ -13044,16 +12480,10 @@ function peg$parse(input, options) {
13044
12480
  else {
13045
12481
  s0 = peg$FAILED;
13046
12482
  }
13047
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
13048
12483
  return s0;
13049
12484
  }
13050
12485
  function peg$parseConfigValidation() {
13051
12486
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
13052
- var key = peg$currPos * 164 + 97, cached = peg$resultsCache[key];
13053
- if (cached) {
13054
- peg$currPos = cached.nextPos;
13055
- return cached.result;
13056
- }
13057
12487
  s0 = peg$currPos;
13058
12488
  s1 = peg$parseWS();
13059
12489
  if (s1 === peg$FAILED) {
@@ -13192,16 +12622,10 @@ function peg$parse(input, options) {
13192
12622
  peg$currPos = s0;
13193
12623
  s0 = peg$FAILED;
13194
12624
  }
13195
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
13196
12625
  return s0;
13197
12626
  }
13198
12627
  function peg$parseGvizLayout() {
13199
12628
  var s0;
13200
- var key = peg$currPos * 164 + 98, cached = peg$resultsCache[key];
13201
- if (cached) {
13202
- peg$currPos = cached.nextPos;
13203
- return cached.result;
13204
- }
13205
12629
  if (input.substr(peg$currPos, 3) === peg$c1327) {
13206
12630
  s0 = peg$c1327;
13207
12631
  peg$currPos += 3;
@@ -13260,16 +12684,10 @@ function peg$parse(input, options) {
13260
12684
  }
13261
12685
  }
13262
12686
  }
13263
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
13264
12687
  return s0;
13265
12688
  }
13266
12689
  function peg$parseStateItems() {
13267
12690
  var s0, s1;
13268
- var key = peg$currPos * 164 + 99, cached = peg$resultsCache[key];
13269
- if (cached) {
13270
- peg$currPos = cached.nextPos;
13271
- return cached.result;
13272
- }
13273
12691
  s0 = [];
13274
12692
  s1 = peg$parseStateDeclarationItem();
13275
12693
  if (s1 !== peg$FAILED) {
@@ -13281,16 +12699,10 @@ function peg$parse(input, options) {
13281
12699
  else {
13282
12700
  s0 = peg$FAILED;
13283
12701
  }
13284
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
13285
12702
  return s0;
13286
12703
  }
13287
12704
  function peg$parseConfigState() {
13288
12705
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
13289
- var key = peg$currPos * 164 + 100, cached = peg$resultsCache[key];
13290
- if (cached) {
13291
- peg$currPos = cached.nextPos;
13292
- return cached.result;
13293
- }
13294
12706
  s0 = peg$currPos;
13295
12707
  s1 = peg$parseWS();
13296
12708
  if (s1 === peg$FAILED) {
@@ -13429,16 +12841,10 @@ function peg$parse(input, options) {
13429
12841
  peg$currPos = s0;
13430
12842
  s0 = peg$FAILED;
13431
12843
  }
13432
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
13433
12844
  return s0;
13434
12845
  }
13435
12846
  function peg$parseConfigStartState() {
13436
12847
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
13437
- var key = peg$currPos * 164 + 101, cached = peg$resultsCache[key];
13438
- if (cached) {
13439
- peg$currPos = cached.nextPos;
13440
- return cached.result;
13441
- }
13442
12848
  s0 = peg$currPos;
13443
12849
  s1 = peg$parseWS();
13444
12850
  if (s1 === peg$FAILED) {
@@ -13577,16 +12983,10 @@ function peg$parse(input, options) {
13577
12983
  peg$currPos = s0;
13578
12984
  s0 = peg$FAILED;
13579
12985
  }
13580
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
13581
12986
  return s0;
13582
12987
  }
13583
12988
  function peg$parseConfigEndState() {
13584
12989
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
13585
- var key = peg$currPos * 164 + 102, cached = peg$resultsCache[key];
13586
- if (cached) {
13587
- peg$currPos = cached.nextPos;
13588
- return cached.result;
13589
- }
13590
12990
  s0 = peg$currPos;
13591
12991
  s1 = peg$parseWS();
13592
12992
  if (s1 === peg$FAILED) {
@@ -13725,16 +13125,10 @@ function peg$parse(input, options) {
13725
13125
  peg$currPos = s0;
13726
13126
  s0 = peg$FAILED;
13727
13127
  }
13728
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
13729
13128
  return s0;
13730
13129
  }
13731
13130
  function peg$parseConfigActiveState() {
13732
13131
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
13733
- var key = peg$currPos * 164 + 103, cached = peg$resultsCache[key];
13734
- if (cached) {
13735
- peg$currPos = cached.nextPos;
13736
- return cached.result;
13737
- }
13738
13132
  s0 = peg$currPos;
13739
13133
  s1 = peg$parseWS();
13740
13134
  if (s1 === peg$FAILED) {
@@ -13873,16 +13267,10 @@ function peg$parse(input, options) {
13873
13267
  peg$currPos = s0;
13874
13268
  s0 = peg$FAILED;
13875
13269
  }
13876
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
13877
13270
  return s0;
13878
13271
  }
13879
13272
  function peg$parseConfigTerminalState() {
13880
13273
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
13881
- var key = peg$currPos * 164 + 104, cached = peg$resultsCache[key];
13882
- if (cached) {
13883
- peg$currPos = cached.nextPos;
13884
- return cached.result;
13885
- }
13886
13274
  s0 = peg$currPos;
13887
13275
  s1 = peg$parseWS();
13888
13276
  if (s1 === peg$FAILED) {
@@ -14021,16 +13409,10 @@ function peg$parse(input, options) {
14021
13409
  peg$currPos = s0;
14022
13410
  s0 = peg$FAILED;
14023
13411
  }
14024
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
14025
13412
  return s0;
14026
13413
  }
14027
13414
  function peg$parseConfigHookedState() {
14028
13415
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
14029
- var key = peg$currPos * 164 + 105, cached = peg$resultsCache[key];
14030
- if (cached) {
14031
- peg$currPos = cached.nextPos;
14032
- return cached.result;
14033
- }
14034
13416
  s0 = peg$currPos;
14035
13417
  s1 = peg$parseWS();
14036
13418
  if (s1 === peg$FAILED) {
@@ -14169,16 +13551,10 @@ function peg$parse(input, options) {
14169
13551
  peg$currPos = s0;
14170
13552
  s0 = peg$FAILED;
14171
13553
  }
14172
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
14173
13554
  return s0;
14174
13555
  }
14175
13556
  function peg$parseConfigAnyState() {
14176
13557
  var s0;
14177
- var key = peg$currPos * 164 + 106, cached = peg$resultsCache[key];
14178
- if (cached) {
14179
- peg$currPos = cached.nextPos;
14180
- return cached.result;
14181
- }
14182
13558
  s0 = peg$parseConfigState();
14183
13559
  if (s0 === peg$FAILED) {
14184
13560
  s0 = peg$parseConfigStartState();
@@ -14195,16 +13571,10 @@ function peg$parse(input, options) {
14195
13571
  }
14196
13572
  }
14197
13573
  }
14198
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
14199
13574
  return s0;
14200
13575
  }
14201
13576
  function peg$parseActionKey() {
14202
13577
  var s0;
14203
- var key = peg$currPos * 164 + 107, cached = peg$resultsCache[key];
14204
- if (cached) {
14205
- peg$currPos = cached.nextPos;
14206
- return cached.result;
14207
- }
14208
13578
  if (input.substr(peg$currPos, 9) === peg$c1317) {
14209
13579
  s0 = peg$c1317;
14210
13580
  peg$currPos += 9;
@@ -14227,16 +13597,10 @@ function peg$parse(input, options) {
14227
13597
  }
14228
13598
  }
14229
13599
  }
14230
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
14231
13600
  return s0;
14232
13601
  }
14233
13602
  function peg$parseActionItem() {
14234
13603
  var s0, s1, s2, s3, s4;
14235
- var key = peg$currPos * 164 + 108, cached = peg$resultsCache[key];
14236
- if (cached) {
14237
- peg$currPos = cached.nextPos;
14238
- return cached.result;
14239
- }
14240
13604
  s0 = peg$currPos;
14241
13605
  s1 = peg$parseActionKey();
14242
13606
  if (s1 !== peg$FAILED) {
@@ -14287,16 +13651,10 @@ function peg$parse(input, options) {
14287
13651
  peg$currPos = s0;
14288
13652
  s0 = peg$FAILED;
14289
13653
  }
14290
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
14291
13654
  return s0;
14292
13655
  }
14293
13656
  function peg$parseActionItems() {
14294
13657
  var s0, s1;
14295
- var key = peg$currPos * 164 + 109, cached = peg$resultsCache[key];
14296
- if (cached) {
14297
- peg$currPos = cached.nextPos;
14298
- return cached.result;
14299
- }
14300
13658
  s0 = [];
14301
13659
  s1 = peg$parseActionItem();
14302
13660
  if (s1 !== peg$FAILED) {
@@ -14308,16 +13666,10 @@ function peg$parse(input, options) {
14308
13666
  else {
14309
13667
  s0 = peg$FAILED;
14310
13668
  }
14311
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
14312
13669
  return s0;
14313
13670
  }
14314
13671
  function peg$parseConfigAction() {
14315
13672
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
14316
- var key = peg$currPos * 164 + 110, cached = peg$resultsCache[key];
14317
- if (cached) {
14318
- peg$currPos = cached.nextPos;
14319
- return cached.result;
14320
- }
14321
13673
  s0 = peg$currPos;
14322
13674
  s1 = peg$parseWS();
14323
13675
  if (s1 === peg$FAILED) {
@@ -14456,16 +13808,10 @@ function peg$parse(input, options) {
14456
13808
  peg$currPos = s0;
14457
13809
  s0 = peg$FAILED;
14458
13810
  }
14459
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
14460
13811
  return s0;
14461
13812
  }
14462
13813
  function peg$parseTransitionKey() {
14463
13814
  var s0;
14464
- var key = peg$currPos * 164 + 111, cached = peg$resultsCache[key];
14465
- if (cached) {
14466
- peg$currPos = cached.nextPos;
14467
- return cached.result;
14468
- }
14469
13815
  if (input.substr(peg$currPos, 9) === peg$c1317) {
14470
13816
  s0 = peg$c1317;
14471
13817
  peg$currPos += 9;
@@ -14488,16 +13834,10 @@ function peg$parse(input, options) {
14488
13834
  }
14489
13835
  }
14490
13836
  }
14491
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
14492
13837
  return s0;
14493
13838
  }
14494
13839
  function peg$parseTransitionItem() {
14495
13840
  var s0, s1, s2, s3, s4;
14496
- var key = peg$currPos * 164 + 112, cached = peg$resultsCache[key];
14497
- if (cached) {
14498
- peg$currPos = cached.nextPos;
14499
- return cached.result;
14500
- }
14501
13841
  s0 = peg$currPos;
14502
13842
  s1 = peg$parseTransitionKey();
14503
13843
  if (s1 !== peg$FAILED) {
@@ -14548,16 +13888,10 @@ function peg$parse(input, options) {
14548
13888
  peg$currPos = s0;
14549
13889
  s0 = peg$FAILED;
14550
13890
  }
14551
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
14552
13891
  return s0;
14553
13892
  }
14554
13893
  function peg$parseTransitionItems() {
14555
13894
  var s0, s1;
14556
- var key = peg$currPos * 164 + 113, cached = peg$resultsCache[key];
14557
- if (cached) {
14558
- peg$currPos = cached.nextPos;
14559
- return cached.result;
14560
- }
14561
13895
  s0 = peg$parseGraphDefaultEdgeColor();
14562
13896
  if (s0 === peg$FAILED) {
14563
13897
  s0 = [];
@@ -14572,16 +13906,10 @@ function peg$parse(input, options) {
14572
13906
  s0 = peg$FAILED;
14573
13907
  }
14574
13908
  }
14575
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
14576
13909
  return s0;
14577
13910
  }
14578
13911
  function peg$parseGraphDefaultEdgeColor() {
14579
13912
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
14580
- var key = peg$currPos * 164 + 114, cached = peg$resultsCache[key];
14581
- if (cached) {
14582
- peg$currPos = cached.nextPos;
14583
- return cached.result;
14584
- }
14585
13913
  peg$silentFails++;
14586
13914
  s0 = peg$currPos;
14587
13915
  s1 = peg$parseWS();
@@ -14810,16 +14138,10 @@ function peg$parse(input, options) {
14810
14138
  peg$fail(peg$c1360);
14811
14139
  }
14812
14140
  }
14813
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
14814
14141
  return s0;
14815
14142
  }
14816
14143
  function peg$parseConfigTransition() {
14817
14144
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
14818
- var key = peg$currPos * 164 + 115, cached = peg$resultsCache[key];
14819
- if (cached) {
14820
- peg$currPos = cached.nextPos;
14821
- return cached.result;
14822
- }
14823
14145
  s0 = peg$currPos;
14824
14146
  s1 = peg$parseWS();
14825
14147
  if (s1 === peg$FAILED) {
@@ -14958,16 +14280,10 @@ function peg$parse(input, options) {
14958
14280
  peg$currPos = s0;
14959
14281
  s0 = peg$FAILED;
14960
14282
  }
14961
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
14962
14283
  return s0;
14963
14284
  }
14964
14285
  function peg$parseConfigGraphLayout() {
14965
14286
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
14966
- var key = peg$currPos * 164 + 116, cached = peg$resultsCache[key];
14967
- if (cached) {
14968
- peg$currPos = cached.nextPos;
14969
- return cached.result;
14970
- }
14971
14287
  s0 = peg$currPos;
14972
14288
  s1 = peg$parseWS();
14973
14289
  if (s1 === peg$FAILED) {
@@ -15077,16 +14393,10 @@ function peg$parse(input, options) {
15077
14393
  peg$currPos = s0;
15078
14394
  s0 = peg$FAILED;
15079
14395
  }
15080
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
15081
14396
  return s0;
15082
14397
  }
15083
14398
  function peg$parseConfigStartNodes() {
15084
14399
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
15085
- var key = peg$currPos * 164 + 117, cached = peg$resultsCache[key];
15086
- if (cached) {
15087
- peg$currPos = cached.nextPos;
15088
- return cached.result;
15089
- }
15090
14400
  s0 = peg$currPos;
15091
14401
  s1 = peg$parseWS();
15092
14402
  if (s1 === peg$FAILED) {
@@ -15196,16 +14506,10 @@ function peg$parse(input, options) {
15196
14506
  peg$currPos = s0;
15197
14507
  s0 = peg$FAILED;
15198
14508
  }
15199
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
15200
14509
  return s0;
15201
14510
  }
15202
14511
  function peg$parseConfigEndNodes() {
15203
14512
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
15204
- var key = peg$currPos * 164 + 118, cached = peg$resultsCache[key];
15205
- if (cached) {
15206
- peg$currPos = cached.nextPos;
15207
- return cached.result;
15208
- }
15209
14513
  s0 = peg$currPos;
15210
14514
  s1 = peg$parseWS();
15211
14515
  if (s1 === peg$FAILED) {
@@ -15315,16 +14619,10 @@ function peg$parse(input, options) {
15315
14619
  peg$currPos = s0;
15316
14620
  s0 = peg$FAILED;
15317
14621
  }
15318
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
15319
14622
  return s0;
15320
14623
  }
15321
14624
  function peg$parseConfigGraphBgColor() {
15322
14625
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
15323
- var key = peg$currPos * 164 + 119, cached = peg$resultsCache[key];
15324
- if (cached) {
15325
- peg$currPos = cached.nextPos;
15326
- return cached.result;
15327
- }
15328
14626
  s0 = peg$currPos;
15329
14627
  s1 = peg$parseWS();
15330
14628
  if (s1 === peg$FAILED) {
@@ -15434,16 +14732,10 @@ function peg$parse(input, options) {
15434
14732
  peg$currPos = s0;
15435
14733
  s0 = peg$FAILED;
15436
14734
  }
15437
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
15438
14735
  return s0;
15439
14736
  }
15440
14737
  function peg$parseConfigAllowsOverride() {
15441
14738
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
15442
- var key = peg$currPos * 164 + 120, cached = peg$resultsCache[key];
15443
- if (cached) {
15444
- peg$currPos = cached.nextPos;
15445
- return cached.result;
15446
- }
15447
14739
  s0 = peg$currPos;
15448
14740
  s1 = peg$parseWS();
15449
14741
  if (s1 === peg$FAILED) {
@@ -15553,16 +14845,10 @@ function peg$parse(input, options) {
15553
14845
  peg$currPos = s0;
15554
14846
  s0 = peg$FAILED;
15555
14847
  }
15556
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
15557
14848
  return s0;
15558
14849
  }
15559
14850
  function peg$parseOverrideT() {
15560
14851
  var s0, s1;
15561
- var key = peg$currPos * 164 + 121, cached = peg$resultsCache[key];
15562
- if (cached) {
15563
- peg$currPos = cached.nextPos;
15564
- return cached.result;
15565
- }
15566
14852
  s0 = peg$currPos;
15567
14853
  if (input.substr(peg$currPos, 4) === peg$c230) {
15568
14854
  s1 = peg$c230;
@@ -15615,16 +14901,10 @@ function peg$parse(input, options) {
15615
14901
  s0 = s1;
15616
14902
  }
15617
14903
  }
15618
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
15619
14904
  return s0;
15620
14905
  }
15621
14906
  function peg$parseConfig() {
15622
14907
  var s0;
15623
- var key = peg$currPos * 164 + 122, cached = peg$resultsCache[key];
15624
- if (cached) {
15625
- peg$currPos = cached.nextPos;
15626
- return cached.result;
15627
- }
15628
14908
  peg$silentFails++;
15629
14909
  s0 = peg$parseConfigGraphLayout();
15630
14910
  if (s0 === peg$FAILED) {
@@ -15657,16 +14937,10 @@ function peg$parse(input, options) {
15657
14937
  peg$fail(peg$c1382);
15658
14938
  }
15659
14939
  }
15660
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
15661
14940
  return s0;
15662
14941
  }
15663
14942
  function peg$parseLicenseOrLabelOrList() {
15664
14943
  var s0;
15665
- var key = peg$currPos * 164 + 123, cached = peg$resultsCache[key];
15666
- if (cached) {
15667
- peg$currPos = cached.nextPos;
15668
- return cached.result;
15669
- }
15670
14944
  if (input.substr(peg$currPos, 3) === peg$c1383) {
15671
14945
  s0 = peg$c1383;
15672
14946
  peg$currPos += 3;
@@ -15803,16 +15077,10 @@ function peg$parse(input, options) {
15803
15077
  }
15804
15078
  }
15805
15079
  }
15806
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
15807
15080
  return s0;
15808
15081
  }
15809
15082
  function peg$parseDirection() {
15810
15083
  var s0;
15811
- var key = peg$currPos * 164 + 124, cached = peg$resultsCache[key];
15812
- if (cached) {
15813
- peg$currPos = cached.nextPos;
15814
- return cached.result;
15815
- }
15816
15084
  peg$silentFails++;
15817
15085
  if (input.substr(peg$currPos, 2) === peg$c1406) {
15818
15086
  s0 = peg$c1406;
@@ -15866,16 +15134,10 @@ function peg$parse(input, options) {
15866
15134
  peg$fail(peg$c1405);
15867
15135
  }
15868
15136
  }
15869
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
15870
15137
  return s0;
15871
15138
  }
15872
15139
  function peg$parseHookDefinition() {
15873
15140
  var s0;
15874
- var key = peg$currPos * 164 + 125, cached = peg$resultsCache[key];
15875
- if (cached) {
15876
- peg$currPos = cached.nextPos;
15877
- return cached.result;
15878
- }
15879
15141
  peg$silentFails++;
15880
15142
  if (input.substr(peg$currPos, 4) === peg$c1415) {
15881
15143
  s0 = peg$c1415;
@@ -15905,16 +15167,10 @@ function peg$parse(input, options) {
15905
15167
  peg$fail(peg$c1414);
15906
15168
  }
15907
15169
  }
15908
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
15909
15170
  return s0;
15910
15171
  }
15911
15172
  function peg$parseMachineAuthor() {
15912
15173
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
15913
- var key = peg$currPos * 164 + 126, cached = peg$resultsCache[key];
15914
- if (cached) {
15915
- peg$currPos = cached.nextPos;
15916
- return cached.result;
15917
- }
15918
15174
  s0 = peg$currPos;
15919
15175
  s1 = peg$parseWS();
15920
15176
  if (s1 === peg$FAILED) {
@@ -16024,16 +15280,10 @@ function peg$parse(input, options) {
16024
15280
  peg$currPos = s0;
16025
15281
  s0 = peg$FAILED;
16026
15282
  }
16027
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
16028
15283
  return s0;
16029
15284
  }
16030
15285
  function peg$parseMachineContributor() {
16031
15286
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
16032
- var key = peg$currPos * 164 + 127, cached = peg$resultsCache[key];
16033
- if (cached) {
16034
- peg$currPos = cached.nextPos;
16035
- return cached.result;
16036
- }
16037
15287
  s0 = peg$currPos;
16038
15288
  s1 = peg$parseWS();
16039
15289
  if (s1 === peg$FAILED) {
@@ -16143,16 +15393,10 @@ function peg$parse(input, options) {
16143
15393
  peg$currPos = s0;
16144
15394
  s0 = peg$FAILED;
16145
15395
  }
16146
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
16147
15396
  return s0;
16148
15397
  }
16149
15398
  function peg$parseMachineComment() {
16150
15399
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
16151
- var key = peg$currPos * 164 + 128, cached = peg$resultsCache[key];
16152
- if (cached) {
16153
- peg$currPos = cached.nextPos;
16154
- return cached.result;
16155
- }
16156
15400
  s0 = peg$currPos;
16157
15401
  s1 = peg$parseWS();
16158
15402
  if (s1 === peg$FAILED) {
@@ -16262,16 +15506,10 @@ function peg$parse(input, options) {
16262
15506
  peg$currPos = s0;
16263
15507
  s0 = peg$FAILED;
16264
15508
  }
16265
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
16266
15509
  return s0;
16267
15510
  }
16268
15511
  function peg$parseMachineDefinition() {
16269
15512
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
16270
- var key = peg$currPos * 164 + 129, cached = peg$resultsCache[key];
16271
- if (cached) {
16272
- peg$currPos = cached.nextPos;
16273
- return cached.result;
16274
- }
16275
15513
  s0 = peg$currPos;
16276
15514
  s1 = peg$parseWS();
16277
15515
  if (s1 === peg$FAILED) {
@@ -16381,16 +15619,10 @@ function peg$parse(input, options) {
16381
15619
  peg$currPos = s0;
16382
15620
  s0 = peg$FAILED;
16383
15621
  }
16384
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
16385
15622
  return s0;
16386
15623
  }
16387
15624
  function peg$parseMachineName() {
16388
15625
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
16389
- var key = peg$currPos * 164 + 130, cached = peg$resultsCache[key];
16390
- if (cached) {
16391
- peg$currPos = cached.nextPos;
16392
- return cached.result;
16393
- }
16394
15626
  s0 = peg$currPos;
16395
15627
  s1 = peg$parseWS();
16396
15628
  if (s1 === peg$FAILED) {
@@ -16500,16 +15732,10 @@ function peg$parse(input, options) {
16500
15732
  peg$currPos = s0;
16501
15733
  s0 = peg$FAILED;
16502
15734
  }
16503
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
16504
15735
  return s0;
16505
15736
  }
16506
15737
  function peg$parseMachineReference() {
16507
15738
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
16508
- var key = peg$currPos * 164 + 131, cached = peg$resultsCache[key];
16509
- if (cached) {
16510
- peg$currPos = cached.nextPos;
16511
- return cached.result;
16512
- }
16513
15739
  s0 = peg$currPos;
16514
15740
  s1 = peg$parseWS();
16515
15741
  if (s1 === peg$FAILED) {
@@ -16619,16 +15845,10 @@ function peg$parse(input, options) {
16619
15845
  peg$currPos = s0;
16620
15846
  s0 = peg$FAILED;
16621
15847
  }
16622
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
16623
15848
  return s0;
16624
15849
  }
16625
15850
  function peg$parseMachineVersion() {
16626
15851
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
16627
- var key = peg$currPos * 164 + 132, cached = peg$resultsCache[key];
16628
- if (cached) {
16629
- peg$currPos = cached.nextPos;
16630
- return cached.result;
16631
- }
16632
15852
  s0 = peg$currPos;
16633
15853
  s1 = peg$parseWS();
16634
15854
  if (s1 === peg$FAILED) {
@@ -16738,16 +15958,10 @@ function peg$parse(input, options) {
16738
15958
  peg$currPos = s0;
16739
15959
  s0 = peg$FAILED;
16740
15960
  }
16741
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
16742
15961
  return s0;
16743
15962
  }
16744
15963
  function peg$parseMachineLicense() {
16745
15964
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
16746
- var key = peg$currPos * 164 + 133, cached = peg$resultsCache[key];
16747
- if (cached) {
16748
- peg$currPos = cached.nextPos;
16749
- return cached.result;
16750
- }
16751
15965
  s0 = peg$currPos;
16752
15966
  s1 = peg$parseWS();
16753
15967
  if (s1 === peg$FAILED) {
@@ -16857,16 +16071,10 @@ function peg$parse(input, options) {
16857
16071
  peg$currPos = s0;
16858
16072
  s0 = peg$FAILED;
16859
16073
  }
16860
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
16861
16074
  return s0;
16862
16075
  }
16863
16076
  function peg$parseMachineLanguage() {
16864
16077
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
16865
- var key = peg$currPos * 164 + 134, cached = peg$resultsCache[key];
16866
- if (cached) {
16867
- peg$currPos = cached.nextPos;
16868
- return cached.result;
16869
- }
16870
16078
  s0 = peg$currPos;
16871
16079
  s1 = peg$parseWS();
16872
16080
  if (s1 === peg$FAILED) {
@@ -16976,16 +16184,10 @@ function peg$parse(input, options) {
16976
16184
  peg$currPos = s0;
16977
16185
  s0 = peg$FAILED;
16978
16186
  }
16979
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
16980
16187
  return s0;
16981
16188
  }
16982
16189
  function peg$parseFslVersion() {
16983
16190
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
16984
- var key = peg$currPos * 164 + 135, cached = peg$resultsCache[key];
16985
- if (cached) {
16986
- peg$currPos = cached.nextPos;
16987
- return cached.result;
16988
- }
16989
16191
  s0 = peg$currPos;
16990
16192
  s1 = peg$parseWS();
16991
16193
  if (s1 === peg$FAILED) {
@@ -17095,16 +16297,10 @@ function peg$parse(input, options) {
17095
16297
  peg$currPos = s0;
17096
16298
  s0 = peg$FAILED;
17097
16299
  }
17098
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
17099
16300
  return s0;
17100
16301
  }
17101
16302
  function peg$parseMachineTheme() {
17102
16303
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
17103
- var key = peg$currPos * 164 + 136, cached = peg$resultsCache[key];
17104
- if (cached) {
17105
- peg$currPos = cached.nextPos;
17106
- return cached.result;
17107
- }
17108
16304
  s0 = peg$currPos;
17109
16305
  s1 = peg$parseWS();
17110
16306
  if (s1 === peg$FAILED) {
@@ -17214,16 +16410,10 @@ function peg$parse(input, options) {
17214
16410
  peg$currPos = s0;
17215
16411
  s0 = peg$FAILED;
17216
16412
  }
17217
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
17218
16413
  return s0;
17219
16414
  }
17220
16415
  function peg$parseMachineFlow() {
17221
16416
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
17222
- var key = peg$currPos * 164 + 137, cached = peg$resultsCache[key];
17223
- if (cached) {
17224
- peg$currPos = cached.nextPos;
17225
- return cached.result;
17226
- }
17227
16417
  s0 = peg$currPos;
17228
16418
  s1 = peg$parseWS();
17229
16419
  if (s1 === peg$FAILED) {
@@ -17333,16 +16523,10 @@ function peg$parse(input, options) {
17333
16523
  peg$currPos = s0;
17334
16524
  s0 = peg$FAILED;
17335
16525
  }
17336
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
17337
16526
  return s0;
17338
16527
  }
17339
16528
  function peg$parseMachineHookDefinition() {
17340
16529
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
17341
- var key = peg$currPos * 164 + 138, cached = peg$resultsCache[key];
17342
- if (cached) {
17343
- peg$currPos = cached.nextPos;
17344
- return cached.result;
17345
- }
17346
16530
  s0 = peg$currPos;
17347
16531
  s1 = peg$parseWS();
17348
16532
  if (s1 === peg$FAILED) {
@@ -17452,16 +16636,10 @@ function peg$parse(input, options) {
17452
16636
  peg$currPos = s0;
17453
16637
  s0 = peg$FAILED;
17454
16638
  }
17455
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
17456
16639
  return s0;
17457
16640
  }
17458
16641
  function peg$parseDotPreamble() {
17459
16642
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
17460
- var key = peg$currPos * 164 + 139, cached = peg$resultsCache[key];
17461
- if (cached) {
17462
- peg$currPos = cached.nextPos;
17463
- return cached.result;
17464
- }
17465
16643
  s0 = peg$currPos;
17466
16644
  s1 = peg$parseWS();
17467
16645
  if (s1 === peg$FAILED) {
@@ -17571,16 +16749,10 @@ function peg$parse(input, options) {
17571
16749
  peg$currPos = s0;
17572
16750
  s0 = peg$FAILED;
17573
16751
  }
17574
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
17575
16752
  return s0;
17576
16753
  }
17577
16754
  function peg$parseMachineAttribute() {
17578
16755
  var s0;
17579
- var key = peg$currPos * 164 + 140, cached = peg$resultsCache[key];
17580
- if (cached) {
17581
- peg$currPos = cached.nextPos;
17582
- return cached.result;
17583
- }
17584
16756
  peg$silentFails++;
17585
16757
  s0 = peg$parseFslVersion();
17586
16758
  if (s0 === peg$FAILED) {
@@ -17628,16 +16800,10 @@ function peg$parse(input, options) {
17628
16800
  peg$fail(peg$c1461);
17629
16801
  }
17630
16802
  }
17631
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
17632
16803
  return s0;
17633
16804
  }
17634
16805
  function peg$parsePropertyVal() {
17635
16806
  var s0;
17636
- var key = peg$currPos * 164 + 141, cached = peg$resultsCache[key];
17637
- if (cached) {
17638
- peg$currPos = cached.nextPos;
17639
- return cached.result;
17640
- }
17641
16807
  s0 = peg$parseString();
17642
16808
  if (s0 === peg$FAILED) {
17643
16809
  s0 = peg$parseBoolean();
@@ -17651,16 +16817,10 @@ function peg$parse(input, options) {
17651
16817
  }
17652
16818
  }
17653
16819
  }
17654
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
17655
16820
  return s0;
17656
16821
  }
17657
16822
  function peg$parseSdStateLabel() {
17658
16823
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
17659
- var key = peg$currPos * 164 + 142, cached = peg$resultsCache[key];
17660
- if (cached) {
17661
- peg$currPos = cached.nextPos;
17662
- return cached.result;
17663
- }
17664
16824
  peg$silentFails++;
17665
16825
  s0 = peg$currPos;
17666
16826
  s1 = peg$parseWS();
@@ -17778,16 +16938,10 @@ function peg$parse(input, options) {
17778
16938
  peg$fail(peg$c311);
17779
16939
  }
17780
16940
  }
17781
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
17782
16941
  return s0;
17783
16942
  }
17784
16943
  function peg$parseSdStateColor() {
17785
16944
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
17786
- var key = peg$currPos * 164 + 143, cached = peg$resultsCache[key];
17787
- if (cached) {
17788
- peg$currPos = cached.nextPos;
17789
- return cached.result;
17790
- }
17791
16945
  peg$silentFails++;
17792
16946
  s0 = peg$currPos;
17793
16947
  s1 = peg$parseWS();
@@ -17905,16 +17059,10 @@ function peg$parse(input, options) {
17905
17059
  peg$fail(peg$c1199);
17906
17060
  }
17907
17061
  }
17908
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
17909
17062
  return s0;
17910
17063
  }
17911
17064
  function peg$parseSdStateTextColor() {
17912
17065
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
17913
- var key = peg$currPos * 164 + 144, cached = peg$resultsCache[key];
17914
- if (cached) {
17915
- peg$currPos = cached.nextPos;
17916
- return cached.result;
17917
- }
17918
17066
  peg$silentFails++;
17919
17067
  s0 = peg$currPos;
17920
17068
  s1 = peg$parseWS();
@@ -18032,16 +17180,10 @@ function peg$parse(input, options) {
18032
17180
  peg$fail(peg$c1468);
18033
17181
  }
18034
17182
  }
18035
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
18036
17183
  return s0;
18037
17184
  }
18038
17185
  function peg$parseSdStateBackgroundColor() {
18039
17186
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
18040
- var key = peg$currPos * 164 + 145, cached = peg$resultsCache[key];
18041
- if (cached) {
18042
- peg$currPos = cached.nextPos;
18043
- return cached.result;
18044
- }
18045
17187
  peg$silentFails++;
18046
17188
  s0 = peg$currPos;
18047
17189
  s1 = peg$parseWS();
@@ -18159,16 +17301,10 @@ function peg$parse(input, options) {
18159
17301
  peg$fail(peg$c1472);
18160
17302
  }
18161
17303
  }
18162
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
18163
17304
  return s0;
18164
17305
  }
18165
17306
  function peg$parseSdStateBorderColor() {
18166
17307
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
18167
- var key = peg$currPos * 164 + 146, cached = peg$resultsCache[key];
18168
- if (cached) {
18169
- peg$currPos = cached.nextPos;
18170
- return cached.result;
18171
- }
18172
17308
  peg$silentFails++;
18173
17309
  s0 = peg$currPos;
18174
17310
  s1 = peg$parseWS();
@@ -18286,16 +17422,10 @@ function peg$parse(input, options) {
18286
17422
  peg$fail(peg$c1476);
18287
17423
  }
18288
17424
  }
18289
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
18290
17425
  return s0;
18291
17426
  }
18292
17427
  function peg$parseSdStateShape() {
18293
17428
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
18294
- var key = peg$currPos * 164 + 147, cached = peg$resultsCache[key];
18295
- if (cached) {
18296
- peg$currPos = cached.nextPos;
18297
- return cached.result;
18298
- }
18299
17429
  peg$silentFails++;
18300
17430
  s0 = peg$currPos;
18301
17431
  s1 = peg$parseWS();
@@ -18413,16 +17543,10 @@ function peg$parse(input, options) {
18413
17543
  peg$fail(peg$c1480);
18414
17544
  }
18415
17545
  }
18416
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
18417
17546
  return s0;
18418
17547
  }
18419
17548
  function peg$parseSdStateCorners() {
18420
17549
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
18421
- var key = peg$currPos * 164 + 148, cached = peg$resultsCache[key];
18422
- if (cached) {
18423
- peg$currPos = cached.nextPos;
18424
- return cached.result;
18425
- }
18426
17550
  peg$silentFails++;
18427
17551
  s0 = peg$currPos;
18428
17552
  s1 = peg$parseWS();
@@ -18540,16 +17664,10 @@ function peg$parse(input, options) {
18540
17664
  peg$fail(peg$c1484);
18541
17665
  }
18542
17666
  }
18543
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
18544
17667
  return s0;
18545
17668
  }
18546
17669
  function peg$parseSdStateLineStyle() {
18547
17670
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
18548
- var key = peg$currPos * 164 + 149, cached = peg$resultsCache[key];
18549
- if (cached) {
18550
- peg$currPos = cached.nextPos;
18551
- return cached.result;
18552
- }
18553
17671
  peg$silentFails++;
18554
17672
  s0 = peg$currPos;
18555
17673
  s1 = peg$parseWS();
@@ -18778,16 +17896,10 @@ function peg$parse(input, options) {
18778
17896
  peg$fail(peg$c1488);
18779
17897
  }
18780
17898
  }
18781
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
18782
17899
  return s0;
18783
17900
  }
18784
17901
  function peg$parseSdStateImage() {
18785
17902
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
18786
- var key = peg$currPos * 164 + 150, cached = peg$resultsCache[key];
18787
- if (cached) {
18788
- peg$currPos = cached.nextPos;
18789
- return cached.result;
18790
- }
18791
17903
  peg$silentFails++;
18792
17904
  s0 = peg$currPos;
18793
17905
  s1 = peg$parseWS();
@@ -18905,16 +18017,10 @@ function peg$parse(input, options) {
18905
18017
  peg$fail(peg$c1492);
18906
18018
  }
18907
18019
  }
18908
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
18909
18020
  return s0;
18910
18021
  }
18911
18022
  function peg$parseSdStateUrl() {
18912
18023
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
18913
- var key = peg$currPos * 164 + 151, cached = peg$resultsCache[key];
18914
- if (cached) {
18915
- peg$currPos = cached.nextPos;
18916
- return cached.result;
18917
- }
18918
18024
  peg$silentFails++;
18919
18025
  s0 = peg$currPos;
18920
18026
  s1 = peg$parseWS();
@@ -19032,16 +18138,10 @@ function peg$parse(input, options) {
19032
18138
  peg$fail(peg$c1496);
19033
18139
  }
19034
18140
  }
19035
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
19036
18141
  return s0;
19037
18142
  }
19038
18143
  function peg$parseSdStateProperty() {
19039
18144
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
19040
- var key = peg$currPos * 164 + 152, cached = peg$resultsCache[key];
19041
- if (cached) {
19042
- peg$currPos = cached.nextPos;
19043
- return cached.result;
19044
- }
19045
18145
  peg$silentFails++;
19046
18146
  s0 = peg$currPos;
19047
18147
  s1 = peg$parseWS();
@@ -19321,16 +18421,10 @@ function peg$parse(input, options) {
19321
18421
  peg$fail(peg$c1500);
19322
18422
  }
19323
18423
  }
19324
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
19325
18424
  return s0;
19326
18425
  }
19327
18426
  function peg$parseStateDeclarationItem() {
19328
18427
  var s0;
19329
- var key = peg$currPos * 164 + 153, cached = peg$resultsCache[key];
19330
- if (cached) {
19331
- peg$currPos = cached.nextPos;
19332
- return cached.result;
19333
- }
19334
18428
  s0 = peg$parseSdStateLabel();
19335
18429
  if (s0 === peg$FAILED) {
19336
18430
  s0 = peg$parseSdStateColor();
@@ -19362,16 +18456,10 @@ function peg$parse(input, options) {
19362
18456
  }
19363
18457
  }
19364
18458
  }
19365
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
19366
18459
  return s0;
19367
18460
  }
19368
18461
  function peg$parseStateDeclarationDesc() {
19369
18462
  var s0, s1, s2, s3, s4, s5;
19370
- var key = peg$currPos * 164 + 154, cached = peg$resultsCache[key];
19371
- if (cached) {
19372
- peg$currPos = cached.nextPos;
19373
- return cached.result;
19374
- }
19375
18463
  s0 = peg$currPos;
19376
18464
  if (input.charCodeAt(peg$currPos) === 123) {
19377
18465
  s1 = peg$c1221;
@@ -19440,16 +18528,10 @@ function peg$parse(input, options) {
19440
18528
  peg$currPos = s0;
19441
18529
  s0 = peg$FAILED;
19442
18530
  }
19443
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
19444
18531
  return s0;
19445
18532
  }
19446
18533
  function peg$parseStateDeclaration() {
19447
18534
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
19448
- var key = peg$currPos * 164 + 155, cached = peg$resultsCache[key];
19449
- if (cached) {
19450
- peg$currPos = cached.nextPos;
19451
- return cached.result;
19452
- }
19453
18535
  s0 = peg$currPos;
19454
18536
  s1 = peg$parseWS();
19455
18537
  if (s1 === peg$FAILED) {
@@ -19573,16 +18655,10 @@ function peg$parse(input, options) {
19573
18655
  peg$currPos = s0;
19574
18656
  s0 = peg$FAILED;
19575
18657
  }
19576
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
19577
18658
  return s0;
19578
18659
  }
19579
18660
  function peg$parseNamedList() {
19580
18661
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
19581
- var key = peg$currPos * 164 + 156, cached = peg$resultsCache[key];
19582
- if (cached) {
19583
- peg$currPos = cached.nextPos;
19584
- return cached.result;
19585
- }
19586
18662
  s0 = peg$currPos;
19587
18663
  s1 = peg$parseWS();
19588
18664
  if (s1 === peg$FAILED) {
@@ -19709,16 +18785,10 @@ function peg$parse(input, options) {
19709
18785
  peg$currPos = s0;
19710
18786
  s0 = peg$FAILED;
19711
18787
  }
19712
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
19713
18788
  return s0;
19714
18789
  }
19715
18790
  function peg$parseMachineProperty() {
19716
18791
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
19717
- var key = peg$currPos * 164 + 157, cached = peg$resultsCache[key];
19718
- if (cached) {
19719
- peg$currPos = cached.nextPos;
19720
- return cached.result;
19721
- }
19722
18792
  s0 = peg$currPos;
19723
18793
  s1 = peg$parseWS();
19724
18794
  if (s1 === peg$FAILED) {
@@ -20165,16 +19235,10 @@ function peg$parse(input, options) {
20165
19235
  }
20166
19236
  }
20167
19237
  }
20168
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
20169
19238
  return s0;
20170
19239
  }
20171
19240
  function peg$parseRegularArrangeDeclaration() {
20172
19241
  var s0, s1, s2, s3, s4, s5, s6;
20173
- var key = peg$currPos * 164 + 158, cached = peg$resultsCache[key];
20174
- if (cached) {
20175
- peg$currPos = cached.nextPos;
20176
- return cached.result;
20177
- }
20178
19242
  s0 = peg$currPos;
20179
19243
  if (input.substr(peg$currPos, 7) === peg$c1515) {
20180
19244
  s1 = peg$c1515;
@@ -20248,16 +19312,10 @@ function peg$parse(input, options) {
20248
19312
  peg$currPos = s0;
20249
19313
  s0 = peg$FAILED;
20250
19314
  }
20251
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
20252
19315
  return s0;
20253
19316
  }
20254
19317
  function peg$parseArrangeStartDeclaration() {
20255
19318
  var s0, s1, s2, s3, s4, s5, s6;
20256
- var key = peg$currPos * 164 + 159, cached = peg$resultsCache[key];
20257
- if (cached) {
20258
- peg$currPos = cached.nextPos;
20259
- return cached.result;
20260
- }
20261
19319
  s0 = peg$currPos;
20262
19320
  if (input.substr(peg$currPos, 13) === peg$c1518) {
20263
19321
  s1 = peg$c1518;
@@ -20331,16 +19389,10 @@ function peg$parse(input, options) {
20331
19389
  peg$currPos = s0;
20332
19390
  s0 = peg$FAILED;
20333
19391
  }
20334
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
20335
19392
  return s0;
20336
19393
  }
20337
19394
  function peg$parseArrangeEndDeclaration() {
20338
19395
  var s0, s1, s2, s3, s4, s5, s6;
20339
- var key = peg$currPos * 164 + 160, cached = peg$resultsCache[key];
20340
- if (cached) {
20341
- peg$currPos = cached.nextPos;
20342
- return cached.result;
20343
- }
20344
19396
  s0 = peg$currPos;
20345
19397
  if (input.substr(peg$currPos, 11) === peg$c1521) {
20346
19398
  s1 = peg$c1521;
@@ -20414,16 +19466,10 @@ function peg$parse(input, options) {
20414
19466
  peg$currPos = s0;
20415
19467
  s0 = peg$FAILED;
20416
19468
  }
20417
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
20418
19469
  return s0;
20419
19470
  }
20420
19471
  function peg$parseArrangeDeclaration() {
20421
19472
  var s0;
20422
- var key = peg$currPos * 164 + 161, cached = peg$resultsCache[key];
20423
- if (cached) {
20424
- peg$currPos = cached.nextPos;
20425
- return cached.result;
20426
- }
20427
19473
  peg$silentFails++;
20428
19474
  s0 = peg$parseArrangeStartDeclaration();
20429
19475
  if (s0 === peg$FAILED) {
@@ -20438,16 +19484,10 @@ function peg$parse(input, options) {
20438
19484
  peg$fail(peg$c1524);
20439
19485
  }
20440
19486
  }
20441
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
20442
19487
  return s0;
20443
19488
  }
20444
19489
  function peg$parseTerm() {
20445
19490
  var s0;
20446
- var key = peg$currPos * 164 + 162, cached = peg$resultsCache[key];
20447
- if (cached) {
20448
- peg$currPos = cached.nextPos;
20449
- return cached.result;
20450
- }
20451
19491
  s0 = peg$parseExp();
20452
19492
  if (s0 === peg$FAILED) {
20453
19493
  s0 = peg$parseStateDeclaration();
@@ -20467,23 +19507,16 @@ function peg$parse(input, options) {
20467
19507
  }
20468
19508
  }
20469
19509
  }
20470
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
20471
19510
  return s0;
20472
19511
  }
20473
19512
  function peg$parseTermList() {
20474
19513
  var s0, s1;
20475
- var key = peg$currPos * 164 + 163, cached = peg$resultsCache[key];
20476
- if (cached) {
20477
- peg$currPos = cached.nextPos;
20478
- return cached.result;
20479
- }
20480
19514
  s0 = [];
20481
19515
  s1 = peg$parseTerm();
20482
19516
  while (s1 !== peg$FAILED) {
20483
19517
  s0.push(s1);
20484
19518
  s1 = peg$parseTerm();
20485
19519
  }
20486
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
20487
19520
  return s0;
20488
19521
  }
20489
19522
  peg$result = peg$startRuleFunction();
@@ -22397,7 +21430,7 @@ var constants = /*#__PURE__*/Object.freeze({
22397
21430
  * Useful for runtime diagnostics and for embedding in serialized machine
22398
21431
  * snapshots so that deserializers can detect version-skew.
22399
21432
  */
22400
- const version = "5.141.9";
21433
+ const version = "5.141.10";
22401
21434
 
22402
21435
  // whargarbl lots of these return arrays could/should be sets
22403
21436
  const { state_name_chars, state_name_first_chars, action_label_chars } = constants;