jssm 5.141.9 → 5.141.11

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 +6 -6
  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 +6 -6
  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 +3 -2
package/dist/cdn/viz.js CHANGED
@@ -240,7 +240,6 @@ function arrow_right_kind(arrow) {
240
240
  }
241
241
  }
242
242
 
243
- // @ts-nocheck
244
243
  /*
245
244
  * Generated by PEG.js 0.10.0.
246
245
  *
@@ -458,7 +457,7 @@ function peg$parse(input, options) {
458
457
  return { key: 'state_property', name, value };
459
458
  }, peg$c1504 = "required", peg$c1505 = peg$literalExpectation("required", false), peg$c1506 = function (name, value) {
460
459
  return { key: 'state_property', name, value, required: true };
461
- }, 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;
460
+ }, 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;
462
461
  if ("startRule" in options) {
463
462
  if (!(options.startRule in peg$startRuleFunctions)) {
464
463
  throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
@@ -552,11 +551,6 @@ function peg$parse(input, options) {
552
551
  }
553
552
  function peg$parseDocument() {
554
553
  var s0, s1, s2, s3;
555
- var key = peg$currPos * 164 + 0, cached = peg$resultsCache[key];
556
- if (cached) {
557
- peg$currPos = cached.nextPos;
558
- return cached.result;
559
- }
560
554
  s0 = peg$currPos;
561
555
  s1 = peg$parseWS();
562
556
  if (s1 === peg$FAILED) {
@@ -588,16 +582,10 @@ function peg$parse(input, options) {
588
582
  peg$currPos = s0;
589
583
  s0 = peg$FAILED;
590
584
  }
591
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
592
585
  return s0;
593
586
  }
594
587
  function peg$parseTheme() {
595
588
  var s0;
596
- var key = peg$currPos * 164 + 1, cached = peg$resultsCache[key];
597
- if (cached) {
598
- peg$currPos = cached.nextPos;
599
- return cached.result;
600
- }
601
589
  if (input.substr(peg$currPos, 7) === peg$c1) {
602
590
  s0 = peg$c1;
603
591
  peg$currPos += 7;
@@ -656,16 +644,10 @@ function peg$parse(input, options) {
656
644
  }
657
645
  }
658
646
  }
659
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
660
647
  return s0;
661
648
  }
662
649
  function peg$parseThemeOrThemeList() {
663
650
  var s0, s1, s2, s3, s4, s5, s6;
664
- var key = peg$currPos * 164 + 2, cached = peg$resultsCache[key];
665
- if (cached) {
666
- peg$currPos = cached.nextPos;
667
- return cached.result;
668
- }
669
651
  s0 = peg$currPos;
670
652
  if (input.charCodeAt(peg$currPos) === 91) {
671
653
  s1 = peg$c11;
@@ -775,16 +757,10 @@ function peg$parse(input, options) {
775
757
  }
776
758
  s0 = s1;
777
759
  }
778
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
779
760
  return s0;
780
761
  }
781
762
  function peg$parseGvizShape() {
782
763
  var s0;
783
- var key = peg$currPos * 164 + 3, cached = peg$resultsCache[key];
784
- if (cached) {
785
- peg$currPos = cached.nextPos;
786
- return cached.result;
787
- }
788
764
  if (input.substr(peg$currPos, 5) === peg$c17) {
789
765
  s0 = peg$c17;
790
766
  peg$currPos += 5;
@@ -1503,16 +1479,10 @@ function peg$parse(input, options) {
1503
1479
  }
1504
1480
  }
1505
1481
  }
1506
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1507
1482
  return s0;
1508
1483
  }
1509
1484
  function peg$parseForwardLightArrow() {
1510
1485
  var s0, s1;
1511
- var key = peg$currPos * 164 + 4, cached = peg$resultsCache[key];
1512
- if (cached) {
1513
- peg$currPos = cached.nextPos;
1514
- return cached.result;
1515
- }
1516
1486
  peg$silentFails++;
1517
1487
  if (input.substr(peg$currPos, 2) === peg$c136) {
1518
1488
  s0 = peg$c136;
@@ -1549,16 +1519,10 @@ function peg$parse(input, options) {
1549
1519
  peg$fail(peg$c135);
1550
1520
  }
1551
1521
  }
1552
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1553
1522
  return s0;
1554
1523
  }
1555
1524
  function peg$parseTwoWayLightArrow() {
1556
1525
  var s0, s1;
1557
- var key = peg$currPos * 164 + 5, cached = peg$resultsCache[key];
1558
- if (cached) {
1559
- peg$currPos = cached.nextPos;
1560
- return cached.result;
1561
- }
1562
1526
  peg$silentFails++;
1563
1527
  if (input.substr(peg$currPos, 3) === peg$c142) {
1564
1528
  s0 = peg$c142;
@@ -1595,16 +1559,10 @@ function peg$parse(input, options) {
1595
1559
  peg$fail(peg$c141);
1596
1560
  }
1597
1561
  }
1598
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1599
1562
  return s0;
1600
1563
  }
1601
1564
  function peg$parseBackLightArrow() {
1602
1565
  var s0, s1;
1603
- var key = peg$currPos * 164 + 6, cached = peg$resultsCache[key];
1604
- if (cached) {
1605
- peg$currPos = cached.nextPos;
1606
- return cached.result;
1607
- }
1608
1566
  peg$silentFails++;
1609
1567
  if (input.substr(peg$currPos, 2) === peg$c148) {
1610
1568
  s0 = peg$c148;
@@ -1641,16 +1599,10 @@ function peg$parse(input, options) {
1641
1599
  peg$fail(peg$c147);
1642
1600
  }
1643
1601
  }
1644
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1645
1602
  return s0;
1646
1603
  }
1647
1604
  function peg$parseForwardFatArrow() {
1648
1605
  var s0, s1;
1649
- var key = peg$currPos * 164 + 7, cached = peg$resultsCache[key];
1650
- if (cached) {
1651
- peg$currPos = cached.nextPos;
1652
- return cached.result;
1653
- }
1654
1606
  peg$silentFails++;
1655
1607
  if (input.substr(peg$currPos, 2) === peg$c154) {
1656
1608
  s0 = peg$c154;
@@ -1687,16 +1639,10 @@ function peg$parse(input, options) {
1687
1639
  peg$fail(peg$c153);
1688
1640
  }
1689
1641
  }
1690
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1691
1642
  return s0;
1692
1643
  }
1693
1644
  function peg$parseTwoWayFatArrow() {
1694
1645
  var s0, s1;
1695
- var key = peg$currPos * 164 + 8, cached = peg$resultsCache[key];
1696
- if (cached) {
1697
- peg$currPos = cached.nextPos;
1698
- return cached.result;
1699
- }
1700
1646
  peg$silentFails++;
1701
1647
  if (input.substr(peg$currPos, 3) === peg$c160) {
1702
1648
  s0 = peg$c160;
@@ -1733,16 +1679,10 @@ function peg$parse(input, options) {
1733
1679
  peg$fail(peg$c159);
1734
1680
  }
1735
1681
  }
1736
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1737
1682
  return s0;
1738
1683
  }
1739
1684
  function peg$parseBackFatArrow() {
1740
1685
  var s0, s1;
1741
- var key = peg$currPos * 164 + 9, cached = peg$resultsCache[key];
1742
- if (cached) {
1743
- peg$currPos = cached.nextPos;
1744
- return cached.result;
1745
- }
1746
1686
  peg$silentFails++;
1747
1687
  if (input.substr(peg$currPos, 2) === peg$c166) {
1748
1688
  s0 = peg$c166;
@@ -1779,16 +1719,10 @@ function peg$parse(input, options) {
1779
1719
  peg$fail(peg$c165);
1780
1720
  }
1781
1721
  }
1782
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1783
1722
  return s0;
1784
1723
  }
1785
1724
  function peg$parseForwardTildeArrow() {
1786
1725
  var s0, s1;
1787
- var key = peg$currPos * 164 + 10, cached = peg$resultsCache[key];
1788
- if (cached) {
1789
- peg$currPos = cached.nextPos;
1790
- return cached.result;
1791
- }
1792
1726
  peg$silentFails++;
1793
1727
  if (input.substr(peg$currPos, 2) === peg$c172) {
1794
1728
  s0 = peg$c172;
@@ -1825,16 +1759,10 @@ function peg$parse(input, options) {
1825
1759
  peg$fail(peg$c171);
1826
1760
  }
1827
1761
  }
1828
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1829
1762
  return s0;
1830
1763
  }
1831
1764
  function peg$parseTwoWayTildeArrow() {
1832
1765
  var s0, s1;
1833
- var key = peg$currPos * 164 + 11, cached = peg$resultsCache[key];
1834
- if (cached) {
1835
- peg$currPos = cached.nextPos;
1836
- return cached.result;
1837
- }
1838
1766
  peg$silentFails++;
1839
1767
  if (input.substr(peg$currPos, 3) === peg$c178) {
1840
1768
  s0 = peg$c178;
@@ -1871,16 +1799,10 @@ function peg$parse(input, options) {
1871
1799
  peg$fail(peg$c177);
1872
1800
  }
1873
1801
  }
1874
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1875
1802
  return s0;
1876
1803
  }
1877
1804
  function peg$parseBackTildeArrow() {
1878
1805
  var s0, s1;
1879
- var key = peg$currPos * 164 + 12, cached = peg$resultsCache[key];
1880
- if (cached) {
1881
- peg$currPos = cached.nextPos;
1882
- return cached.result;
1883
- }
1884
1806
  peg$silentFails++;
1885
1807
  if (input.substr(peg$currPos, 2) === peg$c184) {
1886
1808
  s0 = peg$c184;
@@ -1917,16 +1839,10 @@ function peg$parse(input, options) {
1917
1839
  peg$fail(peg$c183);
1918
1840
  }
1919
1841
  }
1920
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1921
1842
  return s0;
1922
1843
  }
1923
1844
  function peg$parseLightFatArrow() {
1924
1845
  var s0, s1;
1925
- var key = peg$currPos * 164 + 13, cached = peg$resultsCache[key];
1926
- if (cached) {
1927
- peg$currPos = cached.nextPos;
1928
- return cached.result;
1929
- }
1930
1846
  peg$silentFails++;
1931
1847
  if (input.substr(peg$currPos, 4) === peg$c190) {
1932
1848
  s0 = peg$c190;
@@ -1963,16 +1879,10 @@ function peg$parse(input, options) {
1963
1879
  peg$fail(peg$c189);
1964
1880
  }
1965
1881
  }
1966
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1967
1882
  return s0;
1968
1883
  }
1969
1884
  function peg$parseLightTildeArrow() {
1970
1885
  var s0, s1;
1971
- var key = peg$currPos * 164 + 14, cached = peg$resultsCache[key];
1972
- if (cached) {
1973
- peg$currPos = cached.nextPos;
1974
- return cached.result;
1975
- }
1976
1886
  peg$silentFails++;
1977
1887
  if (input.substr(peg$currPos, 4) === peg$c196) {
1978
1888
  s0 = peg$c196;
@@ -2009,16 +1919,10 @@ function peg$parse(input, options) {
2009
1919
  peg$fail(peg$c195);
2010
1920
  }
2011
1921
  }
2012
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2013
1922
  return s0;
2014
1923
  }
2015
1924
  function peg$parseFatLightArrow() {
2016
1925
  var s0, s1;
2017
- var key = peg$currPos * 164 + 15, cached = peg$resultsCache[key];
2018
- if (cached) {
2019
- peg$currPos = cached.nextPos;
2020
- return cached.result;
2021
- }
2022
1926
  peg$silentFails++;
2023
1927
  if (input.substr(peg$currPos, 4) === peg$c202) {
2024
1928
  s0 = peg$c202;
@@ -2055,16 +1959,10 @@ function peg$parse(input, options) {
2055
1959
  peg$fail(peg$c201);
2056
1960
  }
2057
1961
  }
2058
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2059
1962
  return s0;
2060
1963
  }
2061
1964
  function peg$parseFatTildeArrow() {
2062
1965
  var s0, s1;
2063
- var key = peg$currPos * 164 + 16, cached = peg$resultsCache[key];
2064
- if (cached) {
2065
- peg$currPos = cached.nextPos;
2066
- return cached.result;
2067
- }
2068
1966
  peg$silentFails++;
2069
1967
  if (input.substr(peg$currPos, 4) === peg$c208) {
2070
1968
  s0 = peg$c208;
@@ -2101,16 +1999,10 @@ function peg$parse(input, options) {
2101
1999
  peg$fail(peg$c207);
2102
2000
  }
2103
2001
  }
2104
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2105
2002
  return s0;
2106
2003
  }
2107
2004
  function peg$parseTildeLightArrow() {
2108
2005
  var s0, s1;
2109
- var key = peg$currPos * 164 + 17, cached = peg$resultsCache[key];
2110
- if (cached) {
2111
- peg$currPos = cached.nextPos;
2112
- return cached.result;
2113
- }
2114
2006
  peg$silentFails++;
2115
2007
  if (input.substr(peg$currPos, 4) === peg$c214) {
2116
2008
  s0 = peg$c214;
@@ -2147,16 +2039,10 @@ function peg$parse(input, options) {
2147
2039
  peg$fail(peg$c213);
2148
2040
  }
2149
2041
  }
2150
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2151
2042
  return s0;
2152
2043
  }
2153
2044
  function peg$parseTildeFatArrow() {
2154
2045
  var s0, s1;
2155
- var key = peg$currPos * 164 + 18, cached = peg$resultsCache[key];
2156
- if (cached) {
2157
- peg$currPos = cached.nextPos;
2158
- return cached.result;
2159
- }
2160
2046
  peg$silentFails++;
2161
2047
  if (input.substr(peg$currPos, 4) === peg$c220) {
2162
2048
  s0 = peg$c220;
@@ -2193,16 +2079,10 @@ function peg$parse(input, options) {
2193
2079
  peg$fail(peg$c219);
2194
2080
  }
2195
2081
  }
2196
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2197
2082
  return s0;
2198
2083
  }
2199
2084
  function peg$parseLightArrow() {
2200
2085
  var s0;
2201
- var key = peg$currPos * 164 + 19, cached = peg$resultsCache[key];
2202
- if (cached) {
2203
- peg$currPos = cached.nextPos;
2204
- return cached.result;
2205
- }
2206
2086
  peg$silentFails++;
2207
2087
  s0 = peg$parseForwardLightArrow();
2208
2088
  if (s0 === peg$FAILED) {
@@ -2217,16 +2097,10 @@ function peg$parse(input, options) {
2217
2097
  peg$fail(peg$c225);
2218
2098
  }
2219
2099
  }
2220
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2221
2100
  return s0;
2222
2101
  }
2223
2102
  function peg$parseFatArrow() {
2224
2103
  var s0;
2225
- var key = peg$currPos * 164 + 20, cached = peg$resultsCache[key];
2226
- if (cached) {
2227
- peg$currPos = cached.nextPos;
2228
- return cached.result;
2229
- }
2230
2104
  peg$silentFails++;
2231
2105
  s0 = peg$parseForwardFatArrow();
2232
2106
  if (s0 === peg$FAILED) {
@@ -2241,16 +2115,10 @@ function peg$parse(input, options) {
2241
2115
  peg$fail(peg$c226);
2242
2116
  }
2243
2117
  }
2244
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2245
2118
  return s0;
2246
2119
  }
2247
2120
  function peg$parseTildeArrow() {
2248
2121
  var s0;
2249
- var key = peg$currPos * 164 + 21, cached = peg$resultsCache[key];
2250
- if (cached) {
2251
- peg$currPos = cached.nextPos;
2252
- return cached.result;
2253
- }
2254
2122
  peg$silentFails++;
2255
2123
  s0 = peg$parseForwardTildeArrow();
2256
2124
  if (s0 === peg$FAILED) {
@@ -2265,16 +2133,10 @@ function peg$parse(input, options) {
2265
2133
  peg$fail(peg$c227);
2266
2134
  }
2267
2135
  }
2268
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2269
2136
  return s0;
2270
2137
  }
2271
2138
  function peg$parseMixedArrow() {
2272
2139
  var s0;
2273
- var key = peg$currPos * 164 + 22, cached = peg$resultsCache[key];
2274
- if (cached) {
2275
- peg$currPos = cached.nextPos;
2276
- return cached.result;
2277
- }
2278
2140
  peg$silentFails++;
2279
2141
  s0 = peg$parseLightFatArrow();
2280
2142
  if (s0 === peg$FAILED) {
@@ -2298,16 +2160,10 @@ function peg$parse(input, options) {
2298
2160
  peg$fail(peg$c228);
2299
2161
  }
2300
2162
  }
2301
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2302
2163
  return s0;
2303
2164
  }
2304
2165
  function peg$parseArrow() {
2305
2166
  var s0;
2306
- var key = peg$currPos * 164 + 23, cached = peg$resultsCache[key];
2307
- if (cached) {
2308
- peg$currPos = cached.nextPos;
2309
- return cached.result;
2310
- }
2311
2167
  peg$silentFails++;
2312
2168
  s0 = peg$parseMixedArrow();
2313
2169
  if (s0 === peg$FAILED) {
@@ -2325,16 +2181,10 @@ function peg$parse(input, options) {
2325
2181
  peg$fail(peg$c229);
2326
2182
  }
2327
2183
  }
2328
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2329
2184
  return s0;
2330
2185
  }
2331
2186
  function peg$parseBoolean() {
2332
2187
  var s0, s1;
2333
- var key = peg$currPos * 164 + 24, cached = peg$resultsCache[key];
2334
- if (cached) {
2335
- peg$currPos = cached.nextPos;
2336
- return cached.result;
2337
- }
2338
2188
  s0 = peg$currPos;
2339
2189
  if (input.substr(peg$currPos, 4) === peg$c230) {
2340
2190
  s1 = peg$c230;
@@ -2369,16 +2219,10 @@ function peg$parse(input, options) {
2369
2219
  }
2370
2220
  s0 = s1;
2371
2221
  }
2372
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2373
2222
  return s0;
2374
2223
  }
2375
2224
  function peg$parseCorners() {
2376
2225
  var s0;
2377
- var key = peg$currPos * 164 + 25, cached = peg$resultsCache[key];
2378
- if (cached) {
2379
- peg$currPos = cached.nextPos;
2380
- return cached.result;
2381
- }
2382
2226
  if (input.substr(peg$currPos, 7) === peg$c236) {
2383
2227
  s0 = peg$c236;
2384
2228
  peg$currPos += 7;
@@ -2413,16 +2257,10 @@ function peg$parse(input, options) {
2413
2257
  }
2414
2258
  }
2415
2259
  }
2416
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2417
2260
  return s0;
2418
2261
  }
2419
2262
  function peg$parseLineStyle() {
2420
2263
  var s0;
2421
- var key = peg$currPos * 164 + 26, cached = peg$resultsCache[key];
2422
- if (cached) {
2423
- peg$currPos = cached.nextPos;
2424
- return cached.result;
2425
- }
2426
2264
  if (input.substr(peg$currPos, 5) === peg$c242) {
2427
2265
  s0 = peg$c242;
2428
2266
  peg$currPos += 5;
@@ -2457,16 +2295,10 @@ function peg$parse(input, options) {
2457
2295
  }
2458
2296
  }
2459
2297
  }
2460
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2461
2298
  return s0;
2462
2299
  }
2463
2300
  function peg$parseChar() {
2464
2301
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2465
- var key = peg$currPos * 164 + 27, cached = peg$resultsCache[key];
2466
- if (cached) {
2467
- peg$currPos = cached.nextPos;
2468
- return cached.result;
2469
- }
2470
2302
  s0 = peg$parseUnescaped();
2471
2303
  if (s0 === peg$FAILED) {
2472
2304
  s0 = peg$currPos;
@@ -2695,16 +2527,10 @@ function peg$parse(input, options) {
2695
2527
  s0 = peg$FAILED;
2696
2528
  }
2697
2529
  }
2698
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2699
2530
  return s0;
2700
2531
  }
2701
2532
  function peg$parseNull() {
2702
2533
  var s0, s1;
2703
- var key = peg$currPos * 164 + 28, cached = peg$resultsCache[key];
2704
- if (cached) {
2705
- peg$currPos = cached.nextPos;
2706
- return cached.result;
2707
- }
2708
2534
  s0 = peg$currPos;
2709
2535
  if (input.substr(peg$currPos, 4) === peg$c276) {
2710
2536
  s1 = peg$c276;
@@ -2721,16 +2547,10 @@ function peg$parse(input, options) {
2721
2547
  s1 = peg$c278();
2722
2548
  }
2723
2549
  s0 = s1;
2724
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2725
2550
  return s0;
2726
2551
  }
2727
2552
  function peg$parseUndefined() {
2728
2553
  var s0, s1;
2729
- var key = peg$currPos * 164 + 29, cached = peg$resultsCache[key];
2730
- if (cached) {
2731
- peg$currPos = cached.nextPos;
2732
- return cached.result;
2733
- }
2734
2554
  s0 = peg$currPos;
2735
2555
  if (input.substr(peg$currPos, 9) === peg$c279) {
2736
2556
  s1 = peg$c279;
@@ -2747,16 +2567,10 @@ function peg$parse(input, options) {
2747
2567
  s1 = peg$c281();
2748
2568
  }
2749
2569
  s0 = s1;
2750
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2751
2570
  return s0;
2752
2571
  }
2753
2572
  function peg$parseEscape() {
2754
2573
  var s0;
2755
- var key = peg$currPos * 164 + 30, cached = peg$resultsCache[key];
2756
- if (cached) {
2757
- peg$currPos = cached.nextPos;
2758
- return cached.result;
2759
- }
2760
2574
  if (input.charCodeAt(peg$currPos) === 92) {
2761
2575
  s0 = peg$c250;
2762
2576
  peg$currPos++;
@@ -2767,16 +2581,10 @@ function peg$parse(input, options) {
2767
2581
  peg$fail(peg$c251);
2768
2582
  }
2769
2583
  }
2770
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2771
2584
  return s0;
2772
2585
  }
2773
2586
  function peg$parseQuoteMark() {
2774
2587
  var s0;
2775
- var key = peg$currPos * 164 + 31, cached = peg$resultsCache[key];
2776
- if (cached) {
2777
- peg$currPos = cached.nextPos;
2778
- return cached.result;
2779
- }
2780
2588
  if (input.charCodeAt(peg$currPos) === 34) {
2781
2589
  s0 = peg$c248;
2782
2590
  peg$currPos++;
@@ -2787,16 +2595,10 @@ function peg$parse(input, options) {
2787
2595
  peg$fail(peg$c249);
2788
2596
  }
2789
2597
  }
2790
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2791
2598
  return s0;
2792
2599
  }
2793
2600
  function peg$parseUnescaped() {
2794
2601
  var s0;
2795
- var key = peg$currPos * 164 + 32, cached = peg$resultsCache[key];
2796
- if (cached) {
2797
- peg$currPos = cached.nextPos;
2798
- return cached.result;
2799
- }
2800
2602
  if (peg$c282.test(input.charAt(peg$currPos))) {
2801
2603
  s0 = input.charAt(peg$currPos);
2802
2604
  peg$currPos++;
@@ -2807,16 +2609,10 @@ function peg$parse(input, options) {
2807
2609
  peg$fail(peg$c283);
2808
2610
  }
2809
2611
  }
2810
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2811
2612
  return s0;
2812
2613
  }
2813
2614
  function peg$parseActionLabelChar() {
2814
2615
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2815
- var key = peg$currPos * 164 + 33, cached = peg$resultsCache[key];
2816
- if (cached) {
2817
- peg$currPos = cached.nextPos;
2818
- return cached.result;
2819
- }
2820
2616
  s0 = peg$parseActionLabelUnescaped();
2821
2617
  if (s0 === peg$FAILED) {
2822
2618
  s0 = peg$currPos;
@@ -3045,16 +2841,10 @@ function peg$parse(input, options) {
3045
2841
  s0 = peg$FAILED;
3046
2842
  }
3047
2843
  }
3048
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3049
2844
  return s0;
3050
2845
  }
3051
2846
  function peg$parseActionLabelQuoteMark() {
3052
2847
  var s0;
3053
- var key = peg$currPos * 164 + 34, cached = peg$resultsCache[key];
3054
- if (cached) {
3055
- peg$currPos = cached.nextPos;
3056
- return cached.result;
3057
- }
3058
2848
  if (input.charCodeAt(peg$currPos) === 39) {
3059
2849
  s0 = peg$c284;
3060
2850
  peg$currPos++;
@@ -3065,16 +2855,10 @@ function peg$parse(input, options) {
3065
2855
  peg$fail(peg$c285);
3066
2856
  }
3067
2857
  }
3068
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3069
2858
  return s0;
3070
2859
  }
3071
2860
  function peg$parseActionLabelUnescaped() {
3072
2861
  var s0;
3073
- var key = peg$currPos * 164 + 35, cached = peg$resultsCache[key];
3074
- if (cached) {
3075
- peg$currPos = cached.nextPos;
3076
- return cached.result;
3077
- }
3078
2862
  if (peg$c286.test(input.charAt(peg$currPos))) {
3079
2863
  s0 = input.charAt(peg$currPos);
3080
2864
  peg$currPos++;
@@ -3085,16 +2869,10 @@ function peg$parse(input, options) {
3085
2869
  peg$fail(peg$c287);
3086
2870
  }
3087
2871
  }
3088
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3089
2872
  return s0;
3090
2873
  }
3091
2874
  function peg$parseActionLabel() {
3092
2875
  var s0, s1, s2, s3;
3093
- var key = peg$currPos * 164 + 36, cached = peg$resultsCache[key];
3094
- if (cached) {
3095
- peg$currPos = cached.nextPos;
3096
- return cached.result;
3097
- }
3098
2876
  peg$silentFails++;
3099
2877
  s0 = peg$currPos;
3100
2878
  s1 = peg$parseActionLabelQuoteMark();
@@ -3133,16 +2911,10 @@ function peg$parse(input, options) {
3133
2911
  peg$fail(peg$c288);
3134
2912
  }
3135
2913
  }
3136
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3137
2914
  return s0;
3138
2915
  }
3139
2916
  function peg$parseLineTerminator() {
3140
2917
  var s0;
3141
- var key = peg$currPos * 164 + 37, cached = peg$resultsCache[key];
3142
- if (cached) {
3143
- peg$currPos = cached.nextPos;
3144
- return cached.result;
3145
- }
3146
2918
  if (peg$c290.test(input.charAt(peg$currPos))) {
3147
2919
  s0 = input.charAt(peg$currPos);
3148
2920
  peg$currPos++;
@@ -3153,16 +2925,10 @@ function peg$parse(input, options) {
3153
2925
  peg$fail(peg$c291);
3154
2926
  }
3155
2927
  }
3156
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3157
2928
  return s0;
3158
2929
  }
3159
2930
  function peg$parseBlockComment() {
3160
2931
  var s0, s1, s2, s3, s4, s5;
3161
- var key = peg$currPos * 164 + 38, cached = peg$resultsCache[key];
3162
- if (cached) {
3163
- peg$currPos = cached.nextPos;
3164
- return cached.result;
3165
- }
3166
2932
  peg$silentFails++;
3167
2933
  s0 = peg$currPos;
3168
2934
  if (input.substr(peg$currPos, 2) === peg$c293) {
@@ -3306,16 +3072,10 @@ function peg$parse(input, options) {
3306
3072
  peg$fail(peg$c292);
3307
3073
  }
3308
3074
  }
3309
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3310
3075
  return s0;
3311
3076
  }
3312
3077
  function peg$parseEOF() {
3313
3078
  var s0, s1;
3314
- var key = peg$currPos * 164 + 39, cached = peg$resultsCache[key];
3315
- if (cached) {
3316
- peg$currPos = cached.nextPos;
3317
- return cached.result;
3318
- }
3319
3079
  s0 = peg$currPos;
3320
3080
  peg$silentFails++;
3321
3081
  if (input.length > peg$currPos) {
@@ -3336,16 +3096,10 @@ function peg$parse(input, options) {
3336
3096
  peg$currPos = s0;
3337
3097
  s0 = peg$FAILED;
3338
3098
  }
3339
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3340
3099
  return s0;
3341
3100
  }
3342
3101
  function peg$parseLineComment() {
3343
3102
  var s0, s1, s2, s3, s4, s5;
3344
- var key = peg$currPos * 164 + 40, cached = peg$resultsCache[key];
3345
- if (cached) {
3346
- peg$currPos = cached.nextPos;
3347
- return cached.result;
3348
- }
3349
3103
  peg$silentFails++;
3350
3104
  s0 = peg$currPos;
3351
3105
  if (input.substr(peg$currPos, 2) === peg$c299) {
@@ -3465,16 +3219,10 @@ function peg$parse(input, options) {
3465
3219
  peg$fail(peg$c298);
3466
3220
  }
3467
3221
  }
3468
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3469
3222
  return s0;
3470
3223
  }
3471
3224
  function peg$parseWS() {
3472
3225
  var s0, s1, s2;
3473
- var key = peg$currPos * 164 + 41, cached = peg$resultsCache[key];
3474
- if (cached) {
3475
- peg$currPos = cached.nextPos;
3476
- return cached.result;
3477
- }
3478
3226
  peg$silentFails++;
3479
3227
  s0 = [];
3480
3228
  s1 = [];
@@ -3562,16 +3310,10 @@ function peg$parse(input, options) {
3562
3310
  peg$fail(peg$c301);
3563
3311
  }
3564
3312
  }
3565
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3566
3313
  return s0;
3567
3314
  }
3568
3315
  function peg$parseString() {
3569
3316
  var s0, s1, s2, s3;
3570
- var key = peg$currPos * 164 + 42, cached = peg$resultsCache[key];
3571
- if (cached) {
3572
- peg$currPos = cached.nextPos;
3573
- return cached.result;
3574
- }
3575
3317
  peg$silentFails++;
3576
3318
  s0 = peg$currPos;
3577
3319
  s1 = peg$parseQuoteMark();
@@ -3610,16 +3352,10 @@ function peg$parse(input, options) {
3610
3352
  peg$fail(peg$c304);
3611
3353
  }
3612
3354
  }
3613
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3614
3355
  return s0;
3615
3356
  }
3616
3357
  function peg$parseAtomFirstLetter() {
3617
3358
  var s0;
3618
- var key = peg$currPos * 164 + 43, cached = peg$resultsCache[key];
3619
- if (cached) {
3620
- peg$currPos = cached.nextPos;
3621
- return cached.result;
3622
- }
3623
3359
  if (peg$c305.test(input.charAt(peg$currPos))) {
3624
3360
  s0 = input.charAt(peg$currPos);
3625
3361
  peg$currPos++;
@@ -3630,16 +3366,10 @@ function peg$parse(input, options) {
3630
3366
  peg$fail(peg$c306);
3631
3367
  }
3632
3368
  }
3633
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3634
3369
  return s0;
3635
3370
  }
3636
3371
  function peg$parseAtomLetter() {
3637
3372
  var s0;
3638
- var key = peg$currPos * 164 + 44, cached = peg$resultsCache[key];
3639
- if (cached) {
3640
- peg$currPos = cached.nextPos;
3641
- return cached.result;
3642
- }
3643
3373
  if (peg$c307.test(input.charAt(peg$currPos))) {
3644
3374
  s0 = input.charAt(peg$currPos);
3645
3375
  peg$currPos++;
@@ -3650,16 +3380,10 @@ function peg$parse(input, options) {
3650
3380
  peg$fail(peg$c308);
3651
3381
  }
3652
3382
  }
3653
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3654
3383
  return s0;
3655
3384
  }
3656
3385
  function peg$parseAtom() {
3657
3386
  var s0, s1, s2, s3;
3658
- var key = peg$currPos * 164 + 45, cached = peg$resultsCache[key];
3659
- if (cached) {
3660
- peg$currPos = cached.nextPos;
3661
- return cached.result;
3662
- }
3663
3387
  peg$silentFails++;
3664
3388
  s0 = peg$currPos;
3665
3389
  s1 = peg$parseAtomFirstLetter();
@@ -3691,16 +3415,10 @@ function peg$parse(input, options) {
3691
3415
  peg$fail(peg$c309);
3692
3416
  }
3693
3417
  }
3694
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3695
3418
  return s0;
3696
3419
  }
3697
3420
  function peg$parseLabel() {
3698
3421
  var s0;
3699
- var key = peg$currPos * 164 + 46, cached = peg$resultsCache[key];
3700
- if (cached) {
3701
- peg$currPos = cached.nextPos;
3702
- return cached.result;
3703
- }
3704
3422
  peg$silentFails++;
3705
3423
  s0 = peg$parseAtom();
3706
3424
  if (s0 === peg$FAILED) {
@@ -3712,16 +3430,10 @@ function peg$parse(input, options) {
3712
3430
  peg$fail(peg$c311);
3713
3431
  }
3714
3432
  }
3715
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3716
3433
  return s0;
3717
3434
  }
3718
3435
  function peg$parseIntegerLiteral() {
3719
3436
  var s0, s1, s2, s3, s4;
3720
- var key = peg$currPos * 164 + 47, cached = peg$resultsCache[key];
3721
- if (cached) {
3722
- peg$currPos = cached.nextPos;
3723
- return cached.result;
3724
- }
3725
3437
  s0 = peg$currPos;
3726
3438
  if (input.charCodeAt(peg$currPos) === 48) {
3727
3439
  s1 = peg$c312;
@@ -3763,16 +3475,10 @@ function peg$parse(input, options) {
3763
3475
  else {
3764
3476
  s0 = s1;
3765
3477
  }
3766
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3767
3478
  return s0;
3768
3479
  }
3769
3480
  function peg$parseDecimalDigit() {
3770
3481
  var s0;
3771
- var key = peg$currPos * 164 + 48, cached = peg$resultsCache[key];
3772
- if (cached) {
3773
- peg$currPos = cached.nextPos;
3774
- return cached.result;
3775
- }
3776
3482
  if (peg$c314.test(input.charAt(peg$currPos))) {
3777
3483
  s0 = input.charAt(peg$currPos);
3778
3484
  peg$currPos++;
@@ -3783,16 +3489,10 @@ function peg$parse(input, options) {
3783
3489
  peg$fail(peg$c315);
3784
3490
  }
3785
3491
  }
3786
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3787
3492
  return s0;
3788
3493
  }
3789
3494
  function peg$parseNonZeroDigit() {
3790
3495
  var s0;
3791
- var key = peg$currPos * 164 + 49, cached = peg$resultsCache[key];
3792
- if (cached) {
3793
- peg$currPos = cached.nextPos;
3794
- return cached.result;
3795
- }
3796
3496
  if (peg$c316.test(input.charAt(peg$currPos))) {
3797
3497
  s0 = input.charAt(peg$currPos);
3798
3498
  peg$currPos++;
@@ -3803,16 +3503,10 @@ function peg$parse(input, options) {
3803
3503
  peg$fail(peg$c317);
3804
3504
  }
3805
3505
  }
3806
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3807
3506
  return s0;
3808
3507
  }
3809
3508
  function peg$parseHexDigit() {
3810
3509
  var s0;
3811
- var key = peg$currPos * 164 + 50, cached = peg$resultsCache[key];
3812
- if (cached) {
3813
- peg$currPos = cached.nextPos;
3814
- return cached.result;
3815
- }
3816
3510
  if (peg$c318.test(input.charAt(peg$currPos))) {
3817
3511
  s0 = input.charAt(peg$currPos);
3818
3512
  peg$currPos++;
@@ -3823,16 +3517,10 @@ function peg$parse(input, options) {
3823
3517
  peg$fail(peg$c319);
3824
3518
  }
3825
3519
  }
3826
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3827
3520
  return s0;
3828
3521
  }
3829
3522
  function peg$parseBinaryDigit() {
3830
3523
  var s0;
3831
- var key = peg$currPos * 164 + 51, cached = peg$resultsCache[key];
3832
- if (cached) {
3833
- peg$currPos = cached.nextPos;
3834
- return cached.result;
3835
- }
3836
3524
  if (peg$c320.test(input.charAt(peg$currPos))) {
3837
3525
  s0 = input.charAt(peg$currPos);
3838
3526
  peg$currPos++;
@@ -3843,16 +3531,10 @@ function peg$parse(input, options) {
3843
3531
  peg$fail(peg$c321);
3844
3532
  }
3845
3533
  }
3846
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3847
3534
  return s0;
3848
3535
  }
3849
3536
  function peg$parseOctalDigit() {
3850
3537
  var s0;
3851
- var key = peg$currPos * 164 + 52, cached = peg$resultsCache[key];
3852
- if (cached) {
3853
- peg$currPos = cached.nextPos;
3854
- return cached.result;
3855
- }
3856
3538
  if (peg$c322.test(input.charAt(peg$currPos))) {
3857
3539
  s0 = input.charAt(peg$currPos);
3858
3540
  peg$currPos++;
@@ -3863,16 +3545,10 @@ function peg$parse(input, options) {
3863
3545
  peg$fail(peg$c323);
3864
3546
  }
3865
3547
  }
3866
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3867
3548
  return s0;
3868
3549
  }
3869
3550
  function peg$parseNonNegNumber() {
3870
3551
  var s0, s1, s2, s3, s4;
3871
- var key = peg$currPos * 164 + 53, cached = peg$resultsCache[key];
3872
- if (cached) {
3873
- peg$currPos = cached.nextPos;
3874
- return cached.result;
3875
- }
3876
3552
  peg$silentFails++;
3877
3553
  s0 = peg$currPos;
3878
3554
  s1 = peg$parseIntegerLiteral();
@@ -3953,16 +3629,10 @@ function peg$parse(input, options) {
3953
3629
  peg$fail(peg$c324);
3954
3630
  }
3955
3631
  }
3956
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
3957
3632
  return s0;
3958
3633
  }
3959
3634
  function peg$parseJsNumericLiteral() {
3960
3635
  var s0, s1;
3961
- var key = peg$currPos * 164 + 54, cached = peg$resultsCache[key];
3962
- if (cached) {
3963
- peg$currPos = cached.nextPos;
3964
- return cached.result;
3965
- }
3966
3636
  peg$silentFails++;
3967
3637
  s0 = peg$currPos;
3968
3638
  s1 = peg$parseJsHexIntegerLiteral();
@@ -4797,16 +4467,10 @@ function peg$parse(input, options) {
4797
4467
  peg$fail(peg$c328);
4798
4468
  }
4799
4469
  }
4800
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
4801
4470
  return s0;
4802
4471
  }
4803
4472
  function peg$parseJsDecimalLiteral() {
4804
4473
  var s0, s1, s2, s3, s4;
4805
- var key = peg$currPos * 164 + 55, cached = peg$resultsCache[key];
4806
- if (cached) {
4807
- peg$currPos = cached.nextPos;
4808
- return cached.result;
4809
- }
4810
4474
  s0 = peg$currPos;
4811
4475
  s1 = peg$parseJsDecimalIntegerLiteral();
4812
4476
  if (s1 !== peg$FAILED) {
@@ -4928,16 +4592,10 @@ function peg$parse(input, options) {
4928
4592
  }
4929
4593
  }
4930
4594
  }
4931
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
4932
4595
  return s0;
4933
4596
  }
4934
4597
  function peg$parseJsDecimalIntegerLiteral() {
4935
4598
  var s0, s1, s2, s3;
4936
- var key = peg$currPos * 164 + 56, cached = peg$resultsCache[key];
4937
- if (cached) {
4938
- peg$currPos = cached.nextPos;
4939
- return cached.result;
4940
- }
4941
4599
  if (input.charCodeAt(peg$currPos) === 48) {
4942
4600
  s0 = peg$c312;
4943
4601
  peg$currPos++;
@@ -4972,16 +4630,10 @@ function peg$parse(input, options) {
4972
4630
  s0 = peg$FAILED;
4973
4631
  }
4974
4632
  }
4975
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
4976
4633
  return s0;
4977
4634
  }
4978
4635
  function peg$parseJsNExponentPart() {
4979
4636
  var s0, s1, s2;
4980
- var key = peg$currPos * 164 + 57, cached = peg$resultsCache[key];
4981
- if (cached) {
4982
- peg$currPos = cached.nextPos;
4983
- return cached.result;
4984
- }
4985
4637
  s0 = peg$currPos;
4986
4638
  s1 = peg$parseJsNExponentIndicator();
4987
4639
  if (s1 !== peg$FAILED) {
@@ -4999,16 +4651,10 @@ function peg$parse(input, options) {
4999
4651
  peg$currPos = s0;
5000
4652
  s0 = peg$FAILED;
5001
4653
  }
5002
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
5003
4654
  return s0;
5004
4655
  }
5005
4656
  function peg$parseJsNExponentIndicator() {
5006
4657
  var s0;
5007
- var key = peg$currPos * 164 + 58, cached = peg$resultsCache[key];
5008
- if (cached) {
5009
- peg$currPos = cached.nextPos;
5010
- return cached.result;
5011
- }
5012
4658
  if (input.substr(peg$currPos, 1).toLowerCase() === peg$c378) {
5013
4659
  s0 = input.charAt(peg$currPos);
5014
4660
  peg$currPos++;
@@ -5019,16 +4665,10 @@ function peg$parse(input, options) {
5019
4665
  peg$fail(peg$c436);
5020
4666
  }
5021
4667
  }
5022
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
5023
4668
  return s0;
5024
4669
  }
5025
4670
  function peg$parseJsNSignedInteger() {
5026
4671
  var s0, s1, s2, s3;
5027
- var key = peg$currPos * 164 + 59, cached = peg$resultsCache[key];
5028
- if (cached) {
5029
- peg$currPos = cached.nextPos;
5030
- return cached.result;
5031
- }
5032
4672
  s0 = peg$currPos;
5033
4673
  if (peg$c437.test(input.charAt(peg$currPos))) {
5034
4674
  s1 = input.charAt(peg$currPos);
@@ -5068,16 +4708,10 @@ function peg$parse(input, options) {
5068
4708
  peg$currPos = s0;
5069
4709
  s0 = peg$FAILED;
5070
4710
  }
5071
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
5072
4711
  return s0;
5073
4712
  }
5074
4713
  function peg$parseJsHexIntegerLiteral() {
5075
4714
  var s0, s1, s2, s3, s4;
5076
- var key = peg$currPos * 164 + 60, cached = peg$resultsCache[key];
5077
- if (cached) {
5078
- peg$currPos = cached.nextPos;
5079
- return cached.result;
5080
- }
5081
4715
  s0 = peg$currPos;
5082
4716
  if (input.substr(peg$currPos, 2).toLowerCase() === peg$c439) {
5083
4717
  s1 = input.substr(peg$currPos, 2);
@@ -5122,16 +4756,10 @@ function peg$parse(input, options) {
5122
4756
  peg$currPos = s0;
5123
4757
  s0 = peg$FAILED;
5124
4758
  }
5125
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
5126
4759
  return s0;
5127
4760
  }
5128
4761
  function peg$parseJsBinaryIntegerLiteral() {
5129
4762
  var s0, s1, s2, s3, s4;
5130
- var key = peg$currPos * 164 + 61, cached = peg$resultsCache[key];
5131
- if (cached) {
5132
- peg$currPos = cached.nextPos;
5133
- return cached.result;
5134
- }
5135
4763
  s0 = peg$currPos;
5136
4764
  if (input.substr(peg$currPos, 2).toLowerCase() === peg$c442) {
5137
4765
  s1 = input.substr(peg$currPos, 2);
@@ -5176,16 +4804,10 @@ function peg$parse(input, options) {
5176
4804
  peg$currPos = s0;
5177
4805
  s0 = peg$FAILED;
5178
4806
  }
5179
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
5180
4807
  return s0;
5181
4808
  }
5182
4809
  function peg$parseNonJsOctalIntegerLiteral() {
5183
4810
  var s0, s1, s2, s3, s4;
5184
- var key = peg$currPos * 164 + 62, cached = peg$resultsCache[key];
5185
- if (cached) {
5186
- peg$currPos = cached.nextPos;
5187
- return cached.result;
5188
- }
5189
4811
  s0 = peg$currPos;
5190
4812
  if (input.substr(peg$currPos, 2).toLowerCase() === peg$c445) {
5191
4813
  s1 = input.substr(peg$currPos, 2);
@@ -5230,16 +4852,10 @@ function peg$parse(input, options) {
5230
4852
  peg$currPos = s0;
5231
4853
  s0 = peg$FAILED;
5232
4854
  }
5233
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
5234
4855
  return s0;
5235
4856
  }
5236
4857
  function peg$parseSemVer() {
5237
4858
  var s0, s1, s2, s3, s4, s5;
5238
- var key = peg$currPos * 164 + 63, cached = peg$resultsCache[key];
5239
- if (cached) {
5240
- peg$currPos = cached.nextPos;
5241
- return cached.result;
5242
- }
5243
4859
  s0 = peg$currPos;
5244
4860
  s1 = peg$parseIntegerLiteral();
5245
4861
  if (s1 !== peg$FAILED) {
@@ -5297,16 +4913,10 @@ function peg$parse(input, options) {
5297
4913
  peg$currPos = s0;
5298
4914
  s0 = peg$FAILED;
5299
4915
  }
5300
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
5301
4916
  return s0;
5302
4917
  }
5303
4918
  function peg$parseUrlProtocol() {
5304
4919
  var s0;
5305
- var key = peg$currPos * 164 + 67, cached = peg$resultsCache[key];
5306
- if (cached) {
5307
- peg$currPos = cached.nextPos;
5308
- return cached.result;
5309
- }
5310
4920
  if (input.substr(peg$currPos, 7) === peg$c459) {
5311
4921
  s0 = peg$c459;
5312
4922
  peg$currPos += 7;
@@ -5329,16 +4939,10 @@ function peg$parse(input, options) {
5329
4939
  }
5330
4940
  }
5331
4941
  }
5332
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
5333
4942
  return s0;
5334
4943
  }
5335
4944
  function peg$parseURL() {
5336
4945
  var s0, s1, s2, s3;
5337
- var key = peg$currPos * 164 + 68, cached = peg$resultsCache[key];
5338
- if (cached) {
5339
- peg$currPos = cached.nextPos;
5340
- return cached.result;
5341
- }
5342
4946
  s0 = peg$currPos;
5343
4947
  s1 = peg$parseUrlProtocol();
5344
4948
  if (s1 !== peg$FAILED) {
@@ -5385,16 +4989,10 @@ function peg$parse(input, options) {
5385
4989
  peg$currPos = s0;
5386
4990
  s0 = peg$FAILED;
5387
4991
  }
5388
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
5389
4992
  return s0;
5390
4993
  }
5391
4994
  function peg$parseSvgColorLabel() {
5392
4995
  var s0, s1;
5393
- var key = peg$currPos * 164 + 69, cached = peg$resultsCache[key];
5394
- if (cached) {
5395
- peg$currPos = cached.nextPos;
5396
- return cached.result;
5397
- }
5398
4996
  s0 = peg$currPos;
5399
4997
  if (input.substr(peg$currPos, 9) === peg$c466) {
5400
4998
  s1 = peg$c466;
@@ -10685,16 +10283,10 @@ function peg$parse(input, options) {
10685
10283
  }
10686
10284
  }
10687
10285
  }
10688
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
10689
10286
  return s0;
10690
10287
  }
10691
10288
  function peg$parseSvgColor() {
10692
10289
  var s0, s1, s2;
10693
- var key = peg$currPos * 164 + 70, cached = peg$resultsCache[key];
10694
- if (cached) {
10695
- peg$currPos = cached.nextPos;
10696
- return cached.result;
10697
- }
10698
10290
  s0 = peg$currPos;
10699
10291
  s1 = peg$parseSvgColorLabel();
10700
10292
  if (s1 !== peg$FAILED) {
@@ -10716,16 +10308,10 @@ function peg$parse(input, options) {
10716
10308
  peg$currPos = s0;
10717
10309
  s0 = peg$FAILED;
10718
10310
  }
10719
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
10720
10311
  return s0;
10721
10312
  }
10722
10313
  function peg$parseRgb3() {
10723
10314
  var s0, s1, s2, s3, s4, s5;
10724
- var key = peg$currPos * 164 + 71, cached = peg$resultsCache[key];
10725
- if (cached) {
10726
- peg$currPos = cached.nextPos;
10727
- return cached.result;
10728
- }
10729
10315
  s0 = peg$currPos;
10730
10316
  if (input.charCodeAt(peg$currPos) === 35) {
10731
10317
  s1 = peg$c1193;
@@ -10777,16 +10363,10 @@ function peg$parse(input, options) {
10777
10363
  peg$currPos = s0;
10778
10364
  s0 = peg$FAILED;
10779
10365
  }
10780
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
10781
10366
  return s0;
10782
10367
  }
10783
10368
  function peg$parseRgb6() {
10784
10369
  var s0, s1, s2, s3, s4, s5, s6, s7, s8;
10785
- var key = peg$currPos * 164 + 72, cached = peg$resultsCache[key];
10786
- if (cached) {
10787
- peg$currPos = cached.nextPos;
10788
- return cached.result;
10789
- }
10790
10370
  s0 = peg$currPos;
10791
10371
  if (input.charCodeAt(peg$currPos) === 35) {
10792
10372
  s1 = peg$c1193;
@@ -10859,16 +10439,10 @@ function peg$parse(input, options) {
10859
10439
  peg$currPos = s0;
10860
10440
  s0 = peg$FAILED;
10861
10441
  }
10862
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
10863
10442
  return s0;
10864
10443
  }
10865
10444
  function peg$parseRgba4() {
10866
10445
  var s0, s1, s2, s3, s4, s5, s6;
10867
- var key = peg$currPos * 164 + 73, cached = peg$resultsCache[key];
10868
- if (cached) {
10869
- peg$currPos = cached.nextPos;
10870
- return cached.result;
10871
- }
10872
10446
  s0 = peg$currPos;
10873
10447
  if (input.charCodeAt(peg$currPos) === 35) {
10874
10448
  s1 = peg$c1193;
@@ -10927,16 +10501,10 @@ function peg$parse(input, options) {
10927
10501
  peg$currPos = s0;
10928
10502
  s0 = peg$FAILED;
10929
10503
  }
10930
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
10931
10504
  return s0;
10932
10505
  }
10933
10506
  function peg$parseRgba8() {
10934
10507
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
10935
- var key = peg$currPos * 164 + 74, cached = peg$resultsCache[key];
10936
- if (cached) {
10937
- peg$currPos = cached.nextPos;
10938
- return cached.result;
10939
- }
10940
10508
  s0 = peg$currPos;
10941
10509
  if (input.charCodeAt(peg$currPos) === 35) {
10942
10510
  s1 = peg$c1193;
@@ -11023,16 +10591,10 @@ function peg$parse(input, options) {
11023
10591
  peg$currPos = s0;
11024
10592
  s0 = peg$FAILED;
11025
10593
  }
11026
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
11027
10594
  return s0;
11028
10595
  }
11029
10596
  function peg$parseColor() {
11030
10597
  var s0;
11031
- var key = peg$currPos * 164 + 75, cached = peg$resultsCache[key];
11032
- if (cached) {
11033
- peg$currPos = cached.nextPos;
11034
- return cached.result;
11035
- }
11036
10598
  peg$silentFails++;
11037
10599
  s0 = peg$parseSvgColor();
11038
10600
  if (s0 === peg$FAILED) {
@@ -11053,16 +10615,10 @@ function peg$parse(input, options) {
11053
10615
  peg$fail(peg$c1199);
11054
10616
  }
11055
10617
  }
11056
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
11057
10618
  return s0;
11058
10619
  }
11059
10620
  function peg$parseArrowItemKey() {
11060
10621
  var s0;
11061
- var key = peg$currPos * 164 + 76, cached = peg$resultsCache[key];
11062
- if (cached) {
11063
- peg$currPos = cached.nextPos;
11064
- return cached.result;
11065
- }
11066
10622
  if (input.substr(peg$currPos, 9) === peg$c1200) {
11067
10623
  s0 = peg$c1200;
11068
10624
  peg$currPos += 9;
@@ -11097,16 +10653,10 @@ function peg$parse(input, options) {
11097
10653
  }
11098
10654
  }
11099
10655
  }
11100
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
11101
10656
  return s0;
11102
10657
  }
11103
10658
  function peg$parseArrowItem() {
11104
10659
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
11105
- var key = peg$currPos * 164 + 77, cached = peg$resultsCache[key];
11106
- if (cached) {
11107
- peg$currPos = cached.nextPos;
11108
- return cached.result;
11109
- }
11110
10660
  s0 = peg$currPos;
11111
10661
  s1 = peg$parseWS();
11112
10662
  if (s1 === peg$FAILED) {
@@ -11207,16 +10757,10 @@ function peg$parse(input, options) {
11207
10757
  peg$currPos = s0;
11208
10758
  s0 = peg$FAILED;
11209
10759
  }
11210
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
11211
10760
  return s0;
11212
10761
  }
11213
10762
  function peg$parseSingleEdgeColor() {
11214
10763
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
11215
- var key = peg$currPos * 164 + 78, cached = peg$resultsCache[key];
11216
- if (cached) {
11217
- peg$currPos = cached.nextPos;
11218
- return cached.result;
11219
- }
11220
10764
  peg$silentFails++;
11221
10765
  s0 = peg$currPos;
11222
10766
  s1 = peg$parseWS();
@@ -11445,16 +10989,10 @@ function peg$parse(input, options) {
11445
10989
  peg$fail(peg$c1211);
11446
10990
  }
11447
10991
  }
11448
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
11449
10992
  return s0;
11450
10993
  }
11451
10994
  function peg$parseTransitionLineStyle() {
11452
10995
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
11453
- var key = peg$currPos * 164 + 79, cached = peg$resultsCache[key];
11454
- if (cached) {
11455
- peg$currPos = cached.nextPos;
11456
- return cached.result;
11457
- }
11458
10996
  peg$silentFails++;
11459
10997
  s0 = peg$currPos;
11460
10998
  s1 = peg$parseWS();
@@ -11572,16 +11110,10 @@ function peg$parse(input, options) {
11572
11110
  peg$fail(peg$c1217);
11573
11111
  }
11574
11112
  }
11575
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
11576
11113
  return s0;
11577
11114
  }
11578
11115
  function peg$parseArrowItems() {
11579
11116
  var s0, s1;
11580
- var key = peg$currPos * 164 + 80, cached = peg$resultsCache[key];
11581
- if (cached) {
11582
- peg$currPos = cached.nextPos;
11583
- return cached.result;
11584
- }
11585
11117
  s0 = peg$parseSingleEdgeColor();
11586
11118
  if (s0 === peg$FAILED) {
11587
11119
  s0 = peg$parseTransitionLineStyle();
@@ -11599,16 +11131,10 @@ function peg$parse(input, options) {
11599
11131
  }
11600
11132
  }
11601
11133
  }
11602
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
11603
11134
  return s0;
11604
11135
  }
11605
11136
  function peg$parseArrowDesc() {
11606
11137
  var s0, s1, s2, s3, s4, s5;
11607
- var key = peg$currPos * 164 + 81, cached = peg$resultsCache[key];
11608
- if (cached) {
11609
- peg$currPos = cached.nextPos;
11610
- return cached.result;
11611
- }
11612
11138
  s0 = peg$currPos;
11613
11139
  if (input.charCodeAt(peg$currPos) === 123) {
11614
11140
  s1 = peg$c1221;
@@ -11675,16 +11201,10 @@ function peg$parse(input, options) {
11675
11201
  peg$currPos = s0;
11676
11202
  s0 = peg$FAILED;
11677
11203
  }
11678
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
11679
11204
  return s0;
11680
11205
  }
11681
11206
  function peg$parseArrowProbability() {
11682
11207
  var s0, s1, s2;
11683
- var key = peg$currPos * 164 + 82, cached = peg$resultsCache[key];
11684
- if (cached) {
11685
- peg$currPos = cached.nextPos;
11686
- return cached.result;
11687
- }
11688
11208
  s0 = peg$currPos;
11689
11209
  s1 = peg$parseNonNegNumber();
11690
11210
  if (s1 !== peg$FAILED) {
@@ -11712,16 +11232,10 @@ function peg$parse(input, options) {
11712
11232
  peg$currPos = s0;
11713
11233
  s0 = peg$FAILED;
11714
11234
  }
11715
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
11716
11235
  return s0;
11717
11236
  }
11718
11237
  function peg$parseTimeType() {
11719
11238
  var s0, s1;
11720
- var key = peg$currPos * 164 + 83, cached = peg$resultsCache[key];
11721
- if (cached) {
11722
- peg$currPos = cached.nextPos;
11723
- return cached.result;
11724
- }
11725
11239
  s0 = peg$currPos;
11726
11240
  if (input.substr(peg$currPos, 12) === peg$c1229) {
11727
11241
  s1 = peg$c1229;
@@ -12224,16 +11738,10 @@ function peg$parse(input, options) {
12224
11738
  }
12225
11739
  }
12226
11740
  }
12227
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
12228
11741
  return s0;
12229
11742
  }
12230
11743
  function peg$parseArrowAfter() {
12231
11744
  var s0, s1, s2, s3, s4, s5;
12232
- var key = peg$currPos * 164 + 84, cached = peg$resultsCache[key];
12233
- if (cached) {
12234
- peg$currPos = cached.nextPos;
12235
- return cached.result;
12236
- }
12237
11745
  s0 = peg$currPos;
12238
11746
  if (input.substr(peg$currPos, 5) === peg$c1291) {
12239
11747
  s1 = peg$c1291;
@@ -12288,16 +11796,10 @@ function peg$parse(input, options) {
12288
11796
  peg$currPos = s0;
12289
11797
  s0 = peg$FAILED;
12290
11798
  }
12291
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
12292
11799
  return s0;
12293
11800
  }
12294
11801
  function peg$parseLabelList() {
12295
11802
  var s0, s1, s2, s3, s4, s5, s6;
12296
- var key = peg$currPos * 164 + 85, cached = peg$resultsCache[key];
12297
- if (cached) {
12298
- peg$currPos = cached.nextPos;
12299
- return cached.result;
12300
- }
12301
11803
  s0 = peg$currPos;
12302
11804
  if (input.charCodeAt(peg$currPos) === 91) {
12303
11805
  s1 = peg$c11;
@@ -12394,30 +11896,18 @@ function peg$parse(input, options) {
12394
11896
  peg$currPos = s0;
12395
11897
  s0 = peg$FAILED;
12396
11898
  }
12397
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
12398
11899
  return s0;
12399
11900
  }
12400
11901
  function peg$parseLabelOrLabelList() {
12401
11902
  var s0;
12402
- var key = peg$currPos * 164 + 86, cached = peg$resultsCache[key];
12403
- if (cached) {
12404
- peg$currPos = cached.nextPos;
12405
- return cached.result;
12406
- }
12407
11903
  s0 = peg$parseLabelList();
12408
11904
  if (s0 === peg$FAILED) {
12409
11905
  s0 = peg$parseLabel();
12410
11906
  }
12411
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
12412
11907
  return s0;
12413
11908
  }
12414
11909
  function peg$parseStripe() {
12415
11910
  var s0, s1, s2, s3, s4, s5, s6;
12416
- var key = peg$currPos * 164 + 87, cached = peg$resultsCache[key];
12417
- if (cached) {
12418
- peg$currPos = cached.nextPos;
12419
- return cached.result;
12420
- }
12421
11911
  s0 = peg$currPos;
12422
11912
  if (input.substr(peg$currPos, 2) === peg$c1295) {
12423
11913
  s1 = peg$c1295;
@@ -12530,16 +12020,10 @@ function peg$parse(input, options) {
12530
12020
  s0 = peg$FAILED;
12531
12021
  }
12532
12022
  }
12533
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
12534
12023
  return s0;
12535
12024
  }
12536
12025
  function peg$parseCycle() {
12537
12026
  var s0, s1, s2, s3, s4, s5, s6;
12538
- var key = peg$currPos * 164 + 88, cached = peg$resultsCache[key];
12539
- if (cached) {
12540
- peg$currPos = cached.nextPos;
12541
- return cached.result;
12542
- }
12543
12027
  s0 = peg$currPos;
12544
12028
  if (input.charCodeAt(peg$currPos) === 43) {
12545
12029
  s1 = peg$c1301;
@@ -12670,16 +12154,10 @@ function peg$parse(input, options) {
12670
12154
  s0 = s1;
12671
12155
  }
12672
12156
  }
12673
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
12674
12157
  return s0;
12675
12158
  }
12676
12159
  function peg$parseArrowTarget() {
12677
12160
  var s0;
12678
- var key = peg$currPos * 164 + 89, cached = peg$resultsCache[key];
12679
- if (cached) {
12680
- peg$currPos = cached.nextPos;
12681
- return cached.result;
12682
- }
12683
12161
  s0 = peg$parseStripe();
12684
12162
  if (s0 === peg$FAILED) {
12685
12163
  s0 = peg$parseCycle();
@@ -12690,16 +12168,10 @@ function peg$parse(input, options) {
12690
12168
  }
12691
12169
  }
12692
12170
  }
12693
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
12694
12171
  return s0;
12695
12172
  }
12696
12173
  function peg$parseArrowDecoration() {
12697
12174
  var s0, s1;
12698
- var key = peg$currPos * 164 + 90, cached = peg$resultsCache[key];
12699
- if (cached) {
12700
- peg$currPos = cached.nextPos;
12701
- return cached.result;
12702
- }
12703
12175
  s0 = peg$currPos;
12704
12176
  s1 = peg$parseArrowAfter();
12705
12177
  if (s1 !== peg$FAILED) {
@@ -12734,16 +12206,10 @@ function peg$parse(input, options) {
12734
12206
  }
12735
12207
  }
12736
12208
  }
12737
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
12738
12209
  return s0;
12739
12210
  }
12740
12211
  function peg$parseArrowDecorations() {
12741
12212
  var s0, s1, s2, s3;
12742
- var key = peg$currPos * 164 + 91, cached = peg$resultsCache[key];
12743
- if (cached) {
12744
- peg$currPos = cached.nextPos;
12745
- return cached.result;
12746
- }
12747
12213
  s0 = [];
12748
12214
  s1 = peg$currPos;
12749
12215
  s2 = peg$parseArrowDecoration();
@@ -12790,16 +12256,10 @@ function peg$parse(input, options) {
12790
12256
  s1 = peg$FAILED;
12791
12257
  }
12792
12258
  }
12793
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
12794
12259
  return s0;
12795
12260
  }
12796
12261
  function peg$parseSubexp() {
12797
12262
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
12798
- var key = peg$currPos * 164 + 92, cached = peg$resultsCache[key];
12799
- if (cached) {
12800
- peg$currPos = cached.nextPos;
12801
- return cached.result;
12802
- }
12803
12263
  s0 = peg$currPos;
12804
12264
  s1 = peg$parseWS();
12805
12265
  if (s1 === peg$FAILED) {
@@ -12892,16 +12352,10 @@ function peg$parse(input, options) {
12892
12352
  peg$currPos = s0;
12893
12353
  s0 = peg$FAILED;
12894
12354
  }
12895
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
12896
12355
  return s0;
12897
12356
  }
12898
12357
  function peg$parseExp() {
12899
12358
  var s0, s1, s2, s3, s4, s5;
12900
- var key = peg$currPos * 164 + 93, cached = peg$resultsCache[key];
12901
- if (cached) {
12902
- peg$currPos = cached.nextPos;
12903
- return cached.result;
12904
- }
12905
12359
  s0 = peg$currPos;
12906
12360
  s1 = peg$parseArrowTarget();
12907
12361
  if (s1 !== peg$FAILED) {
@@ -12956,16 +12410,10 @@ function peg$parse(input, options) {
12956
12410
  peg$currPos = s0;
12957
12411
  s0 = peg$FAILED;
12958
12412
  }
12959
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
12960
12413
  return s0;
12961
12414
  }
12962
12415
  function peg$parseValidationKey() {
12963
12416
  var s0;
12964
- var key = peg$currPos * 164 + 94, cached = peg$resultsCache[key];
12965
- if (cached) {
12966
- peg$currPos = cached.nextPos;
12967
- return cached.result;
12968
- }
12969
12417
  if (input.substr(peg$currPos, 9) === peg$c1317) {
12970
12418
  s0 = peg$c1317;
12971
12419
  peg$currPos += 9;
@@ -12988,16 +12436,10 @@ function peg$parse(input, options) {
12988
12436
  }
12989
12437
  }
12990
12438
  }
12991
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
12992
12439
  return s0;
12993
12440
  }
12994
12441
  function peg$parseValidationItem() {
12995
12442
  var s0, s1, s2, s3, s4;
12996
- var key = peg$currPos * 164 + 95, cached = peg$resultsCache[key];
12997
- if (cached) {
12998
- peg$currPos = cached.nextPos;
12999
- return cached.result;
13000
- }
13001
12443
  s0 = peg$currPos;
13002
12444
  s1 = peg$parseValidationKey();
13003
12445
  if (s1 !== peg$FAILED) {
@@ -13048,16 +12490,10 @@ function peg$parse(input, options) {
13048
12490
  peg$currPos = s0;
13049
12491
  s0 = peg$FAILED;
13050
12492
  }
13051
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
13052
12493
  return s0;
13053
12494
  }
13054
12495
  function peg$parseValidationItems() {
13055
12496
  var s0, s1;
13056
- var key = peg$currPos * 164 + 96, cached = peg$resultsCache[key];
13057
- if (cached) {
13058
- peg$currPos = cached.nextPos;
13059
- return cached.result;
13060
- }
13061
12497
  s0 = [];
13062
12498
  s1 = peg$parseValidationItem();
13063
12499
  if (s1 !== peg$FAILED) {
@@ -13069,16 +12505,10 @@ function peg$parse(input, options) {
13069
12505
  else {
13070
12506
  s0 = peg$FAILED;
13071
12507
  }
13072
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
13073
12508
  return s0;
13074
12509
  }
13075
12510
  function peg$parseConfigValidation() {
13076
12511
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
13077
- var key = peg$currPos * 164 + 97, cached = peg$resultsCache[key];
13078
- if (cached) {
13079
- peg$currPos = cached.nextPos;
13080
- return cached.result;
13081
- }
13082
12512
  s0 = peg$currPos;
13083
12513
  s1 = peg$parseWS();
13084
12514
  if (s1 === peg$FAILED) {
@@ -13217,16 +12647,10 @@ function peg$parse(input, options) {
13217
12647
  peg$currPos = s0;
13218
12648
  s0 = peg$FAILED;
13219
12649
  }
13220
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
13221
12650
  return s0;
13222
12651
  }
13223
12652
  function peg$parseGvizLayout() {
13224
12653
  var s0;
13225
- var key = peg$currPos * 164 + 98, cached = peg$resultsCache[key];
13226
- if (cached) {
13227
- peg$currPos = cached.nextPos;
13228
- return cached.result;
13229
- }
13230
12654
  if (input.substr(peg$currPos, 3) === peg$c1327) {
13231
12655
  s0 = peg$c1327;
13232
12656
  peg$currPos += 3;
@@ -13285,16 +12709,10 @@ function peg$parse(input, options) {
13285
12709
  }
13286
12710
  }
13287
12711
  }
13288
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
13289
12712
  return s0;
13290
12713
  }
13291
12714
  function peg$parseStateItems() {
13292
12715
  var s0, s1;
13293
- var key = peg$currPos * 164 + 99, cached = peg$resultsCache[key];
13294
- if (cached) {
13295
- peg$currPos = cached.nextPos;
13296
- return cached.result;
13297
- }
13298
12716
  s0 = [];
13299
12717
  s1 = peg$parseStateDeclarationItem();
13300
12718
  if (s1 !== peg$FAILED) {
@@ -13306,16 +12724,10 @@ function peg$parse(input, options) {
13306
12724
  else {
13307
12725
  s0 = peg$FAILED;
13308
12726
  }
13309
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
13310
12727
  return s0;
13311
12728
  }
13312
12729
  function peg$parseConfigState() {
13313
12730
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
13314
- var key = peg$currPos * 164 + 100, cached = peg$resultsCache[key];
13315
- if (cached) {
13316
- peg$currPos = cached.nextPos;
13317
- return cached.result;
13318
- }
13319
12731
  s0 = peg$currPos;
13320
12732
  s1 = peg$parseWS();
13321
12733
  if (s1 === peg$FAILED) {
@@ -13454,16 +12866,10 @@ function peg$parse(input, options) {
13454
12866
  peg$currPos = s0;
13455
12867
  s0 = peg$FAILED;
13456
12868
  }
13457
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
13458
12869
  return s0;
13459
12870
  }
13460
12871
  function peg$parseConfigStartState() {
13461
12872
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
13462
- var key = peg$currPos * 164 + 101, cached = peg$resultsCache[key];
13463
- if (cached) {
13464
- peg$currPos = cached.nextPos;
13465
- return cached.result;
13466
- }
13467
12873
  s0 = peg$currPos;
13468
12874
  s1 = peg$parseWS();
13469
12875
  if (s1 === peg$FAILED) {
@@ -13602,16 +13008,10 @@ function peg$parse(input, options) {
13602
13008
  peg$currPos = s0;
13603
13009
  s0 = peg$FAILED;
13604
13010
  }
13605
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
13606
13011
  return s0;
13607
13012
  }
13608
13013
  function peg$parseConfigEndState() {
13609
13014
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
13610
- var key = peg$currPos * 164 + 102, cached = peg$resultsCache[key];
13611
- if (cached) {
13612
- peg$currPos = cached.nextPos;
13613
- return cached.result;
13614
- }
13615
13015
  s0 = peg$currPos;
13616
13016
  s1 = peg$parseWS();
13617
13017
  if (s1 === peg$FAILED) {
@@ -13750,16 +13150,10 @@ function peg$parse(input, options) {
13750
13150
  peg$currPos = s0;
13751
13151
  s0 = peg$FAILED;
13752
13152
  }
13753
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
13754
13153
  return s0;
13755
13154
  }
13756
13155
  function peg$parseConfigActiveState() {
13757
13156
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
13758
- var key = peg$currPos * 164 + 103, cached = peg$resultsCache[key];
13759
- if (cached) {
13760
- peg$currPos = cached.nextPos;
13761
- return cached.result;
13762
- }
13763
13157
  s0 = peg$currPos;
13764
13158
  s1 = peg$parseWS();
13765
13159
  if (s1 === peg$FAILED) {
@@ -13898,16 +13292,10 @@ function peg$parse(input, options) {
13898
13292
  peg$currPos = s0;
13899
13293
  s0 = peg$FAILED;
13900
13294
  }
13901
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
13902
13295
  return s0;
13903
13296
  }
13904
13297
  function peg$parseConfigTerminalState() {
13905
13298
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
13906
- var key = peg$currPos * 164 + 104, cached = peg$resultsCache[key];
13907
- if (cached) {
13908
- peg$currPos = cached.nextPos;
13909
- return cached.result;
13910
- }
13911
13299
  s0 = peg$currPos;
13912
13300
  s1 = peg$parseWS();
13913
13301
  if (s1 === peg$FAILED) {
@@ -14046,16 +13434,10 @@ function peg$parse(input, options) {
14046
13434
  peg$currPos = s0;
14047
13435
  s0 = peg$FAILED;
14048
13436
  }
14049
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
14050
13437
  return s0;
14051
13438
  }
14052
13439
  function peg$parseConfigHookedState() {
14053
13440
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
14054
- var key = peg$currPos * 164 + 105, cached = peg$resultsCache[key];
14055
- if (cached) {
14056
- peg$currPos = cached.nextPos;
14057
- return cached.result;
14058
- }
14059
13441
  s0 = peg$currPos;
14060
13442
  s1 = peg$parseWS();
14061
13443
  if (s1 === peg$FAILED) {
@@ -14194,16 +13576,10 @@ function peg$parse(input, options) {
14194
13576
  peg$currPos = s0;
14195
13577
  s0 = peg$FAILED;
14196
13578
  }
14197
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
14198
13579
  return s0;
14199
13580
  }
14200
13581
  function peg$parseConfigAnyState() {
14201
13582
  var s0;
14202
- var key = peg$currPos * 164 + 106, cached = peg$resultsCache[key];
14203
- if (cached) {
14204
- peg$currPos = cached.nextPos;
14205
- return cached.result;
14206
- }
14207
13583
  s0 = peg$parseConfigState();
14208
13584
  if (s0 === peg$FAILED) {
14209
13585
  s0 = peg$parseConfigStartState();
@@ -14220,16 +13596,10 @@ function peg$parse(input, options) {
14220
13596
  }
14221
13597
  }
14222
13598
  }
14223
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
14224
13599
  return s0;
14225
13600
  }
14226
13601
  function peg$parseActionKey() {
14227
13602
  var s0;
14228
- var key = peg$currPos * 164 + 107, cached = peg$resultsCache[key];
14229
- if (cached) {
14230
- peg$currPos = cached.nextPos;
14231
- return cached.result;
14232
- }
14233
13603
  if (input.substr(peg$currPos, 9) === peg$c1317) {
14234
13604
  s0 = peg$c1317;
14235
13605
  peg$currPos += 9;
@@ -14252,16 +13622,10 @@ function peg$parse(input, options) {
14252
13622
  }
14253
13623
  }
14254
13624
  }
14255
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
14256
13625
  return s0;
14257
13626
  }
14258
13627
  function peg$parseActionItem() {
14259
13628
  var s0, s1, s2, s3, s4;
14260
- var key = peg$currPos * 164 + 108, cached = peg$resultsCache[key];
14261
- if (cached) {
14262
- peg$currPos = cached.nextPos;
14263
- return cached.result;
14264
- }
14265
13629
  s0 = peg$currPos;
14266
13630
  s1 = peg$parseActionKey();
14267
13631
  if (s1 !== peg$FAILED) {
@@ -14312,16 +13676,10 @@ function peg$parse(input, options) {
14312
13676
  peg$currPos = s0;
14313
13677
  s0 = peg$FAILED;
14314
13678
  }
14315
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
14316
13679
  return s0;
14317
13680
  }
14318
13681
  function peg$parseActionItems() {
14319
13682
  var s0, s1;
14320
- var key = peg$currPos * 164 + 109, cached = peg$resultsCache[key];
14321
- if (cached) {
14322
- peg$currPos = cached.nextPos;
14323
- return cached.result;
14324
- }
14325
13683
  s0 = [];
14326
13684
  s1 = peg$parseActionItem();
14327
13685
  if (s1 !== peg$FAILED) {
@@ -14333,16 +13691,10 @@ function peg$parse(input, options) {
14333
13691
  else {
14334
13692
  s0 = peg$FAILED;
14335
13693
  }
14336
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
14337
13694
  return s0;
14338
13695
  }
14339
13696
  function peg$parseConfigAction() {
14340
13697
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
14341
- var key = peg$currPos * 164 + 110, cached = peg$resultsCache[key];
14342
- if (cached) {
14343
- peg$currPos = cached.nextPos;
14344
- return cached.result;
14345
- }
14346
13698
  s0 = peg$currPos;
14347
13699
  s1 = peg$parseWS();
14348
13700
  if (s1 === peg$FAILED) {
@@ -14481,16 +13833,10 @@ function peg$parse(input, options) {
14481
13833
  peg$currPos = s0;
14482
13834
  s0 = peg$FAILED;
14483
13835
  }
14484
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
14485
13836
  return s0;
14486
13837
  }
14487
13838
  function peg$parseTransitionKey() {
14488
13839
  var s0;
14489
- var key = peg$currPos * 164 + 111, cached = peg$resultsCache[key];
14490
- if (cached) {
14491
- peg$currPos = cached.nextPos;
14492
- return cached.result;
14493
- }
14494
13840
  if (input.substr(peg$currPos, 9) === peg$c1317) {
14495
13841
  s0 = peg$c1317;
14496
13842
  peg$currPos += 9;
@@ -14513,16 +13859,10 @@ function peg$parse(input, options) {
14513
13859
  }
14514
13860
  }
14515
13861
  }
14516
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
14517
13862
  return s0;
14518
13863
  }
14519
13864
  function peg$parseTransitionItem() {
14520
13865
  var s0, s1, s2, s3, s4;
14521
- var key = peg$currPos * 164 + 112, cached = peg$resultsCache[key];
14522
- if (cached) {
14523
- peg$currPos = cached.nextPos;
14524
- return cached.result;
14525
- }
14526
13866
  s0 = peg$currPos;
14527
13867
  s1 = peg$parseTransitionKey();
14528
13868
  if (s1 !== peg$FAILED) {
@@ -14573,16 +13913,10 @@ function peg$parse(input, options) {
14573
13913
  peg$currPos = s0;
14574
13914
  s0 = peg$FAILED;
14575
13915
  }
14576
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
14577
13916
  return s0;
14578
13917
  }
14579
13918
  function peg$parseTransitionItems() {
14580
13919
  var s0, s1;
14581
- var key = peg$currPos * 164 + 113, cached = peg$resultsCache[key];
14582
- if (cached) {
14583
- peg$currPos = cached.nextPos;
14584
- return cached.result;
14585
- }
14586
13920
  s0 = peg$parseGraphDefaultEdgeColor();
14587
13921
  if (s0 === peg$FAILED) {
14588
13922
  s0 = [];
@@ -14597,16 +13931,10 @@ function peg$parse(input, options) {
14597
13931
  s0 = peg$FAILED;
14598
13932
  }
14599
13933
  }
14600
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
14601
13934
  return s0;
14602
13935
  }
14603
13936
  function peg$parseGraphDefaultEdgeColor() {
14604
13937
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
14605
- var key = peg$currPos * 164 + 114, cached = peg$resultsCache[key];
14606
- if (cached) {
14607
- peg$currPos = cached.nextPos;
14608
- return cached.result;
14609
- }
14610
13938
  peg$silentFails++;
14611
13939
  s0 = peg$currPos;
14612
13940
  s1 = peg$parseWS();
@@ -14835,16 +14163,10 @@ function peg$parse(input, options) {
14835
14163
  peg$fail(peg$c1360);
14836
14164
  }
14837
14165
  }
14838
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
14839
14166
  return s0;
14840
14167
  }
14841
14168
  function peg$parseConfigTransition() {
14842
14169
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
14843
- var key = peg$currPos * 164 + 115, cached = peg$resultsCache[key];
14844
- if (cached) {
14845
- peg$currPos = cached.nextPos;
14846
- return cached.result;
14847
- }
14848
14170
  s0 = peg$currPos;
14849
14171
  s1 = peg$parseWS();
14850
14172
  if (s1 === peg$FAILED) {
@@ -14983,16 +14305,10 @@ function peg$parse(input, options) {
14983
14305
  peg$currPos = s0;
14984
14306
  s0 = peg$FAILED;
14985
14307
  }
14986
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
14987
14308
  return s0;
14988
14309
  }
14989
14310
  function peg$parseConfigGraphLayout() {
14990
14311
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
14991
- var key = peg$currPos * 164 + 116, cached = peg$resultsCache[key];
14992
- if (cached) {
14993
- peg$currPos = cached.nextPos;
14994
- return cached.result;
14995
- }
14996
14312
  s0 = peg$currPos;
14997
14313
  s1 = peg$parseWS();
14998
14314
  if (s1 === peg$FAILED) {
@@ -15102,16 +14418,10 @@ function peg$parse(input, options) {
15102
14418
  peg$currPos = s0;
15103
14419
  s0 = peg$FAILED;
15104
14420
  }
15105
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
15106
14421
  return s0;
15107
14422
  }
15108
14423
  function peg$parseConfigStartNodes() {
15109
14424
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
15110
- var key = peg$currPos * 164 + 117, cached = peg$resultsCache[key];
15111
- if (cached) {
15112
- peg$currPos = cached.nextPos;
15113
- return cached.result;
15114
- }
15115
14425
  s0 = peg$currPos;
15116
14426
  s1 = peg$parseWS();
15117
14427
  if (s1 === peg$FAILED) {
@@ -15221,16 +14531,10 @@ function peg$parse(input, options) {
15221
14531
  peg$currPos = s0;
15222
14532
  s0 = peg$FAILED;
15223
14533
  }
15224
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
15225
14534
  return s0;
15226
14535
  }
15227
14536
  function peg$parseConfigEndNodes() {
15228
14537
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
15229
- var key = peg$currPos * 164 + 118, cached = peg$resultsCache[key];
15230
- if (cached) {
15231
- peg$currPos = cached.nextPos;
15232
- return cached.result;
15233
- }
15234
14538
  s0 = peg$currPos;
15235
14539
  s1 = peg$parseWS();
15236
14540
  if (s1 === peg$FAILED) {
@@ -15340,16 +14644,10 @@ function peg$parse(input, options) {
15340
14644
  peg$currPos = s0;
15341
14645
  s0 = peg$FAILED;
15342
14646
  }
15343
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
15344
14647
  return s0;
15345
14648
  }
15346
14649
  function peg$parseConfigGraphBgColor() {
15347
14650
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
15348
- var key = peg$currPos * 164 + 119, cached = peg$resultsCache[key];
15349
- if (cached) {
15350
- peg$currPos = cached.nextPos;
15351
- return cached.result;
15352
- }
15353
14651
  s0 = peg$currPos;
15354
14652
  s1 = peg$parseWS();
15355
14653
  if (s1 === peg$FAILED) {
@@ -15459,16 +14757,10 @@ function peg$parse(input, options) {
15459
14757
  peg$currPos = s0;
15460
14758
  s0 = peg$FAILED;
15461
14759
  }
15462
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
15463
14760
  return s0;
15464
14761
  }
15465
14762
  function peg$parseConfigAllowsOverride() {
15466
14763
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
15467
- var key = peg$currPos * 164 + 120, cached = peg$resultsCache[key];
15468
- if (cached) {
15469
- peg$currPos = cached.nextPos;
15470
- return cached.result;
15471
- }
15472
14764
  s0 = peg$currPos;
15473
14765
  s1 = peg$parseWS();
15474
14766
  if (s1 === peg$FAILED) {
@@ -15578,16 +14870,10 @@ function peg$parse(input, options) {
15578
14870
  peg$currPos = s0;
15579
14871
  s0 = peg$FAILED;
15580
14872
  }
15581
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
15582
14873
  return s0;
15583
14874
  }
15584
14875
  function peg$parseOverrideT() {
15585
14876
  var s0, s1;
15586
- var key = peg$currPos * 164 + 121, cached = peg$resultsCache[key];
15587
- if (cached) {
15588
- peg$currPos = cached.nextPos;
15589
- return cached.result;
15590
- }
15591
14877
  s0 = peg$currPos;
15592
14878
  if (input.substr(peg$currPos, 4) === peg$c230) {
15593
14879
  s1 = peg$c230;
@@ -15640,16 +14926,10 @@ function peg$parse(input, options) {
15640
14926
  s0 = s1;
15641
14927
  }
15642
14928
  }
15643
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
15644
14929
  return s0;
15645
14930
  }
15646
14931
  function peg$parseConfig() {
15647
14932
  var s0;
15648
- var key = peg$currPos * 164 + 122, cached = peg$resultsCache[key];
15649
- if (cached) {
15650
- peg$currPos = cached.nextPos;
15651
- return cached.result;
15652
- }
15653
14933
  peg$silentFails++;
15654
14934
  s0 = peg$parseConfigGraphLayout();
15655
14935
  if (s0 === peg$FAILED) {
@@ -15682,16 +14962,10 @@ function peg$parse(input, options) {
15682
14962
  peg$fail(peg$c1382);
15683
14963
  }
15684
14964
  }
15685
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
15686
14965
  return s0;
15687
14966
  }
15688
14967
  function peg$parseLicenseOrLabelOrList() {
15689
14968
  var s0;
15690
- var key = peg$currPos * 164 + 123, cached = peg$resultsCache[key];
15691
- if (cached) {
15692
- peg$currPos = cached.nextPos;
15693
- return cached.result;
15694
- }
15695
14969
  if (input.substr(peg$currPos, 3) === peg$c1383) {
15696
14970
  s0 = peg$c1383;
15697
14971
  peg$currPos += 3;
@@ -15828,16 +15102,10 @@ function peg$parse(input, options) {
15828
15102
  }
15829
15103
  }
15830
15104
  }
15831
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
15832
15105
  return s0;
15833
15106
  }
15834
15107
  function peg$parseDirection() {
15835
15108
  var s0;
15836
- var key = peg$currPos * 164 + 124, cached = peg$resultsCache[key];
15837
- if (cached) {
15838
- peg$currPos = cached.nextPos;
15839
- return cached.result;
15840
- }
15841
15109
  peg$silentFails++;
15842
15110
  if (input.substr(peg$currPos, 2) === peg$c1406) {
15843
15111
  s0 = peg$c1406;
@@ -15891,16 +15159,10 @@ function peg$parse(input, options) {
15891
15159
  peg$fail(peg$c1405);
15892
15160
  }
15893
15161
  }
15894
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
15895
15162
  return s0;
15896
15163
  }
15897
15164
  function peg$parseHookDefinition() {
15898
15165
  var s0;
15899
- var key = peg$currPos * 164 + 125, cached = peg$resultsCache[key];
15900
- if (cached) {
15901
- peg$currPos = cached.nextPos;
15902
- return cached.result;
15903
- }
15904
15166
  peg$silentFails++;
15905
15167
  if (input.substr(peg$currPos, 4) === peg$c1415) {
15906
15168
  s0 = peg$c1415;
@@ -15930,16 +15192,10 @@ function peg$parse(input, options) {
15930
15192
  peg$fail(peg$c1414);
15931
15193
  }
15932
15194
  }
15933
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
15934
15195
  return s0;
15935
15196
  }
15936
15197
  function peg$parseMachineAuthor() {
15937
15198
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
15938
- var key = peg$currPos * 164 + 126, cached = peg$resultsCache[key];
15939
- if (cached) {
15940
- peg$currPos = cached.nextPos;
15941
- return cached.result;
15942
- }
15943
15199
  s0 = peg$currPos;
15944
15200
  s1 = peg$parseWS();
15945
15201
  if (s1 === peg$FAILED) {
@@ -16049,16 +15305,10 @@ function peg$parse(input, options) {
16049
15305
  peg$currPos = s0;
16050
15306
  s0 = peg$FAILED;
16051
15307
  }
16052
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
16053
15308
  return s0;
16054
15309
  }
16055
15310
  function peg$parseMachineContributor() {
16056
15311
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
16057
- var key = peg$currPos * 164 + 127, cached = peg$resultsCache[key];
16058
- if (cached) {
16059
- peg$currPos = cached.nextPos;
16060
- return cached.result;
16061
- }
16062
15312
  s0 = peg$currPos;
16063
15313
  s1 = peg$parseWS();
16064
15314
  if (s1 === peg$FAILED) {
@@ -16168,16 +15418,10 @@ function peg$parse(input, options) {
16168
15418
  peg$currPos = s0;
16169
15419
  s0 = peg$FAILED;
16170
15420
  }
16171
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
16172
15421
  return s0;
16173
15422
  }
16174
15423
  function peg$parseMachineComment() {
16175
15424
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
16176
- var key = peg$currPos * 164 + 128, cached = peg$resultsCache[key];
16177
- if (cached) {
16178
- peg$currPos = cached.nextPos;
16179
- return cached.result;
16180
- }
16181
15425
  s0 = peg$currPos;
16182
15426
  s1 = peg$parseWS();
16183
15427
  if (s1 === peg$FAILED) {
@@ -16287,16 +15531,10 @@ function peg$parse(input, options) {
16287
15531
  peg$currPos = s0;
16288
15532
  s0 = peg$FAILED;
16289
15533
  }
16290
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
16291
15534
  return s0;
16292
15535
  }
16293
15536
  function peg$parseMachineDefinition() {
16294
15537
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
16295
- var key = peg$currPos * 164 + 129, cached = peg$resultsCache[key];
16296
- if (cached) {
16297
- peg$currPos = cached.nextPos;
16298
- return cached.result;
16299
- }
16300
15538
  s0 = peg$currPos;
16301
15539
  s1 = peg$parseWS();
16302
15540
  if (s1 === peg$FAILED) {
@@ -16406,16 +15644,10 @@ function peg$parse(input, options) {
16406
15644
  peg$currPos = s0;
16407
15645
  s0 = peg$FAILED;
16408
15646
  }
16409
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
16410
15647
  return s0;
16411
15648
  }
16412
15649
  function peg$parseMachineName() {
16413
15650
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
16414
- var key = peg$currPos * 164 + 130, cached = peg$resultsCache[key];
16415
- if (cached) {
16416
- peg$currPos = cached.nextPos;
16417
- return cached.result;
16418
- }
16419
15651
  s0 = peg$currPos;
16420
15652
  s1 = peg$parseWS();
16421
15653
  if (s1 === peg$FAILED) {
@@ -16525,16 +15757,10 @@ function peg$parse(input, options) {
16525
15757
  peg$currPos = s0;
16526
15758
  s0 = peg$FAILED;
16527
15759
  }
16528
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
16529
15760
  return s0;
16530
15761
  }
16531
15762
  function peg$parseMachineReference() {
16532
15763
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
16533
- var key = peg$currPos * 164 + 131, cached = peg$resultsCache[key];
16534
- if (cached) {
16535
- peg$currPos = cached.nextPos;
16536
- return cached.result;
16537
- }
16538
15764
  s0 = peg$currPos;
16539
15765
  s1 = peg$parseWS();
16540
15766
  if (s1 === peg$FAILED) {
@@ -16644,16 +15870,10 @@ function peg$parse(input, options) {
16644
15870
  peg$currPos = s0;
16645
15871
  s0 = peg$FAILED;
16646
15872
  }
16647
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
16648
15873
  return s0;
16649
15874
  }
16650
15875
  function peg$parseMachineVersion() {
16651
15876
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
16652
- var key = peg$currPos * 164 + 132, cached = peg$resultsCache[key];
16653
- if (cached) {
16654
- peg$currPos = cached.nextPos;
16655
- return cached.result;
16656
- }
16657
15877
  s0 = peg$currPos;
16658
15878
  s1 = peg$parseWS();
16659
15879
  if (s1 === peg$FAILED) {
@@ -16763,16 +15983,10 @@ function peg$parse(input, options) {
16763
15983
  peg$currPos = s0;
16764
15984
  s0 = peg$FAILED;
16765
15985
  }
16766
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
16767
15986
  return s0;
16768
15987
  }
16769
15988
  function peg$parseMachineLicense() {
16770
15989
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
16771
- var key = peg$currPos * 164 + 133, cached = peg$resultsCache[key];
16772
- if (cached) {
16773
- peg$currPos = cached.nextPos;
16774
- return cached.result;
16775
- }
16776
15990
  s0 = peg$currPos;
16777
15991
  s1 = peg$parseWS();
16778
15992
  if (s1 === peg$FAILED) {
@@ -16882,16 +16096,10 @@ function peg$parse(input, options) {
16882
16096
  peg$currPos = s0;
16883
16097
  s0 = peg$FAILED;
16884
16098
  }
16885
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
16886
16099
  return s0;
16887
16100
  }
16888
16101
  function peg$parseMachineLanguage() {
16889
16102
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
16890
- var key = peg$currPos * 164 + 134, cached = peg$resultsCache[key];
16891
- if (cached) {
16892
- peg$currPos = cached.nextPos;
16893
- return cached.result;
16894
- }
16895
16103
  s0 = peg$currPos;
16896
16104
  s1 = peg$parseWS();
16897
16105
  if (s1 === peg$FAILED) {
@@ -17001,16 +16209,10 @@ function peg$parse(input, options) {
17001
16209
  peg$currPos = s0;
17002
16210
  s0 = peg$FAILED;
17003
16211
  }
17004
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
17005
16212
  return s0;
17006
16213
  }
17007
16214
  function peg$parseFslVersion() {
17008
16215
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
17009
- var key = peg$currPos * 164 + 135, cached = peg$resultsCache[key];
17010
- if (cached) {
17011
- peg$currPos = cached.nextPos;
17012
- return cached.result;
17013
- }
17014
16216
  s0 = peg$currPos;
17015
16217
  s1 = peg$parseWS();
17016
16218
  if (s1 === peg$FAILED) {
@@ -17120,16 +16322,10 @@ function peg$parse(input, options) {
17120
16322
  peg$currPos = s0;
17121
16323
  s0 = peg$FAILED;
17122
16324
  }
17123
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
17124
16325
  return s0;
17125
16326
  }
17126
16327
  function peg$parseMachineTheme() {
17127
16328
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
17128
- var key = peg$currPos * 164 + 136, cached = peg$resultsCache[key];
17129
- if (cached) {
17130
- peg$currPos = cached.nextPos;
17131
- return cached.result;
17132
- }
17133
16329
  s0 = peg$currPos;
17134
16330
  s1 = peg$parseWS();
17135
16331
  if (s1 === peg$FAILED) {
@@ -17239,16 +16435,10 @@ function peg$parse(input, options) {
17239
16435
  peg$currPos = s0;
17240
16436
  s0 = peg$FAILED;
17241
16437
  }
17242
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
17243
16438
  return s0;
17244
16439
  }
17245
16440
  function peg$parseMachineFlow() {
17246
16441
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
17247
- var key = peg$currPos * 164 + 137, cached = peg$resultsCache[key];
17248
- if (cached) {
17249
- peg$currPos = cached.nextPos;
17250
- return cached.result;
17251
- }
17252
16442
  s0 = peg$currPos;
17253
16443
  s1 = peg$parseWS();
17254
16444
  if (s1 === peg$FAILED) {
@@ -17358,16 +16548,10 @@ function peg$parse(input, options) {
17358
16548
  peg$currPos = s0;
17359
16549
  s0 = peg$FAILED;
17360
16550
  }
17361
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
17362
16551
  return s0;
17363
16552
  }
17364
16553
  function peg$parseMachineHookDefinition() {
17365
16554
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
17366
- var key = peg$currPos * 164 + 138, cached = peg$resultsCache[key];
17367
- if (cached) {
17368
- peg$currPos = cached.nextPos;
17369
- return cached.result;
17370
- }
17371
16555
  s0 = peg$currPos;
17372
16556
  s1 = peg$parseWS();
17373
16557
  if (s1 === peg$FAILED) {
@@ -17477,16 +16661,10 @@ function peg$parse(input, options) {
17477
16661
  peg$currPos = s0;
17478
16662
  s0 = peg$FAILED;
17479
16663
  }
17480
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
17481
16664
  return s0;
17482
16665
  }
17483
16666
  function peg$parseDotPreamble() {
17484
16667
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
17485
- var key = peg$currPos * 164 + 139, cached = peg$resultsCache[key];
17486
- if (cached) {
17487
- peg$currPos = cached.nextPos;
17488
- return cached.result;
17489
- }
17490
16668
  s0 = peg$currPos;
17491
16669
  s1 = peg$parseWS();
17492
16670
  if (s1 === peg$FAILED) {
@@ -17596,16 +16774,10 @@ function peg$parse(input, options) {
17596
16774
  peg$currPos = s0;
17597
16775
  s0 = peg$FAILED;
17598
16776
  }
17599
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
17600
16777
  return s0;
17601
16778
  }
17602
16779
  function peg$parseMachineAttribute() {
17603
16780
  var s0;
17604
- var key = peg$currPos * 164 + 140, cached = peg$resultsCache[key];
17605
- if (cached) {
17606
- peg$currPos = cached.nextPos;
17607
- return cached.result;
17608
- }
17609
16781
  peg$silentFails++;
17610
16782
  s0 = peg$parseFslVersion();
17611
16783
  if (s0 === peg$FAILED) {
@@ -17653,16 +16825,10 @@ function peg$parse(input, options) {
17653
16825
  peg$fail(peg$c1461);
17654
16826
  }
17655
16827
  }
17656
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
17657
16828
  return s0;
17658
16829
  }
17659
16830
  function peg$parsePropertyVal() {
17660
16831
  var s0;
17661
- var key = peg$currPos * 164 + 141, cached = peg$resultsCache[key];
17662
- if (cached) {
17663
- peg$currPos = cached.nextPos;
17664
- return cached.result;
17665
- }
17666
16832
  s0 = peg$parseString();
17667
16833
  if (s0 === peg$FAILED) {
17668
16834
  s0 = peg$parseBoolean();
@@ -17676,16 +16842,10 @@ function peg$parse(input, options) {
17676
16842
  }
17677
16843
  }
17678
16844
  }
17679
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
17680
16845
  return s0;
17681
16846
  }
17682
16847
  function peg$parseSdStateLabel() {
17683
16848
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
17684
- var key = peg$currPos * 164 + 142, cached = peg$resultsCache[key];
17685
- if (cached) {
17686
- peg$currPos = cached.nextPos;
17687
- return cached.result;
17688
- }
17689
16849
  peg$silentFails++;
17690
16850
  s0 = peg$currPos;
17691
16851
  s1 = peg$parseWS();
@@ -17803,16 +16963,10 @@ function peg$parse(input, options) {
17803
16963
  peg$fail(peg$c311);
17804
16964
  }
17805
16965
  }
17806
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
17807
16966
  return s0;
17808
16967
  }
17809
16968
  function peg$parseSdStateColor() {
17810
16969
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
17811
- var key = peg$currPos * 164 + 143, cached = peg$resultsCache[key];
17812
- if (cached) {
17813
- peg$currPos = cached.nextPos;
17814
- return cached.result;
17815
- }
17816
16970
  peg$silentFails++;
17817
16971
  s0 = peg$currPos;
17818
16972
  s1 = peg$parseWS();
@@ -17930,16 +17084,10 @@ function peg$parse(input, options) {
17930
17084
  peg$fail(peg$c1199);
17931
17085
  }
17932
17086
  }
17933
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
17934
17087
  return s0;
17935
17088
  }
17936
17089
  function peg$parseSdStateTextColor() {
17937
17090
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
17938
- var key = peg$currPos * 164 + 144, cached = peg$resultsCache[key];
17939
- if (cached) {
17940
- peg$currPos = cached.nextPos;
17941
- return cached.result;
17942
- }
17943
17091
  peg$silentFails++;
17944
17092
  s0 = peg$currPos;
17945
17093
  s1 = peg$parseWS();
@@ -18057,16 +17205,10 @@ function peg$parse(input, options) {
18057
17205
  peg$fail(peg$c1468);
18058
17206
  }
18059
17207
  }
18060
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
18061
17208
  return s0;
18062
17209
  }
18063
17210
  function peg$parseSdStateBackgroundColor() {
18064
17211
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
18065
- var key = peg$currPos * 164 + 145, cached = peg$resultsCache[key];
18066
- if (cached) {
18067
- peg$currPos = cached.nextPos;
18068
- return cached.result;
18069
- }
18070
17212
  peg$silentFails++;
18071
17213
  s0 = peg$currPos;
18072
17214
  s1 = peg$parseWS();
@@ -18184,16 +17326,10 @@ function peg$parse(input, options) {
18184
17326
  peg$fail(peg$c1472);
18185
17327
  }
18186
17328
  }
18187
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
18188
17329
  return s0;
18189
17330
  }
18190
17331
  function peg$parseSdStateBorderColor() {
18191
17332
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
18192
- var key = peg$currPos * 164 + 146, cached = peg$resultsCache[key];
18193
- if (cached) {
18194
- peg$currPos = cached.nextPos;
18195
- return cached.result;
18196
- }
18197
17333
  peg$silentFails++;
18198
17334
  s0 = peg$currPos;
18199
17335
  s1 = peg$parseWS();
@@ -18311,16 +17447,10 @@ function peg$parse(input, options) {
18311
17447
  peg$fail(peg$c1476);
18312
17448
  }
18313
17449
  }
18314
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
18315
17450
  return s0;
18316
17451
  }
18317
17452
  function peg$parseSdStateShape() {
18318
17453
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
18319
- var key = peg$currPos * 164 + 147, cached = peg$resultsCache[key];
18320
- if (cached) {
18321
- peg$currPos = cached.nextPos;
18322
- return cached.result;
18323
- }
18324
17454
  peg$silentFails++;
18325
17455
  s0 = peg$currPos;
18326
17456
  s1 = peg$parseWS();
@@ -18438,16 +17568,10 @@ function peg$parse(input, options) {
18438
17568
  peg$fail(peg$c1480);
18439
17569
  }
18440
17570
  }
18441
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
18442
17571
  return s0;
18443
17572
  }
18444
17573
  function peg$parseSdStateCorners() {
18445
17574
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
18446
- var key = peg$currPos * 164 + 148, cached = peg$resultsCache[key];
18447
- if (cached) {
18448
- peg$currPos = cached.nextPos;
18449
- return cached.result;
18450
- }
18451
17575
  peg$silentFails++;
18452
17576
  s0 = peg$currPos;
18453
17577
  s1 = peg$parseWS();
@@ -18565,16 +17689,10 @@ function peg$parse(input, options) {
18565
17689
  peg$fail(peg$c1484);
18566
17690
  }
18567
17691
  }
18568
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
18569
17692
  return s0;
18570
17693
  }
18571
17694
  function peg$parseSdStateLineStyle() {
18572
17695
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
18573
- var key = peg$currPos * 164 + 149, cached = peg$resultsCache[key];
18574
- if (cached) {
18575
- peg$currPos = cached.nextPos;
18576
- return cached.result;
18577
- }
18578
17696
  peg$silentFails++;
18579
17697
  s0 = peg$currPos;
18580
17698
  s1 = peg$parseWS();
@@ -18803,16 +17921,10 @@ function peg$parse(input, options) {
18803
17921
  peg$fail(peg$c1488);
18804
17922
  }
18805
17923
  }
18806
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
18807
17924
  return s0;
18808
17925
  }
18809
17926
  function peg$parseSdStateImage() {
18810
17927
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
18811
- var key = peg$currPos * 164 + 150, cached = peg$resultsCache[key];
18812
- if (cached) {
18813
- peg$currPos = cached.nextPos;
18814
- return cached.result;
18815
- }
18816
17928
  peg$silentFails++;
18817
17929
  s0 = peg$currPos;
18818
17930
  s1 = peg$parseWS();
@@ -18930,16 +18042,10 @@ function peg$parse(input, options) {
18930
18042
  peg$fail(peg$c1492);
18931
18043
  }
18932
18044
  }
18933
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
18934
18045
  return s0;
18935
18046
  }
18936
18047
  function peg$parseSdStateUrl() {
18937
18048
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
18938
- var key = peg$currPos * 164 + 151, cached = peg$resultsCache[key];
18939
- if (cached) {
18940
- peg$currPos = cached.nextPos;
18941
- return cached.result;
18942
- }
18943
18049
  peg$silentFails++;
18944
18050
  s0 = peg$currPos;
18945
18051
  s1 = peg$parseWS();
@@ -19057,16 +18163,10 @@ function peg$parse(input, options) {
19057
18163
  peg$fail(peg$c1496);
19058
18164
  }
19059
18165
  }
19060
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
19061
18166
  return s0;
19062
18167
  }
19063
18168
  function peg$parseSdStateProperty() {
19064
18169
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
19065
- var key = peg$currPos * 164 + 152, cached = peg$resultsCache[key];
19066
- if (cached) {
19067
- peg$currPos = cached.nextPos;
19068
- return cached.result;
19069
- }
19070
18170
  peg$silentFails++;
19071
18171
  s0 = peg$currPos;
19072
18172
  s1 = peg$parseWS();
@@ -19346,16 +18446,10 @@ function peg$parse(input, options) {
19346
18446
  peg$fail(peg$c1500);
19347
18447
  }
19348
18448
  }
19349
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
19350
18449
  return s0;
19351
18450
  }
19352
18451
  function peg$parseStateDeclarationItem() {
19353
18452
  var s0;
19354
- var key = peg$currPos * 164 + 153, cached = peg$resultsCache[key];
19355
- if (cached) {
19356
- peg$currPos = cached.nextPos;
19357
- return cached.result;
19358
- }
19359
18453
  s0 = peg$parseSdStateLabel();
19360
18454
  if (s0 === peg$FAILED) {
19361
18455
  s0 = peg$parseSdStateColor();
@@ -19387,16 +18481,10 @@ function peg$parse(input, options) {
19387
18481
  }
19388
18482
  }
19389
18483
  }
19390
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
19391
18484
  return s0;
19392
18485
  }
19393
18486
  function peg$parseStateDeclarationDesc() {
19394
18487
  var s0, s1, s2, s3, s4, s5;
19395
- var key = peg$currPos * 164 + 154, cached = peg$resultsCache[key];
19396
- if (cached) {
19397
- peg$currPos = cached.nextPos;
19398
- return cached.result;
19399
- }
19400
18488
  s0 = peg$currPos;
19401
18489
  if (input.charCodeAt(peg$currPos) === 123) {
19402
18490
  s1 = peg$c1221;
@@ -19465,16 +18553,10 @@ function peg$parse(input, options) {
19465
18553
  peg$currPos = s0;
19466
18554
  s0 = peg$FAILED;
19467
18555
  }
19468
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
19469
18556
  return s0;
19470
18557
  }
19471
18558
  function peg$parseStateDeclaration() {
19472
18559
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
19473
- var key = peg$currPos * 164 + 155, cached = peg$resultsCache[key];
19474
- if (cached) {
19475
- peg$currPos = cached.nextPos;
19476
- return cached.result;
19477
- }
19478
18560
  s0 = peg$currPos;
19479
18561
  s1 = peg$parseWS();
19480
18562
  if (s1 === peg$FAILED) {
@@ -19598,16 +18680,10 @@ function peg$parse(input, options) {
19598
18680
  peg$currPos = s0;
19599
18681
  s0 = peg$FAILED;
19600
18682
  }
19601
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
19602
18683
  return s0;
19603
18684
  }
19604
18685
  function peg$parseNamedList() {
19605
18686
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
19606
- var key = peg$currPos * 164 + 156, cached = peg$resultsCache[key];
19607
- if (cached) {
19608
- peg$currPos = cached.nextPos;
19609
- return cached.result;
19610
- }
19611
18687
  s0 = peg$currPos;
19612
18688
  s1 = peg$parseWS();
19613
18689
  if (s1 === peg$FAILED) {
@@ -19734,16 +18810,10 @@ function peg$parse(input, options) {
19734
18810
  peg$currPos = s0;
19735
18811
  s0 = peg$FAILED;
19736
18812
  }
19737
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
19738
18813
  return s0;
19739
18814
  }
19740
18815
  function peg$parseMachineProperty() {
19741
18816
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
19742
- var key = peg$currPos * 164 + 157, cached = peg$resultsCache[key];
19743
- if (cached) {
19744
- peg$currPos = cached.nextPos;
19745
- return cached.result;
19746
- }
19747
18817
  s0 = peg$currPos;
19748
18818
  s1 = peg$parseWS();
19749
18819
  if (s1 === peg$FAILED) {
@@ -20190,16 +19260,10 @@ function peg$parse(input, options) {
20190
19260
  }
20191
19261
  }
20192
19262
  }
20193
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
20194
19263
  return s0;
20195
19264
  }
20196
19265
  function peg$parseRegularArrangeDeclaration() {
20197
19266
  var s0, s1, s2, s3, s4, s5, s6;
20198
- var key = peg$currPos * 164 + 158, cached = peg$resultsCache[key];
20199
- if (cached) {
20200
- peg$currPos = cached.nextPos;
20201
- return cached.result;
20202
- }
20203
19267
  s0 = peg$currPos;
20204
19268
  if (input.substr(peg$currPos, 7) === peg$c1515) {
20205
19269
  s1 = peg$c1515;
@@ -20273,16 +19337,10 @@ function peg$parse(input, options) {
20273
19337
  peg$currPos = s0;
20274
19338
  s0 = peg$FAILED;
20275
19339
  }
20276
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
20277
19340
  return s0;
20278
19341
  }
20279
19342
  function peg$parseArrangeStartDeclaration() {
20280
19343
  var s0, s1, s2, s3, s4, s5, s6;
20281
- var key = peg$currPos * 164 + 159, cached = peg$resultsCache[key];
20282
- if (cached) {
20283
- peg$currPos = cached.nextPos;
20284
- return cached.result;
20285
- }
20286
19344
  s0 = peg$currPos;
20287
19345
  if (input.substr(peg$currPos, 13) === peg$c1518) {
20288
19346
  s1 = peg$c1518;
@@ -20356,16 +19414,10 @@ function peg$parse(input, options) {
20356
19414
  peg$currPos = s0;
20357
19415
  s0 = peg$FAILED;
20358
19416
  }
20359
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
20360
19417
  return s0;
20361
19418
  }
20362
19419
  function peg$parseArrangeEndDeclaration() {
20363
19420
  var s0, s1, s2, s3, s4, s5, s6;
20364
- var key = peg$currPos * 164 + 160, cached = peg$resultsCache[key];
20365
- if (cached) {
20366
- peg$currPos = cached.nextPos;
20367
- return cached.result;
20368
- }
20369
19421
  s0 = peg$currPos;
20370
19422
  if (input.substr(peg$currPos, 11) === peg$c1521) {
20371
19423
  s1 = peg$c1521;
@@ -20439,16 +19491,10 @@ function peg$parse(input, options) {
20439
19491
  peg$currPos = s0;
20440
19492
  s0 = peg$FAILED;
20441
19493
  }
20442
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
20443
19494
  return s0;
20444
19495
  }
20445
19496
  function peg$parseArrangeDeclaration() {
20446
19497
  var s0;
20447
- var key = peg$currPos * 164 + 161, cached = peg$resultsCache[key];
20448
- if (cached) {
20449
- peg$currPos = cached.nextPos;
20450
- return cached.result;
20451
- }
20452
19498
  peg$silentFails++;
20453
19499
  s0 = peg$parseArrangeStartDeclaration();
20454
19500
  if (s0 === peg$FAILED) {
@@ -20463,16 +19509,10 @@ function peg$parse(input, options) {
20463
19509
  peg$fail(peg$c1524);
20464
19510
  }
20465
19511
  }
20466
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
20467
19512
  return s0;
20468
19513
  }
20469
19514
  function peg$parseTerm() {
20470
19515
  var s0;
20471
- var key = peg$currPos * 164 + 162, cached = peg$resultsCache[key];
20472
- if (cached) {
20473
- peg$currPos = cached.nextPos;
20474
- return cached.result;
20475
- }
20476
19516
  s0 = peg$parseExp();
20477
19517
  if (s0 === peg$FAILED) {
20478
19518
  s0 = peg$parseStateDeclaration();
@@ -20492,23 +19532,16 @@ function peg$parse(input, options) {
20492
19532
  }
20493
19533
  }
20494
19534
  }
20495
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
20496
19535
  return s0;
20497
19536
  }
20498
19537
  function peg$parseTermList() {
20499
19538
  var s0, s1;
20500
- var key = peg$currPos * 164 + 163, cached = peg$resultsCache[key];
20501
- if (cached) {
20502
- peg$currPos = cached.nextPos;
20503
- return cached.result;
20504
- }
20505
19539
  s0 = [];
20506
19540
  s1 = peg$parseTerm();
20507
19541
  while (s1 !== peg$FAILED) {
20508
19542
  s0.push(s1);
20509
19543
  s1 = peg$parseTerm();
20510
19544
  }
20511
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
20512
19545
  return s0;
20513
19546
  }
20514
19547
  peg$result = peg$startRuleFunction();
@@ -22422,7 +21455,7 @@ var constants = /*#__PURE__*/Object.freeze({
22422
21455
  * Useful for runtime diagnostics and for embedding in serialized machine
22423
21456
  * snapshots so that deserializers can detect version-skew.
22424
21457
  */
22425
- const version = "5.141.9";
21458
+ const version = "5.141.11";
22426
21459
 
22427
21460
  // whargarbl lots of these return arrays could/should be sets
22428
21461
  const { state_name_chars, state_name_first_chars, action_label_chars } = constants;