diff --git a/.clocignore b/.clocignore index f4b36c83..a6b8a7fa 100644 --- a/.clocignore +++ b/.clocignore @@ -1 +1 @@ -./src/ts/jssm-dot.ts \ No newline at end of file +./src/ts/fsl_parser.ts \ No newline at end of file diff --git a/.github/ISSUE_TEMPLATE/bug-reporting-template.md b/.github/ISSUE_TEMPLATE/bug-reporting-template.md deleted file mode 100644 index 04de6292..00000000 --- a/.github/ISSUE_TEMPLATE/bug-reporting-template.md +++ /dev/null @@ -1,33 +0,0 @@ ---- -name: Bug reporting template -about: Report an issue or defect in the software (feature requests go elsewhere) - ---- - -This format should give a rough basis for how to report bugs in JSSM. Remove a section if it doesn't make sense. - -**Describe the bug** -Just a quick overview. Specifics below. - -**To Reproduce** -Steps to reproduce the behavior: -1. `...` -2. `...` -3. `...` - -**Expected behavior** -An explanation of what you expected to happen. - -**Screenshots** -If applicable, add screenshots to help explain your problem. - -**Environment** -1. What browser, or node? What version? What os? -1. Was this run through some transpiler like `babel` or `typescript`? -1. Any other stuff you want to bring up - -**Triggering code** -The FSL or JSON machine that triggered this, possibly as well as the triggering state - -**Additional context** -Add any other context about the problem here. diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml new file mode 100644 index 00000000..f2218bab --- /dev/null +++ b/.github/ISSUE_TEMPLATE/config.yml @@ -0,0 +1,14 @@ +blank_issues_enabled: false +contact_links: + - name: Unified issue tracker + url: https://github.com/StoneCypher/fsl/issues + about: Issues for all FSL and JSSM repositories go here + - name: Live community on Discord + url: https://discord.com/invite/9P95USqnMK + about: Come chat with us + - name: Live editor + url: https://stonecypher.github.io/jssm-viz-demo/graph_explorer.html + about: Try what you're doing live + - name: Documentation + url: https://stonecypher.github.io/jssm/docs/ + about: Read the friendly manual diff --git a/.github/ISSUE_TEMPLATE/example-machine-template.md b/.github/ISSUE_TEMPLATE/example-machine-template.md deleted file mode 100644 index 1b52d05c..00000000 --- a/.github/ISSUE_TEMPLATE/example-machine-template.md +++ /dev/null @@ -1,25 +0,0 @@ ---- -name: Example machine template -about: Replace this machine with your own. Write in FSL. - ---- - -machine_name : "Example traffic light"; -machine_author : "John Haugeland "; -machine_license : MIT; -machine_comment : "Just a quick example of how these are written"; -machine_language : en; -machine_version : 1.0.0; -fsl_version : 1.0.0; - -start_states : [Off Red]; - - - - - -Off 'Enable' -> Red; - -Red 'Proceed' => Green 'Proceed' => Yellow 'Proceed' => Red; - -[Red Yellow Green] ~> Off; diff --git a/.github/ISSUE_TEMPLATE/feature-requesting-template.md b/.github/ISSUE_TEMPLATE/feature-requesting-template.md deleted file mode 100644 index 589dca45..00000000 --- a/.github/ISSUE_TEMPLATE/feature-requesting-template.md +++ /dev/null @@ -1,15 +0,0 @@ ---- -name: Feature requesting template -about: Suggest an idea or request a feature (bug reports go elsewhere) - ---- - -**So what's the feature?** - -**Is this related to a problem? If so, what?** - -**Describe the solution you'd like** - -**Describe alternatives you've considered** - -**Additional context as you see fit** diff --git a/.github/workflows/nodejs.yml b/.github/workflows/nodejs.yml index ab70a062..a5d2f1f4 100644 --- a/.github/workflows/nodejs.yml +++ b/.github/workflows/nodejs.yml @@ -6,6 +6,96 @@ jobs: + unicode-atoms: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v2 + + - name: Use Node.js 18.x + uses: actions/setup-node@v1 + with: + node-version: 18.x + + - name: Check full unicode over atoms + run: | + npm install && npm run make && npm run jest-unicode-atom + + + + unicode-strings: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v2 + + - name: Use Node.js 18.x + uses: actions/setup-node@v1 + with: + node-version: 18.x + + - name: Check full unicode over strings + run: | + npm install && npm run make && npm run jest-unicode-string + + + + unicode-atom-labels: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v2 + + - name: Use Node.js 18.x + uses: actions/setup-node@v1 + with: + node-version: 18.x + + - name: Check full unicode over atom labels + run: | + npm install && npm run make && npm run jest-unicode-atom-label + + + + unicode-string-labels: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v2 + + - name: Use Node.js 18.x + uses: actions/setup-node@v1 + with: + node-version: 18.x + + - name: Check full unicode over string labels + run: | + npm install && npm run make && npm run jest-unicode-string-label + + + + unicode-actions: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v2 + + - name: Use Node.js 18.x + uses: actions/setup-node@v1 + with: + node-version: 18.x + + - name: Check full unicode over action statements + run: | + npm install && npm run make && npm run jest-unicode-action + + + build: strategy: @@ -32,7 +122,7 @@ jobs: - node-version: 17.x os: ubuntu-latest - runs-on: ${{matrix.os}} + runs-on: ${{ matrix.os }} steps: - uses: actions/checkout@v1 @@ -65,7 +155,7 @@ jobs: with: node-version: 18.x - - name: Verify the version was bumped + - name: Run the benchmarks run: | npm install && npm run benny @@ -96,7 +186,7 @@ jobs: if: (github.event.pusher.name == github.event.repository.owner.name) && (github.ref == 'refs/heads/main') - needs: [build, verify-version-bump] + needs: [build, verify-version-bump, unicode-strings, unicode-atoms, unicode-actions, unicode-atom-labels, unicode-string-labels] runs-on: ubuntu-latest @@ -107,6 +197,7 @@ jobs: run: | export TAG=$(awk -F'"' '/"version": ".+"/{ print $4; exit; }' package.json) echo "TAG=$TAG" >> $GITHUB_ENV + echo $TAG - name: Use Node.js 18.x uses: actions/setup-node@v1 @@ -132,6 +223,16 @@ jobs: env: NODE_AUTH_TOKEN: ${{ secrets.JSSM_PUBLISH_TOKEN_FOR_GH_CI_CD }} + - name: Tweet notice + run: | + npm install && node ./src/buildjs/tweet.js + env: + JSSM_TWITTER_ACCESS_TOKEN_SECRET: ${{ secrets.JSSM_TWITTER_ACCESS_TOKEN_SECRET }} + JSSM_TWITTER_API_ACCESS_TOKEN: ${{ secrets.JSSM_TWITTER_API_ACCESS_TOKEN }} + JSSM_TWITTER_API_KEY: ${{ secrets.JSSM_TWITTER_API_KEY }} + JSSM_TWITTER_API_SECRET: ${{ secrets.JSSM_TWITTER_API_SECRET }} + TW_COMMIT_MESSAGE: ${{ github.event.head_commit.message }} + bump-jssm-viz: @@ -160,5 +261,13 @@ jobs: runs-on: ubuntu-latest steps: + - uses: actions/checkout@v2 + - name: Results page - run: echo '### Results!\n\n* Published to NPM\n* Bumped `jssm-viz`\n* Bumped `jssm-viz-demo`' >> $GITHUB_STEP_SUMMARY + run: | + export TAG=$(awk -F'"' '/"version": ".+"/{ print $4; exit; }' package.json) + echo '### Results!' >> $GITHUB_STEP_SUMMARY + echo "* Published $TAG to NPM" >> $GITHUB_STEP_SUMMARY + echo '* Bumping `jssm-viz`' >> $GITHUB_STEP_SUMMARY + echo ' * which will bump `jssm-viz-cli`' >> $GITHUB_STEP_SUMMARY + echo ' * which will bump `jssm-viz-demo`' >> $GITHUB_STEP_SUMMARY diff --git a/CHANGELOG.long.md b/CHANGELOG.long.md index 4b158e26..83d7ebec 100644 --- a/CHANGELOG.long.md +++ b/CHANGELOG.long.md @@ -2,7 +2,7 @@ All notable changes to this project will be documented in this file. -961 merges; 129 releases +1076 merges; 178 releases @@ -12,7 +12,7 @@ All notable changes to this project will be documented in this file. Published tags: -5.76.2, 5.76.0, 5.75.1, 5.75.0, 5.74.0, 5.73.1, 5.73.0, 5.72.5, 5.72.4, 5.72.3, 5.72.2, 5.72.1, 5.72.0, 5.71.1, 5.71.0, 5.70.36, 5.70.35, 5.70.34, 5.70.33, 5.70.32, 5.70.31, 5.70.30, 5.70.29, 5.70.28, 5.70.27, 5.70.26, 5.70.25, 5.70.24, 5.70.23, 5.70.22, 5.70.21, 5.70.20, 5.70.19, 5.70.18, 5.70.16, 5.70.15, 5.70.14, 5.70.13, 5.70.12, 5.70.11, 5.70.10, 5.70.9, 5.70.8, 5.70.7, 5.70.6, 5.70.5, 5.70.4, 5.70.3, 5.70.2, 5.70.1, 5.70.0, 5.69.4, 5.69.3, 5.69.2, 5.69.0, 5.68.0, 5.67.2, 5.67.0, 5.66.0, 5.65.14, 5.65.12, 5.65.11, 5.65.10, 5.65.9, 5.65.8, 5.65.7, 5.65.5, 5.65.4, 5.65.3, 5.65.2, 5.65.1, 5.65.0, 5.64.2, 5.64.1, 5.64.0, 5.63.0, 5.62.0, 5.61.4, 5.61.3, 5.61.2, 5.61.1, 5.60.4, 5.60.3, 5.60.0, 5.59.1, 5.59.0, 5.58.1, 5.58.0, 5.57.1, 5.57.0, 5.56.2, 5.56.1, 5.55.0, 5.54.0, 5.53.0, 5.52.0, 5.51.0, 5.50.0, 5.49.0, 5.48.0, 5.47.0, 5.46.0, 5.45.2, 5.45.0, 5.44.0, 5.43.2, v5.42.0, 5.42.0, v5.41.15, 5.41.15, v5.41.14, 5.41.14, v5.41.12, 5.41.12, v5.41.10, 5.41.10, v5.41.9, 5.41.9, v5.41.8, 5.41.8, v5.41.7, v5.41.2, v5.41.1, v5.32.14, 5.14.0, 5.12.0, 5.11.12, 5.11.1, 5.11.0 +5.87.0, 5.86.3, 5.86.2, 5.86.1, 5.86.0, 5.85.11, 5.85.10, 5.85.9, 5.85.8, 5.85.7, 5.85.6, 5.85.5, 5.85.4, 5.85.3, 5.85.2, 5.85.1, 5.85.0, 5.84.1, 5.84.0, 5.83.2, 5.83.1, 5.83.0, 5.82.5, 5.82.4, 5.82.3, 5.82.2, 5.82.1, 5.82.0, 5.81.2, 5.81.0, 5.80.1, 5.80.0, 5.79.18, 5.79.17, 5.79.16, 5.79.15, 5.79.11, 5.79.10, 5.79.9, 5.79.8, 5.79.6, 5.79.4, 5.79.3, 5.79.2, 5.79.1, 5.79.0, 5.78.0, 5.77.1, 5.77.0, 5.76.2, 5.76.0, 5.75.1, 5.75.0, 5.74.0, 5.73.1, 5.73.0, 5.72.5, 5.72.4, 5.72.3, 5.72.2, 5.72.1, 5.72.0, 5.71.1, 5.71.0, 5.70.36, 5.70.35, 5.70.34, 5.70.33, 5.70.32, 5.70.31, 5.70.30, 5.70.29, 5.70.28, 5.70.27, 5.70.26, 5.70.25, 5.70.24, 5.70.23, 5.70.22, 5.70.21, 5.70.20, 5.70.19, 5.70.18, 5.70.16, 5.70.15, 5.70.14, 5.70.13, 5.70.12, 5.70.11, 5.70.10, 5.70.9, 5.70.8, 5.70.7, 5.70.6, 5.70.5, 5.70.4, 5.70.3, 5.70.2, 5.70.1, 5.70.0, 5.69.4, 5.69.3, 5.69.2, 5.69.0, 5.68.0, 5.67.2, 5.67.0, 5.66.0, 5.65.14, 5.65.12, 5.65.11, 5.65.10, 5.65.9, 5.65.8, 5.65.7, 5.65.5, 5.65.4, 5.65.3, 5.65.2, 5.65.1, 5.65.0, 5.64.2, 5.64.1, 5.64.0, 5.63.0, 5.62.0, 5.61.4, 5.61.3, 5.61.2, 5.61.1, 5.60.4, 5.60.3, 5.60.0, 5.59.1, 5.59.0, 5.58.1, 5.58.0, 5.57.1, 5.57.0, 5.56.2, 5.56.1, 5.55.0, 5.54.0, 5.53.0, 5.52.0, 5.51.0, 5.50.0, 5.49.0, 5.48.0, 5.47.0, 5.46.0, 5.45.2, 5.45.0, 5.44.0, 5.43.2, v5.42.0, 5.42.0, v5.41.15, 5.41.15, v5.41.14, 5.41.14, v5.41.12, 5.41.12, v5.41.10, 5.41.10, v5.41.9, 5.41.9, v5.41.8, 5.41.8, v5.41.7, v5.41.2, v5.41.1, v5.32.14, 5.14.0, 5.12.0, 5.11.12, 5.11.1, 5.11.0 @@ -22,18 +22,2246 @@ Published tags:   - + + +## [5.87.0] - 12/3/2022 8:18:35 PM + +Commit [85963d8c154225916ec9bf1f494c480ca033dec9](https://github.com/StoneCypher/jssm/commit/85963d8c154225916ec9bf1f494c480ca033dec9) + +Author: `John Haugeland ` + +Merges [dbb82ae, d6f77d1] + + * Merge pull request #549 from StoneCypher/next_data + * Next data + + + + +  + +  + +## [Untagged] - 12/3/2022 7:40:06 PM + +Commit [d6f77d1be4cf107f2eda1cfddca81d4ebcfc7c99](https://github.com/StoneCypher/jssm/commit/d6f77d1be4cf107f2eda1cfddca81d4ebcfc7c99) + +Author: `John Haugeland ` + + * forgot version bump + + + + +  + +  + +## [Untagged] - 12/3/2022 7:32:06 PM + +Commit [e6227e3d26828277c002ff0dd67899ab89771fc2](https://github.com/StoneCypher/jssm/commit/e6227e3d26828277c002ff0dd67899ab89771fc2) + +Author: `John Haugeland ` + + * next_data, fixes StoneCypher/fsl#1233 + + + + +  + +  + +## [Untagged] - 12/2/2022 10:48:55 PM + +Commit [5fa6e48645cb75fcd5fe38e6ff08c0d5d64a7a23](https://github.com/StoneCypher/jssm/commit/5fa6e48645cb75fcd5fe38e6ff08c0d5d64a7a23) + +Author: `John Haugeland ` + + * nextData underway + + + + +  + +  + + + +## [5.86.3] - 11/12/2022 6:09:16 PM + +Commit [dbb82aefc2744729fd17108d33d19f504dc1783e](https://github.com/StoneCypher/jssm/commit/dbb82aefc2744729fd17108d33d19f504dc1783e) + +Author: `John Haugeland ` + + * Implement override, implement in machine, allow override attribute + * Fixes StoneCypher/fsl#1228, fixes StoneCypher/fsl#1222, fixes StoneCypher/fsl#1232 + + + + +  + +  + + + +## [5.86.2] - 11/12/2022 12:49:23 PM + +Commit [a033eb38e784cbc5c6bf15bef576b69bb935f9b2](https://github.com/StoneCypher/jssm/commit/a033eb38e784cbc5c6bf15bef576b69bb935f9b2) + +Author: `John Haugeland ` + +Merges [48b4f92, 99a5fd6] + + * Merge pull request #548 from StoneCypher/AllowsOverrideInCompiler + * allows override in compiler, constructor config to allow/disallow override, getters for override, cfg override, machine override + + + + +  + +  + +## [Untagged] - 11/12/2022 12:44:20 PM + +Commit [99a5fd66ee5a342814cf34d89fb6dccc2f4ac7e9](https://github.com/StoneCypher/jssm/commit/99a5fd66ee5a342814cf34d89fb6dccc2f4ac7e9) + +Author: `John Haugeland ` + + * allows override in compiler, constructor config to allow/disallow override, getters for override, cfg override, machine override + * fixes StoneCypher/fsl#1225, fixes StoneCypher/fsl#1227, fixes StoneCypher/fsl#1229, fixes StoneCypher/fsl#1230, fixes StoneCypher/fsl#1231 + + + + +  + +  + + + +## [5.86.1] - 11/11/2022 6:41:15 PM + +Commit [48b4f928eb1a4597122b64e6eea38a57c19a112f](https://github.com/StoneCypher/jssm/commit/48b4f928eb1a4597122b64e6eea38a57c19a112f) + +Author: `John Haugeland ` + + * Allow override attribute in grammar, fixes StoneCypher/fsl#1226 + + + + +  + +  + + + +## [5.86.0] - 11/11/2022 6:22:48 PM + +Commit [31077c9256ee31f80398460b3af95bc65a8dbc3a](https://github.com/StoneCypher/jssm/commit/31077c9256ee31f80398460b3af95bc65a8dbc3a) + +Author: `John Haugeland ` + +Merges [793f2fc, 3941c30] + + * Merge pull request #547 from StoneCypher/allows_override + * .allows_override fixes StoneCypher/fsl#1224 + + + + +  + +  + +## [Untagged] - 11/11/2022 6:16:32 PM + +Commit [3941c3000e8544e6b674b4a060abb93a8f5c3455](https://github.com/StoneCypher/jssm/commit/3941c3000e8544e6b674b4a060abb93a8f5c3455) + +Author: `John Haugeland ` + + * .allows_override fixes StoneCypher/fsl#1224 + + + + +  + +  + + + +## [5.85.11] - 9/16/2022 11:15:38 PM + +Commit [793f2fcba840f39cb7442f6be54b0c272caad6ba](https://github.com/StoneCypher/jssm/commit/793f2fcba840f39cb7442f6be54b0c272caad6ba) + +Author: `John Haugeland ` + +Merges [ab43e02, 03790c9] + + * Merge pull request #546 from StoneCypher/uses_forced_transitions + * Adds getter method uses_forced_transitions + + + + +  + +  + +## [Untagged] - 9/16/2022 11:15:13 PM + +Commit [03790c9fc38db0ed5cb0ba35d50c4d5d820aafcc](https://github.com/StoneCypher/jssm/commit/03790c9fc38db0ed5cb0ba35d50c4d5d820aafcc) + +Author: `John Haugeland ` + + * Adds getter method uses_forced_transitions + * Fixes StoneCypher/fsl#1211 + + + + +  + +  + + + +## [5.85.10] - 9/16/2022 5:34:40 PM + +Commit [ab43e02152256d19579efdb73c9fa6cb04d1b2b3](https://github.com/StoneCypher/jssm/commit/ab43e02152256d19579efdb73c9fa6cb04d1b2b3) + +Author: `John Haugeland ` + +Merges [c0c574b, a6026d0] + + * Merge pull request #545 from StoneCypher/PullThemesOutIntoModule + * Pull themes out into module + + + + +  + +  + +## [Untagged] - 9/16/2022 5:30:09 PM + +Commit [a6026d0bdbec44c03303950130ed34df3a78576e](https://github.com/StoneCypher/jssm/commit/a6026d0bdbec44c03303950130ed34df3a78576e) + +Author: `John Haugeland ` + + * Pull themes out into module + * Fixes StoneCypher/fsl#1210 + + + + +  + +  + + + +## [5.85.9] - 9/12/2022 9:15:59 PM + +Commit [c0c574b694f1d0511190be139135cdf745f476b7](https://github.com/StoneCypher/jssm/commit/c0c574b694f1d0511190be139135cdf745f476b7) + +Author: `John Haugeland ` + +Merges [c047caa, 090db83] + + * Merge pull request #544 from StoneCypher/PullCompilerOutIntoModule + * Pull compiler out into a module + + + + +  + +  + +## [Untagged] - 9/12/2022 9:06:27 PM + +Commit [090db831d8df370b0937d2d37e6372b6df030481](https://github.com/StoneCypher/jssm/commit/090db831d8df370b0937d2d37e6372b6df030481) + +Author: `John Haugeland ` + + * Pull compiler out into a module + * Fixes StoneCypher/fsl#1207 + + + + +  + +  + + + +## [5.85.8] - 9/12/2022 8:26:10 PM + +Commit [c047caac3f9d9bb24a9c0b517983088eb8ee2e4a](https://github.com/StoneCypher/jssm/commit/c047caac3f9d9bb24a9c0b517983088eb8ee2e4a) + +Author: `John Haugeland ` + +Merges [581fd8d, 013999a] + + * Merge pull request #543 from StoneCypher/PullArrowsOutIntoModules + * Pull arrows out into modules + + + + +  + +  + +## [Untagged] - 9/12/2022 8:18:05 PM + +Commit [013999a77ce43ceed5eb982754ffe480fdddf159](https://github.com/StoneCypher/jssm/commit/013999a77ce43ceed5eb982754ffe480fdddf159) + +Author: `John Haugeland ` + + * Pull arrows out into modules + * Fixes StoneCypher/fsl#1206 + + + + +  + +  + + + +## [5.85.7] - 9/12/2022 7:24:25 PM + +Commit [581fd8dc33c4eb2ce190b696d952471abec192ef](https://github.com/StoneCypher/jssm/commit/581fd8dc33c4eb2ce190b696d952471abec192ef) + +Author: `John Haugeland ` + +Merges [7d741ba, 771f4c8] + + * Merge pull request #542 from StoneCypher/AddUnicodeTestsForLabels + * Add unicode tests for labels + + + + +  + +  + +## [Untagged] - 9/12/2022 7:19:21 PM + +Commit [771f4c8d67274b40451ae6dfef168fe3c15949df](https://github.com/StoneCypher/jssm/commit/771f4c8d67274b40451ae6dfef168fe3c15949df) + +Author: `John Haugeland ` + + * Add tests for unicode labels (atom and string) + * Fixes StoneCypher/fsl#1193, fixes StoneCypher/fsl#1194 + + + + +  + +  + +## [Untagged] - 9/12/2022 6:52:26 PM + +Commit [3eb246ddb992372ceca4c0adc9dc45295a0a7177](https://github.com/StoneCypher/jssm/commit/3eb246ddb992372ceca4c0adc9dc45295a0a7177) + +Author: `John Haugeland ` + + * Return twitter envvar to GHA yaml + + + + +  + +  + +## [Untagged] - 9/12/2022 6:52:26 PM + +Commit [3a01b8d7ae2cee185e4f36c90a95338bf30002cb](https://github.com/StoneCypher/jssm/commit/3a01b8d7ae2cee185e4f36c90a95338bf30002cb) + +Author: `John Haugeland ` + + * that wasn't supposed to be removed... + + + + +  + +  + + + +## [5.85.6] - 9/12/2022 6:43:57 PM + +Commit [7d741ba17ccee77138537f732b833efa028dbda7](https://github.com/StoneCypher/jssm/commit/7d741ba17ccee77138537f732b833efa028dbda7) + +Author: `John Haugeland ` + +Merges [4b9fefd, 37c0bdf] + + * Merge pull request #541 from StoneCypher/StartStateRefining + * Prevent request of illegal state as start state + + + + +  + +  + +## [Untagged] - 9/12/2022 6:39:19 PM + +Commit [37c0bdf33263bf4b9dd60ba329108297cf5ea68f](https://github.com/StoneCypher/jssm/commit/37c0bdf33263bf4b9dd60ba329108297cf5ea68f) + +Author: `John Haugeland ` + + * Prevent request of illegal state as start state + * Fixes StoneCypher/fsl#1203, fixes StoneCypher/fsl#1204, fixes StoneCypher/fsl#1205 + + + + +  + +  + +## [Untagged] - 9/12/2022 3:27:58 PM + +Commit [4b9fefde004f1c1ac5f36ad760105109475af95a](https://github.com/StoneCypher/jssm/commit/4b9fefde004f1c1ac5f36ad760105109475af95a) + +Author: `John Haugeland ` + + * expose build date directly on module (also -viz and -demo,) support logging in -demo + + + + +  + +  + + + +## [5.85.5] - 9/12/2022 3:10:10 PM + +Commit [35ad7228d5bb15d963a2e4d9e6e35721cce36b33](https://github.com/StoneCypher/jssm/commit/35ad7228d5bb15d963a2e4d9e6e35721cce36b33) + +Author: `John Haugeland ` + + * Add build time to module + + + + +  + +  + + + +## [5.85.4] - 9/12/2022 1:55:57 PM + +Commit [293e2cb9c07734fef562b455d786b7c63ea7647b](https://github.com/StoneCypher/jssm/commit/293e2cb9c07734fef562b455d786b7c63ea7647b) + +Author: `John Haugeland ` + + * Clean up the gh action a skosh + + + + +  + +  + + + +## [5.85.3] - 9/12/2022 11:25:36 AM + +Commit [87ec233d3511d30358660ad161f932e13eb1738e](https://github.com/StoneCypher/jssm/commit/87ec233d3511d30358660ad161f932e13eb1738e) + +Author: `John Haugeland ` + +Merges [98b7b14, 6475296] + + * Merge pull request #540 from StoneCypher/ReintroduceDisplayText + * Reintroduce display text, lost in a bad merge + + + + +  + +  + +## [Untagged] - 9/12/2022 11:24:38 AM + +Commit [6475296d979dab3d227828b80319d60c4f6ab2f5](https://github.com/StoneCypher/jssm/commit/6475296d979dab3d227828b80319d60c4f6ab2f5) + +Author: `John Haugeland ` + + * Reintroduce display text, lost in a bad merge + + + + +  + +  + + + +## [5.85.2] - 9/12/2022 10:03:27 AM + +Commit [98b7b14217ea7e83550e4ed15b6b6be80799e246](https://github.com/StoneCypher/jssm/commit/98b7b14217ea7e83550e4ed15b6b6be80799e246) + +Author: `John Haugeland ` + +Merges [461a287, 0f3025a] + + * Merge pull request #539 from StoneCypher/TrimTweet + * Shorten the tweet notice + + + + +  + +  + +## [Untagged] - 9/12/2022 9:59:52 AM + +Commit [0f3025ae2e484afbda57b5f39f5485c4831e7ce7](https://github.com/StoneCypher/jssm/commit/0f3025ae2e484afbda57b5f39f5485c4831e7ce7) + +Author: `John Haugeland ` + + * Shorten the tweet notice + + + + +  + +  + + + +## [5.85.1] - 9/12/2022 9:49:05 AM + +Commit [461a2874583d08da6db68e40b75047682625c73d](https://github.com/StoneCypher/jssm/commit/461a2874583d08da6db68e40b75047682625c73d) + +Author: `John Haugeland ` + +Merges [2eec2c8, 76d6729] + + * Merge pull request #538 from StoneCypher/RemoveYmlEcho + * Remove noisy echo in the YML + + + + +  + +  + +## [Untagged] - 9/12/2022 9:35:11 AM + +Commit [76d6729a35a3f4eba666ff2d78cd284ed0668edd](https://github.com/StoneCypher/jssm/commit/76d6729a35a3f4eba666ff2d78cd284ed0668edd) + +Author: `John Haugeland ` + + * Remove noisy echo in the YML + + + + +  + +  + + + +## [5.85.0] - 9/12/2022 9:22:37 AM + +Commit [2eec2c8b69d3e59cb06d7b0efc34b336e9ecc29a](https://github.com/StoneCypher/jssm/commit/2eec2c8b69d3e59cb06d7b0efc34b336e9ecc29a) + +Author: `John Haugeland ` + +Merges [a7b92f9, a0b9fb5] + + * Merge pull request #537 from StoneCypher/DisplayText + * simple display text function to resolve labels and node names + + + + +  + +  + +## [Untagged] - 9/12/2022 9:17:28 AM + +Commit [a0b9fb59c5dc92c94738a6d456ef5e5514a48d1f](https://github.com/StoneCypher/jssm/commit/a0b9fb59c5dc92c94738a6d456ef5e5514a48d1f) + +Author: `John Haugeland ` + + * simple display text function to resolve labels and node names + * fixes StoneCypher/fsl#1202 + + + + +  + +  + + + +## [5.84.1] - 9/12/2022 8:30:09 AM + +Commit [a7b92f9b1e94dcab843ab588d83d0c5f8eb9ca18](https://github.com/StoneCypher/jssm/commit/a7b92f9b1e94dcab843ab588d83d0c5f8eb9ca18) + +Author: `John Haugeland ` + +Merges [d4e6196, eedb4a7] + + * Merge pull request #536 from StoneCypher/MoreStabsAtTweeting + * Working on auto-tweeter; no associated issue + + + + +  + +  + +## [Untagged] - 9/12/2022 8:26:02 AM + +Commit [eedb4a7d6ea5392a252cf6dbe5bc2e6e3239591c](https://github.com/StoneCypher/jssm/commit/eedb4a7d6ea5392a252cf6dbe5bc2e6e3239591c) + +Author: `John Haugeland ` + + * Working on auto-tweeter; no associated issue + + + + +  + +  + + + +## [5.84.0] - 9/12/2022 7:41:49 AM + +Commit [d4e619611a04f24b76ad783a9b0f34393e45840a](https://github.com/StoneCypher/jssm/commit/d4e619611a04f24b76ad783a9b0f34393e45840a) + +Author: `John Haugeland ` + +Merges [cdaa32e, 9193c2d] + + * Merge pull request #535 from StoneCypher/RenameParserAlready + * Change parser name to fsl_parser, fixes StoneCypher/fsl#1201; another stab at Twitter + + + + +  + +  + +## [Untagged] - 9/12/2022 7:35:32 AM + +Commit [9193c2d1f27f1c80ed4a3bfb41e586f5da24179a](https://github.com/StoneCypher/jssm/commit/9193c2d1f27f1c80ed4a3bfb41e586f5da24179a) + +Author: `John Haugeland ` + + * Change parser name to fsl_parser, fixes StoneCypher/fsl#1201; another stab at Twitter + + + + +  + +  + + + +## [5.83.2] - 9/11/2022 3:39:14 PM + +Commit [cdaa32e418ddf2f094fe5ab2adbc1a0a0b65a2d7](https://github.com/StoneCypher/jssm/commit/cdaa32e418ddf2f094fe5ab2adbc1a0a0b65a2d7) + +Author: `John Haugeland ` + + * reduce-to-639-1 needs to be a dependency for downstream builds + + + + +  + +  + + + +## [5.83.1] - 9/11/2022 2:24:06 PM + +Commit [c46d677560dc06baf33c2088205051fedaf5be04](https://github.com/StoneCypher/jssm/commit/c46d677560dc06baf33c2088205051fedaf5be04) + +Author: `John Haugeland ` + +Merges [3256f05, 991d2dc] + + * Merge pull request #534 from StoneCypher/BoldTheme + * Add a bold theme + + + + +  + +  + +## [Untagged] - 9/11/2022 2:19:28 PM + +Commit [991d2dcf113bd19026f037e6eb22f46eacde57aa](https://github.com/StoneCypher/jssm/commit/991d2dcf113bd19026f037e6eb22f46eacde57aa) + +Author: `John Haugeland ` + + * Add a bold theme + + + + +  + +  + + + +## [5.83.0] - 9/3/2022 5:34:01 PM + +Commit [3256f05a4f2b5c5d6e05c2eeba091899e73ef327](https://github.com/StoneCypher/jssm/commit/3256f05a4f2b5c5d6e05c2eeba091899e73ef327) + +Author: `John Haugeland ` + +Merges [51ebcfc, 216dc9c] + + * Merge pull request #533 from StoneCypher/AttemptToFixAstral + * Attempt to fix astral + + + + +  + +  + +## [Untagged] - 9/3/2022 5:30:23 PM + +Commit [216dc9cb659d634a6be9510264f48c26e8a471c0](https://github.com/StoneCypher/jssm/commit/216dc9cb659d634a6be9510264f48c26e8a471c0) + +Author: `John Haugeland ` + + * Need to make before the unicode tests + + + + +  + +  + +## [Untagged] - 9/3/2022 5:27:18 PM + +Commit [7878070213ea189def19419eefa4a37ceff701c1](https://github.com/StoneCypher/jssm/commit/7878070213ea189def19419eefa4a37ceff701c1) + +Author: `John Haugeland ` + + * Get the script names right in the yaml + + + + +  + +  + +## [Untagged] - 9/3/2022 5:25:50 PM + +Commit [ead26fe40eeb115a87de151b6d91fc83e9aab2b9](https://github.com/StoneCypher/jssm/commit/ead26fe40eeb115a87de151b6d91fc83e9aab2b9) + +Author: `John Haugeland ` + + * Needed a version bump + + + + +  + +  + +## [Untagged] - 9/3/2022 5:21:12 PM + +Commit [4deaa1ebabb4bbc3604103a3bcdde77259247fe7](https://github.com/StoneCypher/jssm/commit/4deaa1ebabb4bbc3604103a3bcdde77259247fe7) + +Author: `John Haugeland ` + + * Unicode range tests for actions, very slow, fixes StoneCypher/fsl#1192 + + + + +  + +  + +## [Untagged] - 9/3/2022 5:16:16 PM + +Commit [72c4ac7e754ab32fe3ca2372fff1733ba8363b27](https://github.com/StoneCypher/jssm/commit/72c4ac7e754ab32fe3ca2372fff1733ba8363b27) + +Author: `John Haugeland ` + + * Unicode range tests for atoms and strings, very slow, fixes StoneCypher/fsl#1190, fixes StoneCypher/fsl#1191 + + + + +  + +  + +## [Untagged] - 9/3/2022 3:23:46 PM + +Commit [54adb9e46e56254596ca0a710492d3ecf633ea85](https://github.com/StoneCypher/jssm/commit/54adb9e46e56254596ca0a710492d3ecf633ea85) + +Author: `John Haugeland ` + + * on the way to unicode testing + + + + +  + +  + +## [Untagged] - 9/1/2022 7:14:42 PM + +Commit [51ebcfc1ec163b8590d1a1a2065dcd8ad0458cc9](https://github.com/StoneCypher/jssm/commit/51ebcfc1ec163b8590d1a1a2065dcd8ad0458cc9) + +Author: `John Haugeland ` + +Merges [94c4f37, 3557437] + + * Merge pull request #530 from machinshin/feature/new-readme + * more-readable README + + + + +  + +  + +## [Untagged] - 9/1/2022 7:13:51 PM + +Commit [35574377c523d8f48198b30ef77b12a5efe72b6c](https://github.com/StoneCypher/jssm/commit/35574377c523d8f48198b30ef77b12a5efe72b6c) + +Author: `Vat Raghavan ` + + * remake package-lock & upversion + + + + +  + +  + +## [Untagged] - 9/1/2022 7:05:32 PM + +Commit [c7bb4b01d3b5475d9ccb91ff7999556ef39e8805](https://github.com/StoneCypher/jssm/commit/c7bb4b01d3b5475d9ccb91ff7999556ef39e8805) + +Author: `Vat Raghavan ` + + * re-build + + + + +  + +  + +## [Untagged] - 9/1/2022 6:59:27 PM + +Commit [d916b2fe3b67c66ad6c47eef1df6dcfd9863d247](https://github.com/StoneCypher/jssm/commit/d916b2fe3b67c66ad6c47eef1df6dcfd9863d247) + +Author: `Vat Raghavan ` + + * update version number + + + + +  + +  + +## [Untagged] - 9/1/2022 6:56:09 PM + +Commit [50b5d8b1a4efce1c7359f713a02cb0477abd7d4a](https://github.com/StoneCypher/jssm/commit/50b5d8b1a4efce1c7359f713a02cb0477abd7d4a) + +Author: `Vat Raghavan ` + +Merges [9e18022, 94c4f37] + + * Merge branch 'main' into feature/new-readme + + + + +  + +  + + + +## [5.82.5] - 9/1/2022 6:44:36 PM + +Commit [94c4f37805eea9179474c66011155368e6c4ed31](https://github.com/StoneCypher/jssm/commit/94c4f37805eea9179474c66011155368e6c4ed31) + +Author: `John Haugeland ` + +Merges [a307163, cf1cb12] + + * Merge pull request #532 from machinshin/feature/shootout/all-inline + * all example links are inline-d + + + + +  + +  + +## [Untagged] - 9/1/2022 6:41:25 PM + +Commit [cf1cb122a9f86e943258ce58ffe490e27d401319](https://github.com/StoneCypher/jssm/commit/cf1cb122a9f86e943258ce58ffe490e27d401319) + +Author: `Vat Raghavan ` + +Merges [1f69c53, a307163] + + * Merge branch 'main' into feature/shootout/all-inline + + + + +  + +  + +## [Untagged] - 9/1/2022 6:08:10 PM + +Commit [1f69c53f4d3851f205896c446c65e9ecdbf26bbc](https://github.com/StoneCypher/jssm/commit/1f69c53f4d3851f205896c446c65e9ecdbf26bbc) + +Author: `Vat Raghavan ` + + * all example links are inline-d + + + + +  + +  + + + +## [5.82.4] - 9/1/2022 6:04:35 PM + +Commit [a307163e979abf8af53e4936f972c017f91198ba](https://github.com/StoneCypher/jssm/commit/a307163e979abf8af53e4936f972c017f91198ba) + +Author: `John Haugeland ` + + * add spurious single type return to theme getter to agree with the setter type, fixes StoneCypher/fsl#1189 + + + + +  + +  + + + +## [5.82.3] - 9/1/2022 5:26:59 PM + +Commit [58751e614c6f3f9223239af91f44079ee3a1f045](https://github.com/StoneCypher/jssm/commit/58751e614c6f3f9223239af91f44079ee3a1f045) + +Author: `John Haugeland ` + +Merges [da69e65, a824b2f] + + * Merge pull request #531 from machinshin/feature/shootout-inline-links + * relative link to code in Shootout.md + + + + +  + +  + +## [Untagged] - 9/1/2022 5:06:20 PM + +Commit [a824b2fea98113f5c1ff04227ff4261a41e8634e](https://github.com/StoneCypher/jssm/commit/a824b2fea98113f5c1ff04227ff4261a41e8634e) + +Author: `Vat Raghavan ` + + * all toggle examples are inline-linked + + + + +  + +  + +## [Untagged] - 9/1/2022 4:53:34 PM + +Commit [07e19355674ecf8c44ceb54f31cafebefdf08921](https://github.com/StoneCypher/jssm/commit/07e19355674ecf8c44ceb54f31cafebefdf08921) + +Author: `Vat Raghavan ` + + * relative link to code in Shootout.md + + + + +  + +  + + + +## [5.82.2] - 9/1/2022 4:17:04 PM + +Commit [da69e65ee5a1567825b011d3e17655c2dbd6261d](https://github.com/StoneCypher/jssm/commit/da69e65ee5a1567825b011d3e17655c2dbd6261d) + +Author: `John Haugeland ` + + * re-enable stoch testing, fixes StoneCypher/fsl#1187; replace .replaceAll with .replace, fixes StoneCypher/fsl#1188 + + + + +  + +  + +## [Untagged] - 9/1/2022 3:57:04 PM + +Commit [9e18022f7b474f06e30df55df254f01a0bf6ceb6](https://github.com/StoneCypher/jssm/commit/9e18022f7b474f06e30df55df254f01a0bf6ceb6) + +Author: `Vat Raghavan ` + + * more-readable README + + + + +  + +  + + + +## [5.82.1] - 8/20/2022 11:19:53 AM + +Commit [27480ec9b23dc281db0212e68f53aabcdc8b946f](https://github.com/StoneCypher/jssm/commit/27480ec9b23dc281db0212e68f53aabcdc8b946f) + +Author: `John Haugeland ` + +Merges [5278df4, 03e1ad3] + + * Merge pull request #529 from StoneCypher/ExposeThemesAndDirections + * Expose themes and directions; fixes StoneCypher/fsl#540, fixes StoneCypher/fsl#541 + + + + +  + +  + +## [Untagged] - 8/20/2022 11:16:34 AM + +Commit [03e1ad3acf5074dd570eb9a2e2001abab10fb923](https://github.com/StoneCypher/jssm/commit/03e1ad3acf5074dd570eb9a2e2001abab10fb923) + +Author: `John Haugeland ` + + * Expose themes and directions; fixes StoneCypher/fsl#540, fixes StoneCypher/fsl#541 + + + + +  + +  + + + +## [5.82.0] - 8/19/2022 11:11:19 PM + +Commit [5278df4d94a347b37da6cdca2a64a6ca85665b42](https://github.com/StoneCypher/jssm/commit/5278df4d94a347b37da6cdca2a64a6ca85665b42) + +Author: `John Haugeland ` + +Merges [72d6ef7, 88d7309] + + * Merge pull request #528 from StoneCypher/SpinUpThemes + * Spin up themes + + + + +  + +  + +## [Untagged] - 8/19/2022 11:04:20 PM + +Commit [88d7309bfd2217fe9aeae3be681ae1f520542365](https://github.com/StoneCypher/jssm/commit/88d7309bfd2217fe9aeae3be681ae1f520542365) + +Author: `John Haugeland ` + + * Multiple themes, fixes StoneCypher/fsl#128 + + + + +  + +  + +## [Untagged] - 8/19/2022 8:44:55 PM + +Commit [2cf5a3f8121a68db58bba992e85b95a8b0e6315e](https://github.com/StoneCypher/jssm/commit/2cf5a3f8121a68db58bba992e85b95a8b0e6315e) + +Author: `John Haugeland ` + + * coverage pass prior to multitheme + + + + +  + +  + +## [Untagged] - 8/18/2022 10:12:07 PM + +Commit [2f81a2682202a239acc8acbefe0360e3481c8ca9](https://github.com/StoneCypher/jssm/commit/2f81a2682202a239acc8acbefe0360e3481c8ca9) + +Author: `John Haugeland ` + + * draft themes in place + + + + +  + +  + +## [Untagged] - 8/17/2022 10:02:39 PM + +Commit [9209392cd7e025b365da88aa29649c63b241074d](https://github.com/StoneCypher/jssm/commit/9209392cd7e025b365da88aa29649c63b241074d) + +Author: `John Haugeland ` + + * mostly done, just have to surface the themes then do testing + + + + +  + +  + + + +## [5.81.2] - 8/14/2022 4:22:34 PM + +Commit [72d6ef77839234d9763ba3c5e667f0eb5ef43951](https://github.com/StoneCypher/jssm/commit/72d6ef77839234d9763ba3c5e667f0eb5ef43951) + +Author: `John Haugeland ` + + * Clarify composite style type before we start work on themes + + + + +  + +  + +## [Untagged] - 8/11/2022 9:01:49 PM + +Commit [df1dd4c1d190b6571cf43637183b831229793eba](https://github.com/StoneCypher/jssm/commit/df1dd4c1d190b6571cf43637183b831229793eba) + +Author: `John Haugeland ` + + * Small type changes preparing for theme + + + + +  + +  + + + +## [5.81.0] - 8/10/2022 11:32:42 PM + +Commit [5162f2299530514aecba1bf78fbfe77910e3a417](https://github.com/StoneCypher/jssm/commit/5162f2299530514aecba1bf78fbfe77910e3a417) + +Author: `John Haugeland ` + + * Engine and parser support for label substitution (no viz yet,) fixes StoneCypher/fsl#117; fixes StoneCypher/fsl#263 + + + + +  + +  + +## [Untagged] - 8/10/2022 10:25:03 PM + +Commit [bab9f160ae1dab672a2800c175c21fed2e74f48e](https://github.com/StoneCypher/jssm/commit/bab9f160ae1dab672a2800c175c21fed2e74f48e) + +Author: `John Haugeland ` + +Merges [59e95d8, c3939c3] + + * Merge branch 'main' of github.com:StoneCypher/jssm + + + + +  + +  + +## [Untagged] - 8/10/2022 10:24:55 PM + +Commit [59e95d8d4c06a63fb51b0c886d23612a4835ccfc](https://github.com/StoneCypher/jssm/commit/59e95d8d4c06a63fb51b0c886d23612a4835ccfc) + +Author: `John Haugeland ` + + * tests for property overriding from inline and for border lines + + + + +  + +  + + + +## [5.80.1] - 8/7/2022 11:57:01 PM + +Commit [c3939c3486d8ae2338385de375d753ef5a38673d](https://github.com/StoneCypher/jssm/commit/c3939c3486d8ae2338385de375d753ef5a38673d) + +Author: `John Haugeland ` + +Merges [6cb2816, b59b5b5] + + * Merge pull request #527 from StoneCypher/AddInlineStylesToResolver + * Adds inline styles to resolver, fixes StoneCypher/fsl#1160 + + + + +  + +  + +## [Untagged] - 8/7/2022 11:52:57 PM + +Commit [b59b5b530de566d82b6fa707d66f9b5ceb2037e8](https://github.com/StoneCypher/jssm/commit/b59b5b530de566d82b6fa707d66f9b5ceb2037e8) + +Author: `John Haugeland ` + + * Adds inline styles to resolver, fixes StoneCypher/fsl#1160 + + + + +  + +  + + + +## [5.80.0] - 8/4/2022 9:37:11 PM + +Commit [6cb281616eaa3d70bc0ff4e14410c5caa07f70f2](https://github.com/StoneCypher/jssm/commit/6cb281616eaa3d70bc0ff4e14410c5caa07f70f2) + +Author: `John Haugeland ` + +Merges [4d79b09, ed398d3] + + * Merge pull request #526 from StoneCypher/SupportForStartAndEndStateStyling + * Support for start and end state styling + + + + +  + +  + +## [Untagged] - 8/4/2022 9:29:52 PM + +Commit [ed398d3627e63b7b64d009acb42779b814e2f6da](https://github.com/StoneCypher/jssm/commit/ed398d3627e63b7b64d009acb42779b814e2f6da) + +Author: `John Haugeland ` + + * tests + + + + +  + +  + +## [Untagged] - 8/4/2022 9:15:50 PM + +Commit [63304cd9d1dd4ea5801edb6437f361023e3d6c32](https://github.com/StoneCypher/jssm/commit/63304cd9d1dd4ea5801edb6437f361023e3d6c32) + +Author: `John Haugeland ` + + * Styling now works for start, end, and terminal state types too. Fixes StoneCypher/fsl#1143, fixes StoneCypher/fsl#1141, fixes StoneCypher/fsl#1156, fixes StoneCypher/fsl#1157, fixes StoneCypher/fsl#242 + + + + +  + +  + +## [Untagged] - 8/4/2022 1:50:52 AM + +Commit [89948de7b9857909a6132c95cd6019be08e82d18](https://github.com/StoneCypher/jssm/commit/89948de7b9857909a6132c95cd6019be08e82d18) + +Author: `John Haugeland ` + + * Semi-working implementation of style condensation, fixes StoneCypher/fsl#1141; added base stylesheet, fixes StoneCypher/fsl#1142 + + + + +  + +  + +## [Untagged] - 8/2/2022 3:50:45 PM + +Commit [9001216af66f3fc719a406402d1d07f66cea465c](https://github.com/StoneCypher/jssm/commit/9001216af66f3fc719a406402d1d07f66cea465c) + +Author: `John Haugeland ` + + * Six style modalities exposed, fixes StoneCypher/fsl#1136, fixes StoneCypher/fsl#1137, fixes StoneCypher/fsl#1138, fixes StoneCypher/fsl#1139, fixes StoneCypher/fsl#1140 + + + + +  + +  + +## [Untagged] - 8/1/2022 12:08:55 PM + +Commit [1c4fcaaf1b15087b8d2aaa4fcf08ee386fb7c90c](https://github.com/StoneCypher/jssm/commit/1c4fcaaf1b15087b8d2aaa4fcf08ee386fb7c90c) + +Author: `John Haugeland ` + + * all six state styles (start end standard hooked terminal current) now make it through to the machine, fixes StoneCypher/fsl#1131, fixes StoneCypher/fsl#1132, fixes StoneCypher/fsl#1133, fixes StoneCypher/fsl#1134, fixes StoneCypher/fsl#1135 + + + + +  + +  + + + +## [5.79.18] - 7/28/2022 11:21:27 PM + +Commit [4d79b09ceed3385fbfd237092c5befd0b120f589](https://github.com/StoneCypher/jssm/commit/4d79b09ceed3385fbfd237092c5befd0b120f589) + +Author: `John Haugeland ` + + * Compile benchmark, fixes StoneCypher/fsl#1130 + + + + +  + +  + + + +## [5.79.17] - 7/28/2022 10:21:48 PM + +Commit [80a5f0821ce4e866bfdb6ed9123ee3e409fdfd99](https://github.com/StoneCypher/jssm/commit/80a5f0821ce4e866bfdb6ed9123ee3e409fdfd99) + +Author: `John Haugeland ` + + * Definitions for language features in feature comparison matrix + + + + +  + +  + + + +## [5.79.16] - 7/28/2022 7:04:27 PM + +Commit [a76a9d87b7f1d691e982d9b5da8a5bc0d68fc1ea](https://github.com/StoneCypher/jssm/commit/a76a9d87b7f1d691e982d9b5da8a5bc0d68fc1ea) + +Author: `John Haugeland ` + +Merges [3cceb0a, 3363432] + + * Merge pull request #525 from StoneCypher/FinishComparisonMatrix + * Adds `stent`, `fsm`, `fsm-event`, `node-state`, `state-machine`, `stately.js` to feature comparison table, fixes StoneCypher/fsl#1118, fixes StoneCypher/fsl#1119, fixes StoneCypher/fsl#1120, fixes StoneCypher/fsl#1121, fixes StoneCypher/fsl#1122, fixes StoneCypher/fsl#1123 + + + + +  + +  + +## [Untagged] - 7/28/2022 7:01:10 PM + +Commit [3363432b1abe446798ca41beff6ce7a9f3b6cee6](https://github.com/StoneCypher/jssm/commit/3363432b1abe446798ca41beff6ce7a9f3b6cee6) + +Author: `John Haugeland ` + + * Adds `stent`, `fsm`, `fsm-event`, `node-state`, `state-machine`, `stately.js`, `node-state` to feature comparison table, fixes StoneCypher/fsl#1118, fixes StoneCypher/fsl#1119, fixes StoneCypher/fsl#1120, fixes StoneCypher/fsl#1121, fixes StoneCypher/fsl#1122, fixes StoneCypher/fsl#1123 + + + + +  + +  + + + +## [5.79.15] - 7/28/2022 3:47:24 PM + +Commit [3cceb0ab8a9d56f7f3cd79b6ff64beb882e7bc86](https://github.com/StoneCypher/jssm/commit/3cceb0ab8a9d56f7f3cd79b6ff64beb882e7bc86) + +Author: `John Haugeland ` + +Merges [bc39f54, 3ace82f] + + * Merge pull request #524 from StoneCypher/MoreTryingToFixTwitterTweeter + * More trying to fix twitter tweeter + + + + +  + +  + +## [Untagged] - 7/28/2022 3:37:38 PM + +Commit [3ace82f3e03403765c72ffda4e4e8819bcd1e1ca](https://github.com/StoneCypher/jssm/commit/3ace82f3e03403765c72ffda4e4e8819bcd1e1ca) + +Author: `John Haugeland ` + + * Working on the Twitter release message + + + + +  + +  + +## [Untagged] - 7/28/2022 3:28:23 PM + +Commit [bc39f54865c2eb421261ee1a6ff9e3f6cc3f0b66](https://github.com/StoneCypher/jssm/commit/bc39f54865c2eb421261ee1a6ff9e3f6cc3f0b66) + +Author: `John Haugeland ` + +Merges [98eb7eb, 6324d89] + + * Merge pull request #523 from StoneCypher/MoreComparisonChart + * More comparison chart + + + + +  + +  + +## [Untagged] - 7/28/2022 3:25:12 PM + +Commit [6483abdffc869f010f866110c55295da1bee022d](https://github.com/StoneCypher/jssm/commit/6483abdffc869f010f866110c55295da1bee022d) + +Author: `John Haugeland ` + +Merges [6324d89, 98eb7eb] + + * Merge branch 'main' into MoreComparisonChart + + + + +  + +  + +## [Untagged] - 7/28/2022 3:24:41 PM + +Commit [6324d89f41053d8129df931d56ef4a0fdf499500](https://github.com/StoneCypher/jssm/commit/6324d89f41053d8129df931d56ef4a0fdf499500) + +Author: `John Haugeland ` + + * try to fix the broken publish env + + + + +  + +  + +## [Untagged] - 7/28/2022 3:19:37 PM + +Commit [915482bf57474c05cb0b8722e89d782eda4ea61c](https://github.com/StoneCypher/jssm/commit/915482bf57474c05cb0b8722e89d782eda4ea61c) + +Author: `John Haugeland ` + + * Adds `machina`, `finity`, `fsm-iterator`, `fsm-as-promised` to feature comparison table, fixes StoneCypher/fsl#1114, fixes StoneCypher/fsl#1115, fixes StoneCypher/fsl#1116, fixes StoneCypher/fsl#1117 + + + + +  + +  + +## [Untagged] - 7/28/2022 1:46:09 PM + +Commit [98eb7eb745ed5b8593e7695764ddee37eb8ecf9e](https://github.com/StoneCypher/jssm/commit/98eb7eb745ed5b8593e7695764ddee37eb8ecf9e) + +Author: `John Haugeland ` + +Merges [66cbb1d, 16920b1] + + * Merge pull request #522 from StoneCypher/MoreComparisonChart + * More comparison chart + + + + +  + +  + +## [Untagged] - 7/28/2022 1:45:17 PM + +Commit [16920b102b96a8cc4e3db44abb5b17b716940090](https://github.com/StoneCypher/jssm/commit/16920b102b96a8cc4e3db44abb5b17b716940090) + +Author: `John Haugeland ` + + * Adds `robot3` to feature comparison table, fixes StoneCypher/fsl#1124 + + + + +  + +  + +## [Untagged] - 7/28/2022 1:02:26 PM + +Commit [6a7684e3a0b665e3c7b7f38e6adda08c09d18c1c](https://github.com/StoneCypher/jssm/commit/6a7684e3a0b665e3c7b7f38e6adda08c09d18c1c) + +Author: `John Haugeland ` + + * Adds `mood` to feature comparison table, fixes StoneCypher/fsl#1125 + + + + +  + +  + +## [Untagged] - 7/28/2022 12:52:20 PM + +Commit [b49af31975f4424923024f2cef459a975240a98e](https://github.com/StoneCypher/jssm/commit/b49af31975f4424923024f2cef459a975240a98e) + +Author: `John Haugeland ` + + * Add `grammar-graph` to comparison, fixes StoneCypher/fsl#1126 + + + + +  + +  + + + +## [5.79.11] - 7/28/2022 8:22:55 AM + +Commit [66cbb1d35679c7271a08bc31ab3a7b2557a15f3e](https://github.com/StoneCypher/jssm/commit/66cbb1d35679c7271a08bc31ab3a7b2557a15f3e) + +Author: `John Haugeland ` + + * Add javascript-state-machine to feature comparison, fixes StoneCypher/fsl#1113 + + + + +  + +  + + + +## [5.79.10] - 7/27/2022 11:44:10 PM + +Commit [aa5e666f5f02e5fc0c6818dd7fb84dd689dc0448](https://github.com/StoneCypher/jssm/commit/aa5e666f5f02e5fc0c6818dd7fb84dd689dc0448) + +Author: `John Haugeland ` + + * Feature comparison table, shots fired, fixes StoneCypher/fsl#839, fixes StoneCypher/fsl#643 + + + + +  + +  + +## [Untagged] - 7/27/2022 10:21:23 PM + +Commit [2f548fc2c2c8e02d9ac5da5279a6c8d69130316f](https://github.com/StoneCypher/jssm/commit/2f548fc2c2c8e02d9ac5da5279a6c8d69130316f) + +Author: `John Haugeland ` + + * first sketch of feature comparison + + + + +  + +  + +## [Untagged] - 7/25/2022 11:11:11 AM + +Commit [d0a4b3e731b887da477f2dde109a5d57b39522b3](https://github.com/StoneCypher/jssm/commit/d0a4b3e731b887da477f2dde109a5d57b39522b3) + +Author: `John Haugeland ` + + * Delete example-machine-template.md + + + + +  + +  + +## [Untagged] - 7/25/2022 11:09:21 AM + +Commit [572a8a1e14f4b29a1bb021e9b76124d74959e59b](https://github.com/StoneCypher/jssm/commit/572a8a1e14f4b29a1bb021e9b76124d74959e59b) + +Author: `John Haugeland ` + + * Delete feature-requesting-template.md + + + + +  + +  + +## [Untagged] - 7/25/2022 11:09:07 AM + +Commit [7379b2324c15a44ca98311121408b771d165b68a](https://github.com/StoneCypher/jssm/commit/7379b2324c15a44ca98311121408b771d165b68a) + +Author: `John Haugeland ` + + * Delete bug-reporting-template.md + + + + +  + +  + +## [Untagged] - 7/25/2022 11:08:28 AM + +Commit [412cabb32d87ffd91752ba5006c59e4b1867a469](https://github.com/StoneCypher/jssm/commit/412cabb32d87ffd91752ba5006c59e4b1867a469) + +Author: `John Haugeland ` + + * Create config.yml + + + + +  + +  + + + +## [5.79.9] - 7/25/2022 5:41:07 AM + +Commit [014cafc52c34afb19f50e8ab60741ee8585b1213](https://github.com/StoneCypher/jssm/commit/014cafc52c34afb19f50e8ab60741ee8585b1213) + +Author: `John Haugeland ` + + * centralize prior to tree tool + + + + +  + +  + + + +## [5.79.8] - 7/22/2022 12:23:51 AM + +Commit [2c1ab4f936b061a7ffe46187f45fdc3949b3eb1f](https://github.com/StoneCypher/jssm/commit/2c1ab4f936b061a7ffe46187f45fdc3949b3eb1f) + +Author: `John Haugeland ` + + * Expose a load of math constants; create a constants namespace. Leave the old ones in both places for compat. Fixes StoneCypher/fsl#1043, StoneCypher/fsl#1044, StoneCypher/fsl#1045, StoneCypher/fsl#1046, StoneCypher/fsl#1047, StoneCypher/fsl#1048, StoneCypher/fsl#1049, StoneCypher/fsl#1050, StoneCypher/fsl#1058, StoneCypher/fsl#1059, StoneCypher/fsl#1060, StoneCypher/fsl#1061, StoneCypher/fsl#1062, StoneCypher/fsl#1063, StoneCypher/fsl#1064, StoneCypher/fsl#1065, StoneCypher/fsl#1066 + + + + +  + +  + + + +## [5.79.6] - 7/21/2022 11:56:00 PM + +Commit [e91095dc64dacebab0dafe96180219998e0d2891](https://github.com/StoneCypher/jssm/commit/e91095dc64dacebab0dafe96180219998e0d2891) + +Author: `John Haugeland ` + + * add newline in gha envvar to support twitter action + + + + +  + +  + +## [Untagged] - 7/21/2022 11:03:43 PM + +Commit [a2a45dbfda6df7012651a55aa65f8e606c0a8768](https://github.com/StoneCypher/jssm/commit/a2a45dbfda6df7012651a55aa65f8e606c0a8768) + +Author: `John Haugeland ` + +Merges [3bf5c1d, 277683b] + + * Merge pull request #521 from StoneCypher/StartTweetingInGha + * improved tweet system, fixed gh action non-install + + + + +  + +  + +## [Untagged] - 7/21/2022 10:58:51 PM + +Commit [277683b9ba40288005a0bf2d7044dea84696ac01](https://github.com/StoneCypher/jssm/commit/277683b9ba40288005a0bf2d7044dea84696ac01) + +Author: `John Haugeland ` + + * improved tweet system, fixed gh action non-install + + + + +  + +  + + + +## [5.79.4] - 7/21/2022 10:39:56 PM + +Commit [3bf5c1d061d67524c5f97279a854473d9989e92b](https://github.com/StoneCypher/jssm/commit/3bf5c1d061d67524c5f97279a854473d9989e92b) + +Author: `John Haugeland ` + +Merges [02bf1ff, 39f3906] + + * Merge pull request #520 from StoneCypher/StartTweetingInGha + * Start tweeting in gha + + + + +  + +  + +## [Untagged] - 7/21/2022 10:35:56 PM + +Commit [39f390677155346d07f55264f006c1067932670f](https://github.com/StoneCypher/jssm/commit/39f390677155346d07f55264f006c1067932670f) + +Author: `John Haugeland ` + + * Bump, rebuild + + + + +  + +  + +## [Untagged] - 7/21/2022 10:33:47 PM + +Commit [03f81a35f2c158b1139589bb67fd230fa46be3be](https://github.com/StoneCypher/jssm/commit/03f81a35f2c158b1139589bb67fd230fa46be3be) + +Author: `John Haugeland ` + + * Automate GHA tweeting of releases to @FSL_and_JSSM; bump terser; fix protocol on youtube links + + + + +  + +  + + + +## [5.79.3] - 7/18/2022 6:41:12 PM + +Commit [02bf1ff5ef650323c2ad5d4a54d2c21caf0f272a](https://github.com/StoneCypher/jssm/commit/02bf1ff5ef650323c2ad5d4a54d2c21caf0f272a) + +Author: `John Haugeland ` + + * changing to a protocol-free url in docs to get youtube vids to load, test 1 + + + + +  + +  + + + +## [5.79.2] - 7/14/2022 11:39:18 PM + +Commit [9f4e86c883c6bb776817da84ba3fe77473f47427](https://github.com/StoneCypher/jssm/commit/9f4e86c883c6bb776817da84ba3fe77473f47427) + +Author: `John Haugeland ` + +Merges [f756f21, 3a127c6] + + * Merge pull request #518 from StoneCypher/RequiredProperties + * Property requirement, fixes StoneCypher/fsl#1041 + + + + +  + +  + +## [Untagged] - 7/14/2022 11:31:58 PM + +Commit [3a127c6201604ec2323d72adabf72c07dd1425e3](https://github.com/StoneCypher/jssm/commit/3a127c6201604ec2323d72adabf72c07dd1425e3) + +Author: `John Haugeland ` + + * caught a typo + + + + +  + +  + +## [Untagged] - 7/14/2022 11:26:20 PM + +Commit [0a97cd4664b15047b265bd0bf72fd7da79b2d528](https://github.com/StoneCypher/jssm/commit/0a97cd4664b15047b265bd0bf72fd7da79b2d528) + +Author: `John Haugeland ` + + * Property requirement, fixes StoneCypher/fsl#1041 + + + + +  + +  + + + +## [5.79.1] - 7/14/2022 2:45:12 PM + +Commit [f756f219a0b8ca95feae287a110261dc364030cc](https://github.com/StoneCypher/jssm/commit/f756f219a0b8ca95feae287a110261dc364030cc) + +Author: `John Haugeland ` + +Merges [ed93695, e2cc7d1] + + * Merge pull request #517 from StoneCypher/StrictProp + * `.strict_prop`, fixes StoneCypher/fsl#1037; tests to enforce, fixes StoneCypher/fsl#1035 + + + + +  + +  + +## [Untagged] - 7/14/2022 2:37:44 PM + +Commit [e2cc7d1c49c6507572d26c30ff069aee19167eec](https://github.com/StoneCypher/jssm/commit/e2cc7d1c49c6507572d26c30ff069aee19167eec) + +Author: `John Haugeland ` + + * `.strict_prop`, fixes StoneCypher/fsl#1037; tests to enforce, fixes StoneCypher/fsl#1035 + + + + +  + +  + + + +## [5.79.0] - 7/13/2022 9:32:13 PM + +Commit [ed936950b132042aeb299c02ad199fe84d5f41f5](https://github.com/StoneCypher/jssm/commit/ed936950b132042aeb299c02ad199fe84d5f41f5) + +Author: `John Haugeland ` + +Merges [7e9fc0d, d28ab5a] + + * Merge pull request #516 from StoneCypher/Properties + * Properties + + + + +  + +  + +## [Untagged] - 7/13/2022 6:41:37 PM + +Commit [d28ab5a2a576d25bf45d5fd2f55895441a10cd99](https://github.com/StoneCypher/jssm/commit/d28ab5a2a576d25bf45d5fd2f55895441a10cd99) + +Author: `John Haugeland ` + + * State properties make it to machine, fixes StoneCypher/fsl#1040; overrides, fixes StoneCypher/fsl#1023 + + + + +  + +  + +## [Untagged] - 7/13/2022 2:23:16 PM + +Commit [ef4f483808e5aff64c4dee0ffac1472ac9202c4b](https://github.com/StoneCypher/jssm/commit/ef4f483808e5aff64c4dee0ffac1472ac9202c4b) + +Author: `John Haugeland ` + + * `.props`, fixes StoneCypher/fsl#1019; state props make it through compiler, fixes StoneCypher/fsl#1029; lots of doc improvements, numeric constants + + + + +  + +  + +## [Untagged] - 7/13/2022 2:20:10 PM + +Commit [7814c864c7bffeeb755bc0f3d7ec1faf8e4a965d](https://github.com/StoneCypher/jssm/commit/7814c864c7bffeeb755bc0f3d7ec1faf8e4a965d) + +Author: `John Haugeland ` + + * State properties in grammar, fixes StoneCypher/fsl#1030, fixes StoneCypher/fsl#1031, fixes StoneCypher/fsl#1032, fixes StoneCypher/fsl#1033, fixes StoneCypher/fsl#1034 + + + + +  + +  + +## [Untagged] - 7/13/2022 9:06:10 AM + +Commit [1349b752fd40db754dfa760bfb60b16646ef5108](https://github.com/StoneCypher/jssm/commit/1349b752fd40db754dfa760bfb60b16646ef5108) + +Author: `John Haugeland ` + + * known_prop, fixes StoneCypher/fsl#1021 + + + + +  + +  + +## [Untagged] - 7/13/2022 8:14:19 AM + +Commit [c7191c8ba796bd21cb2ba123038b9c6b5b274057](https://github.com/StoneCypher/jssm/commit/c7191c8ba796bd21cb2ba123038b9c6b5b274057) + +Author: `John Haugeland ` + + * Default props now making it into machine, fixes StoneCypher/fsl#1039; datastructures, fixes StoneCypher/fsl#1022 + + + + +  + +  + +## [Untagged] - 7/12/2022 10:05:06 AM + +Commit [1629741f34d564706e6c91f8cfc60edcfdd379bb](https://github.com/StoneCypher/jssm/commit/1629741f34d564706e6c91f8cfc60edcfdd379bb) + +Author: `John Haugeland ` + + * Default properties now make it through compiler, fixes StoneCypher/fsl#1028; blocks repetition, fixes StoneCypher/fsl#1038 + + + + +  + +  + +## [Untagged] - 7/11/2022 10:38:54 PM + +Commit [fd306ed88144815a2d2fb26250709d4fba8f99fe](https://github.com/StoneCypher/jssm/commit/fd306ed88144815a2d2fb26250709d4fba8f99fe) + +Author: `John Haugeland ` + + * Basic machine properties now making it through aggregation + + + + +  + +  + +## [Untagged] - 7/11/2022 10:10:29 PM + +Commit [400cbe62582aa2261b694f01e0d04704a76a12ef](https://github.com/StoneCypher/jssm/commit/400cbe62582aa2261b694f01e0d04704a76a12ef) + +Author: `John Haugeland ` + + * Basic tests for property defaults + + + + +  + +  + +## [Untagged] - 7/11/2022 9:55:08 PM + +Commit [31425dd227fa0811e387d96f89e40e2c0e148df3](https://github.com/StoneCypher/jssm/commit/31425dd227fa0811e387d96f89e40e2c0e148df3) + +Author: `John Haugeland ` + + * Internal property datastructures, fixes StoneCypher/fsl#1022, getting started with StoneCypher/fsl#1018 + + + + +  + +  + + + +## [5.78.0] - 7/9/2022 4:22:51 PM + +Commit [7e9fc0d832e0e46b477e27758183cc6ffc288916](https://github.com/StoneCypher/jssm/commit/7e9fc0d832e0e46b477e27758183cc6ffc288916) + +Author: `John Haugeland ` + +Merges [6497ed4, 1e742f0] + + * Merge pull request #514 from StoneCypher/Serialize + * Serialize + + + + +  + +  + +## [Untagged] - 7/9/2022 3:50:44 PM + +Commit [1e742f089c9d0d012691abe9cc6db82d54925469](https://github.com/StoneCypher/jssm/commit/1e742f089c9d0d012691abe9cc6db82d54925469) + +Author: `John Haugeland ` + + * Draft implementation of serialization and deserialization. Fixes StoneCypher/fsl#1000, fixes StoneCypher/fsl#1001, fixes StoneCypher/fsl#1002, fixes StoneCypher/fsl#1003, fixes StoneCypher/fsl#1004, fixes StoneCypher/fsl#1005, fixes StoneCypher/fsl#1006, fixes StoneCypher/fsl#1009, fixes StoneCypher/fsl#1011, fixes StoneCypher/fsl#1012 + + + + +  + +  + +## [Untagged] - 7/9/2022 1:00:20 PM + +Commit [05c1f81f02406cb3211e3d2bd84eefb2da201b3e](https://github.com/StoneCypher/jssm/commit/05c1f81f02406cb3211e3d2bd84eefb2da201b3e) + +Author: `John Haugeland ` + + * Spec underway + + + + +  + +  + + + +## [5.77.1] - 7/7/2022 10:36:21 PM + +Commit [6497ed49a6a7dbe55509ac552cc30adb9ee19c9c](https://github.com/StoneCypher/jssm/commit/6497ed49a6a7dbe55509ac552cc30adb9ee19c9c) + +Author: `John Haugeland ` + +Merges [e9400bd, 4623580] + + * Merge pull request #512 from StoneCypher/SynonymDoForAction + * Define do/1 to be a synonym for action/1, fixes StoneCypher/fsl#809 + + + + +  + +  + +## [Untagged] - 7/7/2022 10:18:20 PM + +Commit [462358017970f5d968d8309ba8ee96d74648ec03](https://github.com/StoneCypher/jssm/commit/462358017970f5d968d8309ba8ee96d74648ec03) + +Author: `John Haugeland ` + + * Define do/1 to be a synonym for action/1, fixes StoneCypher/fsl#809 + + + + +  + +  + + + +## [5.77.0] - 7/7/2022 10:18:06 PM + +Commit [e9400bd62c93201bcc34a002469e21910979cb2e](https://github.com/StoneCypher/jssm/commit/e9400bd62c93201bcc34a002469e21910979cb2e) + +Author: `John Haugeland ` + +Merges [d1b55ae, 2c633a6] + + * Merge pull request #511 from StoneCypher/SynonymGoForTransition + * Define go/1 to be a synonym for transition/1, fixes StoneCypher/fsl#810 + + + + +  + +  -## [5.76.2] - 7/6/2022 8:27:33 AM +## [Untagged] - 7/7/2022 10:11:44 PM -Commit [d1b55ae8944031677c228f06eec6a5a28eb695ac](https://github.com/StoneCypher/jssm/commit/d1b55ae8944031677c228f06eec6a5a28eb695ac) +Commit [2c633a61b2ee0f13583ddc85923596f6b473abe6](https://github.com/StoneCypher/jssm/commit/2c633a61b2ee0f13583ddc85923596f6b473abe6) Author: `John Haugeland ` -Merges [813d866, 40677c7] - - * Merge pull request #510 from StoneCypher/BumpCloc - * Bump CLOC, fixes StoneCypher/fsl#995 + * Define go/1 to be a synonym for transition/1, fixes StoneCypher/fsl#810 @@ -42,13 +2270,13 @@ Merges [813d866, 40677c7]   -## [Untagged] - 7/5/2022 1:24:10 PM +## [Untagged] - 7/7/2022 12:29:56 PM -Commit [40677c744241e590d901c317cdcc0046833a5257](https://github.com/StoneCypher/jssm/commit/40677c744241e590d901c317cdcc0046833a5257) +Commit [d29b22488e10f3ee798b7ecb23598654fe987fb8](https://github.com/StoneCypher/jssm/commit/d29b22488e10f3ee798b7ecb23598654fe987fb8) Author: `John Haugeland ` - * Uh, you have to git add to git commit, dummy + * it seems the bundling error I was facing when Discord insisted I just didn't get it might be a bug in deno @@ -57,15 +2285,18 @@ Author: `John Haugeland `   -## [Untagged] - 7/5/2022 1:04:10 PM + + +## [5.76.2] - 7/6/2022 8:27:33 AM -Commit [58e88fec3f6412cadfc762f646ed50f6bc10eac6](https://github.com/StoneCypher/jssm/commit/58e88fec3f6412cadfc762f646ed50f6bc10eac6) +Commit [d1b55ae8944031677c228f06eec6a5a28eb695ac](https://github.com/StoneCypher/jssm/commit/d1b55ae8944031677c228f06eec6a5a28eb695ac) Author: `John Haugeland ` -Merges [1cc0629, 0cc8f7b] +Merges [813d866, 40677c7] - * WIP on IntroducingTheKitchenSinkDragon: 1cc0629 Sequester the stoch tests until they're more complete + * Merge pull request #510 from StoneCypher/BumpCloc + * Bump CLOC, fixes StoneCypher/fsl#995 @@ -74,13 +2305,13 @@ Merges [1cc0629, 0cc8f7b]   -## [Untagged] - 7/5/2022 1:04:10 PM +## [Untagged] - 7/5/2022 1:24:10 PM -Commit [0cc8f7bad92e4327128237bc9600cedd2e7cbb94](https://github.com/StoneCypher/jssm/commit/0cc8f7bad92e4327128237bc9600cedd2e7cbb94) +Commit [40677c744241e590d901c317cdcc0046833a5257](https://github.com/StoneCypher/jssm/commit/40677c744241e590d901c317cdcc0046833a5257) Author: `John Haugeland ` - * index on IntroducingTheKitchenSinkDragon: 1cc0629 Sequester the stoch tests until they're more complete + * Uh, you have to git add to git commit, dummy @@ -235,21 +2466,6 @@ Author: `John Haugeland ` -  - -  - -## [Untagged] - 7/3/2022 11:41:29 AM - -Commit [7bf27e64e929c449d613d461fd1de1ceee4e8183](https://github.com/StoneCypher/jssm/commit/7bf27e64e929c449d613d461fd1de1ceee4e8183) - -Author: `John Haugeland ` - - * Force this directory to exist with a meaningles file that defies the gitignore, then roll version back because apparently .0 didn't get released - - - -     @@ -295,36 +2511,6 @@ Author: `John Haugeland ` -  - -  - -## [Untagged] - 7/3/2022 10:08:02 AM - -Commit [986fd0dd50adcb739f54e4fa3712628c94004505](https://github.com/StoneCypher/jssm/commit/986fd0dd50adcb739f54e4fa3712628c94004505) - -Author: `John Haugeland ` - - * added cloc, turned to disk, made a cute little reporter, fixes StoneCypher/fsl#985 - - - - -  - -  - -## [Untagged] - 7/3/2022 10:08:02 AM - -Commit [0c34b68d5a5d6666895965e5f8b4b9a9dadfe397](https://github.com/StoneCypher/jssm/commit/0c34b68d5a5d6666895965e5f8b4b9a9dadfe397) - -Author: `John Haugeland ` - - * added cloc, turned to disk, made a cute little reporter, fixes StoneCypher/fsl#985 - - - -     @@ -2273,21 +4459,6 @@ Author: `John Haugeland ` -  - -  - -## [Untagged] - 5/22/2022 9:07:03 AM - -Commit [4dbe3833d503a7f5af7563e487ab6f722b01220f](https://github.com/StoneCypher/jssm/commit/4dbe3833d503a7f5af7563e487ab6f722b01220f) - -Author: `John Haugeland ` - - * Document arr_uniq_p; fix merge mess - - - -     @@ -2308,66 +4479,6 @@ Merges [fdb3369, bc9f107] -  - -  - -## [Untagged] - 5/22/2022 8:52:35 AM - -Commit [9c6982187896ea62e1a7bdc989d4d16e57975f8a](https://github.com/StoneCypher/jssm/commit/9c6982187896ea62e1a7bdc989d4d16e57975f8a) - -Author: `John Haugeland ` - - * Document hook_name, fixes StoneCypher/#788, and named_hook_name, fixes StoneCypher/#789 - - - - -  - -  - -## [Untagged] - 5/22/2022 8:43:42 AM - -Commit [cc3b7dda265226ef7ca818d387c06628132673ef](https://github.com/StoneCypher/jssm/commit/cc3b7dda265226ef7ca818d387c06628132673ef) - -Author: `John Haugeland ` - - * document seq/1, document histo/1, a little extra testing, fixes StoneCypher/fsl#786, fixes StoneCypher/fsl#787 - - - - -  - -  - -## [Untagged] - 5/22/2022 8:43:42 AM - -Commit [9dbc57da37b83d3fc2a26c7de17aae8fe976a025](https://github.com/StoneCypher/jssm/commit/9dbc57da37b83d3fc2a26c7de17aae8fe976a025) - -Author: `John Haugeland ` - - * document seq/1, document histo/1, a little extra testing - - - - -  - -  - -## [Untagged] - 5/22/2022 8:43:42 AM - -Commit [780cc714651030e2a89343620dff20669d317e62](https://github.com/StoneCypher/jssm/commit/780cc714651030e2a89343620dff20669d317e62) - -Author: `John Haugeland ` - - * seq/1, a little extra testing - - - -     @@ -3504,51 +5615,6 @@ Author: `John Haugeland ` -  - -  - -## [Untagged] - 5/8/2022 3:31:19 PM - -Commit [6f68f82516475c74e9ae958b0b9d9d9ea8496742](https://github.com/StoneCypher/jssm/commit/6f68f82516475c74e9ae958b0b9d9d9ea8496742) - -Author: `John Haugeland ` - - * Bumps eslint, fixes StoneCypher/fsl#723 - - - - -  - -  - -## [Untagged] - 5/8/2022 3:14:51 PM - -Commit [7985afdecc47ec9247357e386efa126a705f6e7b](https://github.com/StoneCypher/jssm/commit/7985afdecc47ec9247357e386efa126a705f6e7b) - -Author: `John Haugeland ` - - * was pinned by ts-jest, re-bumped - - - - -  - -  - -## [Untagged] - 5/8/2022 3:09:14 PM - -Commit [ee261f9ce626b0df70932c82fe5e599abd4f1225](https://github.com/StoneCypher/jssm/commit/ee261f9ce626b0df70932c82fe5e599abd4f1225) - -Author: `John Haugeland ` - - * Bumps jest, fixes StoneCypher/fsl#719 - - - -     @@ -3699,23 +5765,6 @@ Merges [e993d6b, 23c50e2] -  - -  - -## [Untagged] - 5/8/2022 3:09:04 AM - -Commit [fbcda324d66dd8b569a4e60b93794af1a3fea8f0](https://github.com/StoneCypher/jssm/commit/fbcda324d66dd8b569a4e60b93794af1a3fea8f0) - -Author: `John Haugeland ` - -Merges [23c50e2, e993d6b] - - * Merge branch 'main' into AttemptToCorrectQualityDrop2 - - - -     @@ -4228,21 +6277,6 @@ Author: `John Haugeland ` -  - -  - -## [Untagged] - 4/26/2022 12:26:11 AM - -Commit [330a670aaf0b8b793ad5d2c10d3321c9b1dd1b43](https://github.com/StoneCypher/jssm/commit/330a670aaf0b8b793ad5d2c10d3321c9b1dd1b43) - -Author: `John Haugeland ` - - * will get started here - - - -     @@ -6525,21 +8559,6 @@ Author: `John Haugeland ` -  - -  - -## [Untagged] - 1/14/2021 1:14:47 PM - -Commit [78a99337c1e690abeac5c9c03c745f50393c43ae](https://github.com/StoneCypher/jssm/commit/78a99337c1e690abeac5c9c03c745f50393c43ae) - -Author: `John Haugeland ` - - * fix 531 soon - - - -     @@ -7549,53 +9568,6 @@ Author: `John Haugeland ` -  - -  - -## [Untagged] - 1/28/2020 7:50:46 PM - -Commit [92ecbf90777430ab2db1de3d0595c3150368ba6d](https://github.com/StoneCypher/jssm/commit/92ecbf90777430ab2db1de3d0595c3150368ba6d) - -Author: `John Haugeland ` - -Merges [1fa2e0b, 307ecf2] - - * WIP on LetsSimplifyTheTautologies: 1fa2e0b first steps: centralize the constants - - - - -  - -  - -## [Untagged] - 1/28/2020 7:50:44 PM - -Commit [307ecf2d66dc79fb6c6576641696a97b917d1b61](https://github.com/StoneCypher/jssm/commit/307ecf2d66dc79fb6c6576641696a97b917d1b61) - -Author: `John Haugeland ` - - * index on LetsSimplifyTheTautologies: 1fa2e0b first steps: centralize the constants - - - - -  - -  - -## [Untagged] - 1/28/2020 7:11:13 PM - -Commit [1fa2e0be1bbfdbb4e2627bd4154d9e02da61e377](https://github.com/StoneCypher/jssm/commit/1fa2e0be1bbfdbb4e2627bd4154d9e02da61e377) - -Author: `John Haugeland ` - - * first steps: centralize the constants - - - -     @@ -8865,38 +10837,6 @@ Author: `John Haugeland ` -  - -  - -## [Untagged] - 5/6/2019 9:11:54 PM - -Commit [6a6dee46986db783cebbb6d7f7df9be594f61be6](https://github.com/StoneCypher/jssm/commit/6a6dee46986db783cebbb6d7f7df9be594f61be6) - -Author: `John Haugeland ` - -Merges [816a498, e98824f] - - * WIP on (no branch): 816a498 attempt to surgery the lcov directly :| - - - - -  - -  - -## [Untagged] - 5/6/2019 9:11:54 PM - -Commit [e98824f54254cd8b32a755def3a5e0e6d936f842](https://github.com/StoneCypher/jssm/commit/e98824f54254cd8b32a755def3a5e0e6d936f842) - -Author: `John Haugeland ` - - * index on (no branch): 816a498 attempt to surgery the lcov directly :| - - - -     diff --git a/CHANGELOG.md b/CHANGELOG.md index 486562e6..ed8ae052 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,7 +2,7 @@ All notable changes to this project will be documented in this file. -961 merges; 129 releases; Changlogging the last 10 commits; Full changelog at [CHANGELOG.long.md](CHANGELOG.long.md) +1076 merges; 178 releases; Changlogging the last 10 commits; Full changelog at [CHANGELOG.long.md](CHANGELOG.long.md) @@ -12,7 +12,7 @@ All notable changes to this project will be documented in this file. Published tags: -5.76.2, 5.76.0, 5.75.1, 5.75.0, 5.74.0, 5.73.1, 5.73.0, 5.72.5, 5.72.4, 5.72.3, 5.72.2, 5.72.1, 5.72.0, 5.71.1, 5.71.0, 5.70.36, 5.70.35, 5.70.34, 5.70.33, 5.70.32, 5.70.31, 5.70.30, 5.70.29, 5.70.28, 5.70.27, 5.70.26, 5.70.25, 5.70.24, 5.70.23, 5.70.22, 5.70.21, 5.70.20, 5.70.19, 5.70.18, 5.70.16, 5.70.15, 5.70.14, 5.70.13, 5.70.12, 5.70.11, 5.70.10, 5.70.9, 5.70.8, 5.70.7, 5.70.6, 5.70.5, 5.70.4, 5.70.3, 5.70.2, 5.70.1, 5.70.0, 5.69.4, 5.69.3, 5.69.2, 5.69.0, 5.68.0, 5.67.2, 5.67.0, 5.66.0, 5.65.14, 5.65.12, 5.65.11, 5.65.10, 5.65.9, 5.65.8, 5.65.7, 5.65.5, 5.65.4, 5.65.3, 5.65.2, 5.65.1, 5.65.0, 5.64.2, 5.64.1, 5.64.0, 5.63.0, 5.62.0, 5.61.4, 5.61.3, 5.61.2, 5.61.1, 5.60.4, 5.60.3, 5.60.0, 5.59.1, 5.59.0, 5.58.1, 5.58.0, 5.57.1, 5.57.0, 5.56.2, 5.56.1, 5.55.0, 5.54.0, 5.53.0, 5.52.0, 5.51.0, 5.50.0, 5.49.0, 5.48.0, 5.47.0, 5.46.0, 5.45.2, 5.45.0, 5.44.0, 5.43.2, v5.42.0, 5.42.0, v5.41.15, 5.41.15, v5.41.14, 5.41.14, v5.41.12, 5.41.12, v5.41.10, 5.41.10, v5.41.9, 5.41.9, v5.41.8, 5.41.8, v5.41.7, v5.41.2, v5.41.1, v5.32.14, 5.14.0, 5.12.0, 5.11.12, 5.11.1, 5.11.0 +5.87.0, 5.86.3, 5.86.2, 5.86.1, 5.86.0, 5.85.11, 5.85.10, 5.85.9, 5.85.8, 5.85.7, 5.85.6, 5.85.5, 5.85.4, 5.85.3, 5.85.2, 5.85.1, 5.85.0, 5.84.1, 5.84.0, 5.83.2, 5.83.1, 5.83.0, 5.82.5, 5.82.4, 5.82.3, 5.82.2, 5.82.1, 5.82.0, 5.81.2, 5.81.0, 5.80.1, 5.80.0, 5.79.18, 5.79.17, 5.79.16, 5.79.15, 5.79.11, 5.79.10, 5.79.9, 5.79.8, 5.79.6, 5.79.4, 5.79.3, 5.79.2, 5.79.1, 5.79.0, 5.78.0, 5.77.1, 5.77.0, 5.76.2, 5.76.0, 5.75.1, 5.75.0, 5.74.0, 5.73.1, 5.73.0, 5.72.5, 5.72.4, 5.72.3, 5.72.2, 5.72.1, 5.72.0, 5.71.1, 5.71.0, 5.70.36, 5.70.35, 5.70.34, 5.70.33, 5.70.32, 5.70.31, 5.70.30, 5.70.29, 5.70.28, 5.70.27, 5.70.26, 5.70.25, 5.70.24, 5.70.23, 5.70.22, 5.70.21, 5.70.20, 5.70.19, 5.70.18, 5.70.16, 5.70.15, 5.70.14, 5.70.13, 5.70.12, 5.70.11, 5.70.10, 5.70.9, 5.70.8, 5.70.7, 5.70.6, 5.70.5, 5.70.4, 5.70.3, 5.70.2, 5.70.1, 5.70.0, 5.69.4, 5.69.3, 5.69.2, 5.69.0, 5.68.0, 5.67.2, 5.67.0, 5.66.0, 5.65.14, 5.65.12, 5.65.11, 5.65.10, 5.65.9, 5.65.8, 5.65.7, 5.65.5, 5.65.4, 5.65.3, 5.65.2, 5.65.1, 5.65.0, 5.64.2, 5.64.1, 5.64.0, 5.63.0, 5.62.0, 5.61.4, 5.61.3, 5.61.2, 5.61.1, 5.60.4, 5.60.3, 5.60.0, 5.59.1, 5.59.0, 5.58.1, 5.58.0, 5.57.1, 5.57.0, 5.56.2, 5.56.1, 5.55.0, 5.54.0, 5.53.0, 5.52.0, 5.51.0, 5.50.0, 5.49.0, 5.48.0, 5.47.0, 5.46.0, 5.45.2, 5.45.0, 5.44.0, 5.43.2, v5.42.0, 5.42.0, v5.41.15, 5.41.15, v5.41.14, 5.41.14, v5.41.12, 5.41.12, v5.41.10, 5.41.10, v5.41.9, 5.41.9, v5.41.8, 5.41.8, v5.41.7, v5.41.2, v5.41.1, v5.32.14, 5.14.0, 5.12.0, 5.11.12, 5.11.1, 5.11.0 @@ -22,18 +22,18 @@ Published tags:   - + -## [5.76.2] - 7/6/2022 8:27:33 AM +## [5.87.0] - 12/3/2022 8:18:35 PM -Commit [d1b55ae8944031677c228f06eec6a5a28eb695ac](https://github.com/StoneCypher/jssm/commit/d1b55ae8944031677c228f06eec6a5a28eb695ac) +Commit [85963d8c154225916ec9bf1f494c480ca033dec9](https://github.com/StoneCypher/jssm/commit/85963d8c154225916ec9bf1f494c480ca033dec9) Author: `John Haugeland ` -Merges [813d866, 40677c7] +Merges [dbb82ae, d6f77d1] - * Merge pull request #510 from StoneCypher/BumpCloc - * Bump CLOC, fixes StoneCypher/fsl#995 + * Merge pull request #549 from StoneCypher/next_data + * Next data @@ -42,13 +42,13 @@ Merges [813d866, 40677c7]   -## [Untagged] - 7/5/2022 1:24:10 PM +## [Untagged] - 12/3/2022 7:40:06 PM -Commit [40677c744241e590d901c317cdcc0046833a5257](https://github.com/StoneCypher/jssm/commit/40677c744241e590d901c317cdcc0046833a5257) +Commit [d6f77d1be4cf107f2eda1cfddca81d4ebcfc7c99](https://github.com/StoneCypher/jssm/commit/d6f77d1be4cf107f2eda1cfddca81d4ebcfc7c99) Author: `John Haugeland ` - * Uh, you have to git add to git commit, dummy + * forgot version bump @@ -57,15 +57,13 @@ Author: `John Haugeland `   -## [Untagged] - 7/5/2022 1:04:10 PM +## [Untagged] - 12/3/2022 7:32:06 PM -Commit [58e88fec3f6412cadfc762f646ed50f6bc10eac6](https://github.com/StoneCypher/jssm/commit/58e88fec3f6412cadfc762f646ed50f6bc10eac6) +Commit [e6227e3d26828277c002ff0dd67899ab89771fc2](https://github.com/StoneCypher/jssm/commit/e6227e3d26828277c002ff0dd67899ab89771fc2) Author: `John Haugeland ` -Merges [1cc0629, 0cc8f7b] - - * WIP on IntroducingTheKitchenSinkDragon: 1cc0629 Sequester the stoch tests until they're more complete + * next_data, fixes StoneCypher/fsl#1233 @@ -74,13 +72,13 @@ Merges [1cc0629, 0cc8f7b]   -## [Untagged] - 7/5/2022 1:04:10 PM +## [Untagged] - 12/2/2022 10:48:55 PM -Commit [0cc8f7bad92e4327128237bc9600cedd2e7cbb94](https://github.com/StoneCypher/jssm/commit/0cc8f7bad92e4327128237bc9600cedd2e7cbb94) +Commit [5fa6e48645cb75fcd5fe38e6ff08c0d5d64a7a23](https://github.com/StoneCypher/jssm/commit/5fa6e48645cb75fcd5fe38e6ff08c0d5d64a7a23) Author: `John Haugeland ` - * index on IntroducingTheKitchenSinkDragon: 1cc0629 Sequester the stoch tests until they're more complete + * nextData underway @@ -89,18 +87,16 @@ Author: `John Haugeland `   - + -## [5.76.0] - 7/5/2022 1:02:57 PM +## [5.86.3] - 11/12/2022 6:09:16 PM -Commit [813d8668300b88e72c0598ec9b5b19fce777d05e](https://github.com/StoneCypher/jssm/commit/813d8668300b88e72c0598ec9b5b19fce777d05e) +Commit [dbb82aefc2744729fd17108d33d19f504dc1783e](https://github.com/StoneCypher/jssm/commit/dbb82aefc2744729fd17108d33d19f504dc1783e) Author: `John Haugeland ` -Merges [bdea503, 1cc0629] - - * Merge pull request #509 from StoneCypher/IntroducingTheKitchenSinkDragon - * Introducing the kitchen sink dragon + * Implement override, implement in machine, allow override attribute + * Fixes StoneCypher/fsl#1228, fixes StoneCypher/fsl#1222, fixes StoneCypher/fsl#1232 @@ -109,13 +105,18 @@ Merges [bdea503, 1cc0629]   -## [Untagged] - 7/5/2022 12:58:07 PM + + +## [5.86.2] - 11/12/2022 12:49:23 PM -Commit [1cc0629fd1afa845b074c7f6dd2fa3ae16284429](https://github.com/StoneCypher/jssm/commit/1cc0629fd1afa845b074c7f6dd2fa3ae16284429) +Commit [a033eb38e784cbc5c6bf15bef576b69bb935f9b2](https://github.com/StoneCypher/jssm/commit/a033eb38e784cbc5c6bf15bef576b69bb935f9b2) Author: `John Haugeland ` - * Sequester the stoch tests until they're more complete +Merges [48b4f92, 99a5fd6] + + * Merge pull request #548 from StoneCypher/AllowsOverrideInCompiler + * allows override in compiler, constructor config to allow/disallow override, getters for override, cfg override, machine override @@ -124,13 +125,14 @@ Author: `John Haugeland `   -## [Untagged] - 7/5/2022 8:08:12 AM +## [Untagged] - 11/12/2022 12:44:20 PM -Commit [6ea28bad46da225e3593c294837d397234e0a84d](https://github.com/StoneCypher/jssm/commit/6ea28bad46da225e3593c294837d397234e0a84d) +Commit [99a5fd66ee5a342814cf34d89fb6dccc2f4ac7e9](https://github.com/StoneCypher/jssm/commit/99a5fd66ee5a342814cf34d89fb6dccc2f4ac7e9) Author: `John Haugeland ` - * non-shrinkable proof of concept + * allows override in compiler, constructor config to allow/disallow override, getters for override, cfg override, machine override + * fixes StoneCypher/fsl#1225, fixes StoneCypher/fsl#1227, fixes StoneCypher/fsl#1229, fixes StoneCypher/fsl#1230, fixes StoneCypher/fsl#1231 @@ -139,13 +141,15 @@ Author: `John Haugeland `   -## [Untagged] - 7/4/2022 11:08:37 PM + + +## [5.86.1] - 11/11/2022 6:41:15 PM -Commit [86706ce989f8651b79f58dce6cf2511f43fa0629](https://github.com/StoneCypher/jssm/commit/86706ce989f8651b79f58dce6cf2511f43fa0629) +Commit [48b4f928eb1a4597122b64e6eea38a57c19a112f](https://github.com/StoneCypher/jssm/commit/48b4f928eb1a4597122b64e6eea38a57c19a112f) Author: `John Haugeland ` - * First draft of the KSD already caught a bug, removes equals from followup atom characters, fixes StoneCypher/fsl#993 + * Allow override attribute in grammar, fixes StoneCypher/fsl#1226 @@ -154,30 +158,30 @@ Author: `John Haugeland `   -## [Untagged] - 7/3/2022 2:16:27 PM + -Commit [604f0dda3438d81a9209013d77caccc3b89cdd20](https://github.com/StoneCypher/jssm/commit/604f0dda3438d81a9209013d77caccc3b89cdd20) +## [5.86.0] - 11/11/2022 6:22:48 PM + +Commit [31077c9256ee31f80398460b3af95bc65a8dbc3a](https://github.com/StoneCypher/jssm/commit/31077c9256ee31f80398460b3af95bc65a8dbc3a) Author: `John Haugeland ` - * Update typescript, typedoc, and the two typescript-eslint plugins +Merges [793f2fc, 3941c30] + * Merge pull request #547 from StoneCypher/allows_override + * .allows_override fixes StoneCypher/fsl#1224 -    - +  -## [5.75.1] - 7/3/2022 1:49:19 PM +## [Untagged] - 11/11/2022 6:16:32 PM -Commit [bdea50316e8e826af73a4e6ab39f925492328c51](https://github.com/StoneCypher/jssm/commit/bdea50316e8e826af73a4e6ab39f925492328c51) +Commit [3941c3000e8544e6b674b4a060abb93a8f5c3455](https://github.com/StoneCypher/jssm/commit/3941c3000e8544e6b674b4a060abb93a8f5c3455) Author: `John Haugeland ` -Merges [cb76475, f084d51] - - * Merge pull request #507 from StoneCypher/PutClocMetricsInReadme - * Cleanup stuff; suppress warnings about non-exported types, fixes StoneCypher/fsl#988 \ No newline at end of file + * .allows_override fixes StoneCypher/fsl#1224 \ No newline at end of file diff --git a/README.md b/README.md index 646c2e1d..c55442c0 100644 --- a/README.md +++ b/README.md @@ -18,7 +18,7 @@ Please edit the file it's derived from, instead: `./src/md/readme_base.md` -* Generated for version 5.77.0 at 7/7/2022, 11:39:46 AM +* Generated for version 5.87.0 at 12/3/2022, 11:31:57 PM --> # jssm @@ -29,7 +29,7 @@ share online. Easy to embed. Readable, useful state machines as one-liner strings. -***4,664 tests*** run 5,555 times. 4,655 specs with 100.0% coverage, 9 fuzz tests with 5.4% coverage. With 1,722 lines, that's about 2.7 tests per line, or 3.2 generated tests per line. +***4,923 tests*** run 5,814 times. 4,914 specs with 100.0% coverage, 9 fuzz tests with 13.2% coverage. With 2,828 lines, that's about 1.7 tests per line, or 2.1 generated tests per line. ***Meet your new state machine library.*** @@ -425,7 +425,7 @@ looks like HTML in Javascript, that's a DSL. This library implements a simple language for `defining finite state machine`s inside of strings. For example, this `DSL` defines that `'a -> b;'` actually means "create two states, create a transition between them, assign the first as the initial state", et cetera. That micro-language is the `DSL` that we'll be referring to a lot, coming up. This -`DSL`'s formal name is `jssm-dot`, because it's a descendant-in-spirit of an older flowcharting language +`DSL`'s parser's original name was `jssm-dot`, because it's a descendant-in-spirit of an older flowcharting language [DOT](http://www.graphviz.org/content/dot-language), from [graphviz](graphviz.org), which is also used to make the visualizations in [jssm-viz](https://github.com/StoneCypher/jssm-viz) by way of [viz-js](viz-js.com). @@ -551,7 +551,7 @@ Let's load it and use it! 😀 ### An introduction to machine design Let's make a `state machine` for ATMs. In the process, we will use a lot of core concepts of `finite state machine`s -and of `jssm-dot`, this library's `DSL`. +and of `fsl`, this library's `DSL`. We're going to improve on this [NCSU ATM diagram](https://people.engr.ncsu.edu/efg/210/s99/Notes/fsm/atm.gif) that I found: diff --git a/benchmark/results/general.chart.html b/benchmark/results/general.chart.html index b231dd7b..56b25289 100644 --- a/benchmark/results/general.chart.html +++ b/benchmark/results/general.chart.html @@ -28,7 +28,7 @@
- +
Options
All
  • Public
  • Public/Protected
  • All
Menu

Class Machine<mDT>

Type Parameters

  • mDT

Hierarchy

  • Machine

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Properties

_actions

_actions: Map<string, Map<string, number>>

_any_action_hook

_any_action_hook: HookHandler<mDT>

_any_transition_hook

_any_transition_hook: HookHandler<mDT>

_arrange_declaration

_arrange_declaration: string[][]

_arrange_end_declaration

_arrange_end_declaration: string[][]

_arrange_start_declaration

_arrange_start_declaration: string[][]

Optional _data

_data?: mDT

_dot_preamble

_dot_preamble: string

_edge_map

_edge_map: Map<string, Map<string, number>>

_edges

_edges: JssmTransition<mDT>[]

_entry_hooks

_entry_hooks: Map<string, HookHandler<mDT>>

_exit_hooks

_exit_hooks: Map<string, HookHandler<mDT>>

_flow

_flow: FslDirection

_forced_transition_hook

_forced_transition_hook: HookHandler<mDT>

Optional _fsl_version

_fsl_version?: string

_global_action_hooks

_global_action_hooks: Map<string, HookHandler<mDT>>

_graph_layout

_graph_layout: JssmLayout

_has_basic_hooks

_has_basic_hooks: boolean

_has_entry_hooks

_has_entry_hooks: boolean

_has_exit_hooks

_has_exit_hooks: boolean

_has_global_action_hooks

_has_global_action_hooks: boolean

_has_hooks

_has_hooks: boolean

_has_named_hooks

_has_named_hooks: boolean

_has_post_basic_hooks

_has_post_basic_hooks: boolean

_has_post_entry_hooks

_has_post_entry_hooks: boolean

_has_post_exit_hooks

_has_post_exit_hooks: boolean

_has_post_global_action_hooks

_has_post_global_action_hooks: boolean

_has_post_hooks

_has_post_hooks: boolean

_has_post_named_hooks

_has_post_named_hooks: boolean

_has_post_transition_hooks

_has_post_transition_hooks: boolean

_has_transition_hooks

_has_transition_hooks: boolean

_history

_history: circular_buffer<[string, mDT]>

_history_length

_history_length: number

_hooks

_hooks: Map<string, HookHandler<mDT>>

_instance_name

_instance_name: string

Optional _machine_author

_machine_author?: string[]

Optional _machine_comment

_machine_comment?: string

Optional _machine_contributor

_machine_contributor?: string[]

Optional _machine_definition

_machine_definition?: string

Optional _machine_language

_machine_language?: string

Optional _machine_license

_machine_license?: string

Optional _machine_name

_machine_name?: string

Optional _machine_version

_machine_version?: string

_main_transition_hook

_main_transition_hook: HookHandler<mDT>

_named_hooks

_named_hooks: Map<string, HookHandler<mDT>>

_named_transitions

_named_transitions: Map<string, number>

_post_any_action_hook

_post_any_action_hook: HookHandler<mDT>

_post_any_transition_hook

_post_any_transition_hook: HookHandler<mDT>

_post_entry_hooks

_post_entry_hooks: Map<string, HookHandler<mDT>>

_post_exit_hooks

_post_exit_hooks: Map<string, HookHandler<mDT>>

_post_forced_transition_hook

_post_forced_transition_hook: HookHandler<mDT>

_post_global_action_hooks

_post_global_action_hooks: Map<string, HookHandler<mDT>>

_post_hooks

_post_hooks: Map<string, HookHandler<mDT>>

_post_main_transition_hook

_post_main_transition_hook: HookHandler<mDT>

_post_named_hooks

_post_named_hooks: Map<string, HookHandler<mDT>>

_post_standard_transition_hook

_post_standard_transition_hook: HookHandler<mDT>

Optional _raw_state_declaration

_raw_state_declaration?: <internal>.Object[]

_reverse_action_targets

_reverse_action_targets: Map<string, Map<string, number>>

_reverse_actions

_reverse_actions: Map<string, Map<string, number>>

_standard_transition_hook

_standard_transition_hook: HookHandler<mDT>

_state

_state: string

_state_declarations

_state_declarations: Map<string, JssmStateDeclaration>

_states

_states: Map<string, JssmGenericState>

_theme

_theme: FslTheme

Accessors

history

  • get history(): [string, mDT][]

actions

  • actions(whichState?: string): string[]

  • List all actions available from this state. Please note that the order of the actions is not guaranteed.

    import { sm } from 'jssm';

    const machine = sm`
      red 'next' -> green 'next' -> yellow 'next' -> red;
      [red yellow green] 'shutdown' ~> off 'start' -> red;
    `;

    console.log( machine.state() );    // logs 'red'
    console.log( machine.actions() );  // logs ['next', 'shutdown']

    machine.action('next');            // true
    console.log( machine.state() );    // logs 'green'
    console.log( machine.actions() );  // logs ['next', 'shutdown']

    machine.action('shutdown');        // true
    console.log( machine.state() );    // logs 'off'
    console.log( machine.actions() );  // logs ['start']

    machine.action('start');           // true
    console.log( machine.state() );    // logs 'red'
    console.log( machine.actions() );  // logs ['next', 'shutdown']

    Parameters

    • whichState: string = ...

      The state whose actions to have listed

      -

    Returns string[]

current_action_edge_for

current_action_for

  • current_action_for(action: string): number

data

  • data(): mDT

Returns string[]

all_themes

  • all_themes(): ("default" | "modern" | "ocean" | "bold" | "plain")[]

current_action_edge_for

current_action_for

  • current_action_for(action: string): number

data

  • data(): mDT

  • Get the current data of a machine.

    -
    import * as jssm from 'jssm';

    const switch = jssm.from('on <=> off;', {data: 1});
    console.log( switch.data() );              // 1
+
    import * as jssm from 'jssm';

    const lswitch = jssm.from('on <=> off;', {data: 1});
    console.log( lswitch.data() );              // 1
+
    +

    Returns mDT

display_text

  • display_text(state: string): string
  • +

    Get whatever the node should show as text.

    +

    Currently, this means to get the label for a given state, if any; + otherwise to return the node's name. However, this definition is expected + to grow with time, and it is currently considered ill-advised to manually + parse this text.

    +

    See also label_for.

    +
    import * as jssm from 'jssm';

    const lswitch = jssm.from('a -> b; state a: { label: "Foo!"; };');
    console.log( lswitch.display_text('a') );              // 'Foo!'
    console.log( lswitch.display_text('b') );              // 'b'
    -

    Returns mDT

dot_preamble

  • dot_preamble(): string

edges_between

flow

force_transition

  • force_transition(newState: string, newData?: mDT): boolean

do

  • do(actionName: string, newData?: mDT): boolean
  • +

    Instruct the machine to complete an action. Synonym for action.

    +
    const light = sm`
      off 'start' -> red;
      red 'next' -> green 'next' -> yellow 'next' -> red;
      [red yellow green] 'shutdown' ~> off;
    `;

    light.state();       // 'off'
    light.do('start');   // true
    light.state();       // 'red'
    light.do('next');    // true
    light.state();       // 'green'
    light.do('next');    // true
    light.state();       // 'yellow'
    light.do('dance');   // !! false - no such action
    light.state();       // 'yellow'
    light.do('start');   // !! false - yellow does not have the action start
    light.state();       // 'yellow'
+
    +

    Parameters

    • actionName: string
      +

      The action to engage

      +
    • Optional newData: mDT
      +

      The data change to insert during the action

      +

    Returns boolean

dot_preamble

  • dot_preamble(): string

edges_between

  • edges_between(from: string, to: string): JssmTransition<string, mDT>[]

flow

  • flow(): "up" | "right" | "down" | "left"

force_transition

  • force_transition(newState: string, newData?: mDT): boolean

  • Instruct the machine to complete a forced transition (which will reject if called with a normal transition call.)

    const light = sm`red -> green -> yellow -> red; [red yellow green] 'shutdown' ~> off 'start' -> red;`;

    light.state();                     // 'red'
    light.transition('off');           // false
    light.state();                     // 'red'
    light.force_transition('off');     // true
    light.state();                     // 'off'
@@ -59,43 +132,87 @@
 
    The state to switch to
  • Optional newData: mDT

    The data change to insert during the transition

    -

Returns boolean

fsl_version

  • fsl_version(): string

get_transition_by_state_names

  • get_transition_by_state_names(from: string, to: string): number

graph_layout

  • graph_layout(): string

has_completes

  • has_completes(): boolean

has_state

  • has_state(whichState: string): boolean

Returns boolean

fsl_version

  • fsl_version(): string

get_transition_by_state_names

  • get_transition_by_state_names(from: string, to: string): number

go

  • go(newState: string, newData?: mDT): boolean
  • +

    Instruct the machine to complete a transition. Synonym for transition.

    +
    const light = sm`red -> green -> yellow -> red; [red yellow green] 'shutdown' ~> off 'start' -> red;`;

    light.state();       // 'red'
    light.go('green');   // true
    light.state();       // 'green'
+
    +

    Parameters

    • newState: string
      +

      The state to switch to

      +
    • Optional newData: mDT
      +

      The data change to insert during the transition

      +

    Returns boolean

graph_layout

  • graph_layout(): string

has_completes

  • has_completes(): boolean

has_state

  • has_state(whichState: string): boolean

  • Check whether the machine knows a given state.

    -
    import * as jssm from 'jssm';

    const switch = jssm.from('on <=> off;');

    console.log( switch.has_state('off') );     // true
    console.log( switch.has_state('dance') );   // false
+
    import * as jssm from 'jssm';

    const lswitch = jssm.from('on <=> off;');

    console.log( lswitch.has_state('off') );     // true
    console.log( lswitch.has_state('dance') );   // false

    Parameters

    • whichState: string

      The state to be checked for extance

      -

    Returns boolean

has_terminals

  • has_terminals(): boolean

has_unenterables

  • has_unenterables(): boolean

hook

hook_action

  • hook_action(from: string, to: string, action: string, handler: HookHandler<mDT>): Machine<mDT>

hook_any_action

hook_any_transition

hook_entry

hook_exit

hook_forced_transition

hook_global_action

hook_main_transition

hook_standard_transition

instance_name

  • instance_name(): string

is_complete

  • is_complete(): boolean

is_final

  • is_final(): boolean

Returns boolean

has_terminals

  • has_terminals(): boolean

has_unenterables

  • has_unenterables(): boolean

hook

hook_action

  • hook_action(from: string, to: string, action: string, handler: HookHandler<mDT>): Machine<mDT>

hook_any_action

hook_any_transition

hook_entry

hook_exit

hook_forced_transition

hook_global_action

hook_main_transition

hook_standard_transition

instance_name

  • instance_name(): string

is_complete

  • is_complete(): boolean

is_end_state

  • is_end_state(whichState: string): boolean
  • +

    Check whether a given state is a valid start state (either because it was + explicitly named as such, or because it was the first mentioned state.)

    +
    import { sm, is_end_state } from 'jssm';

    const example = sm`a -> b;`;

    console.log( final_test.is_start_state('a') );   // false
    console.log( final_test.is_start_state('b') );   // true

    const example = sm`end_states: [a b]; a -> b;`;

    console.log( final_test.is_start_state('a') );   // true
    console.log( final_test.is_start_state('b') );   // true
+
    +

    Parameters

    • whichState: string
      +

      The name of the state to check

      +

    Returns boolean

is_final

  • is_final(): boolean

  • Check whether the current state is final (either has no exits or is marked complete.)

    -
    import { sm, state_is_final } from 'jssm';

    const final_test = sm`first -> second;`;

    console.log( final_test.is_final() );   // false
    state.transition('second');
    console.log( final_test.is_final() );   // true
+
    import { sm, is_final } from 'jssm';

    const final_test = sm`first -> second;`;

    console.log( final_test.is_final() );   // false
    state.transition('second');
    console.log( final_test.is_final() );   // true
+
    +

    Returns boolean

is_start_state

  • is_start_state(whichState: string): boolean
  • +

    Check whether a given state is a valid start state (either because it was + explicitly named as such, or because it was the first mentioned state.)

    +
    import { sm, is_start_state } from 'jssm';

    const example = sm`a -> b;`;

    console.log( final_test.is_start_state('a') );   // true
    console.log( final_test.is_start_state('b') );   // false

    const example = sm`start_states: [a b]; a -> b;`;

    console.log( final_test.is_start_state('a') );   // true
    console.log( final_test.is_start_state('b') );   // true
+
    +

    Parameters

    • whichState: string
      +

      The name of the state to check

      +

    Returns boolean

is_terminal

  • is_terminal(): boolean

is_unenterable

  • is_unenterable(whichState: string): boolean

known_prop

  • known_prop(prop_name: string): boolean
  • +

    Check whether a given string is a known property's name.

    +
    const example = sm`property foo default 1; a->b;`;

    example.known_prop('foo');  // true
    example.known_prop('bar');  // false
+
    +

    Parameters

    • prop_name: string
      +

      The relevant property name to look up

      +

    Returns boolean

known_props

  • known_props(): string[]
  • +

    List all known property names. If you'd also like values, use + props instead. The order of the properties is not defined, and + the properties generally will not be sorted.

    +
    -

    Returns boolean

is_terminal

  • is_terminal(): boolean

is_unenterable

  • is_unenterable(whichState: string): boolean

list_actions

  • list_actions(): string[]

list_edges

label_for

  • label_for(state: string): string
  • +

    Get the label for a given state, if any; return undefined otherwise.

    +
    import * as jssm from 'jssm';

    const lswitch = jssm.from('a -> b; state a: { label: "Foo!"; };');
    console.log( lswitch.label_for('a') );              // 'Foo!'
    console.log( lswitch.label_for('b') );              // undefined
+
    +

    See also display_text.

    +

    Parameters

    • state: string

    Returns string

list_actions

  • list_actions(): string[]

list_edges

  • Lists all edges of a machine.

    import { sm } from 'jssm';

    const lswitch = sm`on 'toggle' <=> 'toggle' off;`;

    lswitch.list_edges();
    [
      {
        from: 'on',
        to: 'off',
        kind: 'main',
        forced_only: false,
        main_path: true,
        action: 'toggle'
      },
      {
        from: 'off',
        to: 'on',
        kind: 'main',
        forced_only: false,
        main_path: true,
        action: 'toggle'
      }
    ]
    -

    Returns JssmTransition<mDT>[]

list_entrances

  • list_entrances(whichState?: string): string[]

list_entrances

  • list_entrances(whichState?: string): string[]

  • List all entrances attached to the current state. Please note that the - order of the list is not defined.

    + order of the list is not defined. This list includes both unforced and + forced entrances; if this isn't desired, consider + {@link list_unforced_entrances} or {@link list_forced_entrances} as + appropriate.

    import { sm } from 'jssm';

    const light = sm`red 'next' -> green 'next' -> yellow 'next' -> red; [red yellow green] 'shutdown' ~> off 'start' -> red;`;

    light.state();               // 'red'
    light.list_entrances();      // [ 'yellow', 'off' ]

    Parameters

    • whichState: string = ...

      The state whose entrances to have listed

      -

    Returns string[]

list_exit_actions

  • list_exit_actions(whichState?: string): string[]

list_exits

  • list_exits(whichState?: string): string[]

Returns string[]

list_exit_actions

  • list_exit_actions(whichState?: string): string[]

list_exits

  • list_exits(whichState?: string): string[]

  • List all exits attached to the current state. Please note that the order - of the list is not defined.

    + of the list is not defined. This list includes both unforced and forced + exits; if this isn't desired, consider {@link list_unforced_exits} or + {@link list_forced_exits} as appropriate.

    import { sm } from 'jssm';

    const light = sm`red 'next' -> green 'next' -> yellow 'next' -> red; [red yellow green] 'shutdown' ~> off 'start' -> red;`;

    light.state();               // 'red'
    light.list_exits();          // [ 'green', 'off' ]

    Parameters

    • whichState: string = ...

      The state whose exits to have listed

      -

    Returns string[]

list_named_transitions

  • list_named_transitions(): Map<string, number>

list_states_having_action

  • list_states_having_action(whichState: string): string[]

Returns string[]

list_named_transitions

  • list_named_transitions(): Map<string, number>

list_states_having_action

  • list_states_having_action(whichState: string): string[]

  • List all states that have a specific action attached. Please note that the order of the states is not guaranteed.

    import { sm } from 'jssm';

    const machine = sm`
      red 'next' -> green 'next' -> yellow 'next' -> red;
      [red yellow green] 'shutdown' ~> off 'start' -> red;
    `;

    console.log( machine.list_states_having_action('next') );    // ['red', 'green', 'yellow']
    console.log( machine.list_states_having_action('start') );   // ['off']

    Parameters

    • whichState: string

      The action to be checked for associated states

      -

    Returns string[]

list_transitions

Returns string[]

list_transitions

  • List all transitions attached to the current state, sorted by entrance and exit. The order of each sublist is not defined. A node could appear in both lists.

    @@ -103,28 +220,73 @@

    Parameters

    • whichState: string = ...

      The state whose transitions to have listed

      -

    Returns JssmTransitionList

lookup_transition_for

machine_author

  • machine_author(): string[]

machine_comment

  • machine_comment(): string

machine_contributor

  • machine_contributor(): string[]

machine_definition

  • machine_definition(): string

machine_language

  • machine_language(): string

machine_license

  • machine_license(): string

machine_name

  • machine_name(): string

machine_state

machine_version

  • machine_version(): string

post_hook

post_hook_action

  • post_hook_action(from: string, to: string, action: string, handler: HookHandler<mDT>): Machine<mDT>

post_hook_any_action

post_hook_any_transition

post_hook_entry

post_hook_exit

post_hook_forced_transition

post_hook_global_action

post_hook_main_transition

post_hook_standard_transition

probabilistic_histo_walk

  • probabilistic_histo_walk(n: number): Map<string, number>

probabilistic_transition

  • probabilistic_transition(): boolean

probabilistic_walk

  • probabilistic_walk(n: number): string[]

probable_action_exits

  • probable_action_exits(whichState?: string): any[]

probable_exits_for

raw_state_declarations

set_hook

sm

state

  • state(): string

Returns JssmTransitionList

lookup_transition_for

  • lookup_transition_for(from: string, to: string): JssmTransition<string, mDT>

machine_author

  • machine_author(): string[]

machine_comment

  • machine_comment(): string

machine_contributor

  • machine_contributor(): string[]

machine_definition

  • machine_definition(): string

machine_language

  • machine_language(): string

machine_license

  • machine_license(): string

machine_name

  • machine_name(): string

machine_state

machine_version

  • machine_version(): string

override

  • override(newState: string, newData?: mDT): void
  • +

    Replace the current state and data with no regard to the graph.

    +
    import { sm } from 'jssm';

    const machine = sm`a -> b -> c;`;
    console.log( machine.state() );    // 'a'

    machine.go('b');
    machine.go('c');
    console.log( machine.state() );    // 'c'

    machine.override('a');
    console.log( machine.state() );    // 'a'
+
    +

    Parameters

    • newState: string
    • Optional newData: mDT

    Returns void

post_hook

post_hook_action

  • post_hook_action(from: string, to: string, action: string, handler: HookHandler<mDT>): Machine<mDT>

post_hook_any_action

post_hook_any_transition

post_hook_entry

post_hook_exit

post_hook_forced_transition

post_hook_global_action

post_hook_main_transition

post_hook_standard_transition

probabilistic_histo_walk

  • probabilistic_histo_walk(n: number): Map<string, number>

probabilistic_transition

  • probabilistic_transition(): boolean

probabilistic_walk

  • probabilistic_walk(n: number): string[]

probable_action_exits

  • probable_action_exits(whichState?: string): any[]

probable_exits_for

prop

  • prop(name: string): any
  • +

    Get the current value of a given property name.

    +
    
+
    +

    Parameters

    • name: string
      +

      The relevant property name to look up

      +

    Returns any

    The value behind the prop name. Because functional props are + evaluated as getters, this can be anything.

    +

props

  • props(): object
  • +

    Get the current value of every prop, as an object. If no current definition + exists for a prop - that is, if the prop was defined without a default and + the current state also doesn't define the prop - then that prop will be listed + in the returned object with a value of undefined.

    +
    const traffic_light = sm`

      property can_go     default true;
      property hesitate   default true;
      property stop_first default false;

      Off -> Red => Green => Yellow => Red;
      [Red Yellow Green] ~> [Off FlashingRed];
      FlashingRed -> Red;

      state Red:         { property stop_first true;  property can_go false; };
      state Off:         { property stop_first true;  };
      state FlashingRed: { property stop_first true;  };
      state Green:       { property hesitate   false; };

    `;

    traffic_light.state();  // Off
    traffic_light.props();  // { can_go: true,  hesitate: true,  stop_first: true;  }

    traffic_light.go('Red');
    traffic_light.props();  // { can_go: false, hesitate: true,  stop_first: true;  }

    traffic_light.go('Green');
    traffic_light.props();  // { can_go: true,  hesitate: false, stop_first: false; }
+
    +

    Returns object

raw_state_declarations

serialize

  • +

    Serialize the current machine, including all defining state but not the + machine string, to a structure. This means you will need the machine + string to recreate (to not waste repeated space;) if you want the machine + string embedded, call {@link serialize_with_string} instead.

    +

    Parameters

    • Optional comment: string

    Returns JssmSerialization<mDT>

set_hook

sm

state

  • state(): string

  • Get the current state of a machine.

    -
    import * as jssm from 'jssm';

    const switch = jssm.from('on <=> off;');
    console.log( switch.state() );             // 'on'

    switch.transition('off');
    console.log( switch.state() );             // 'off'
+
    import * as jssm from 'jssm';

    const lswitch = jssm.from('on <=> off;');
    console.log( lswitch.state() );             // 'on'

    lswitch.transition('off');
    console.log( lswitch.state() );             // 'off'
    -

    Returns string

state_declaration

state_declarations

state_for

state_is_complete

  • state_is_complete(whichState: string): boolean

state_is_final

  • state_is_final(whichState: string): boolean

state_declaration

state_declarations

state_for

state_is_complete

  • state_is_complete(whichState: string): boolean

state_is_final

  • state_is_final(whichState: string): boolean

  • Check whether a given state is final (either has no exits or is marked complete.)

    import { sm, state_is_final } from 'jssm';

    const final_test = sm`first -> second;`;

    console.log( final_test.state_is_final('first') );   // false
    console.log( final_test.state_is_final('second') );  // true

    Parameters

    • whichState: string

      The name of the state to check for finality

      -

    Returns boolean

state_is_terminal

  • state_is_terminal(whichState: string): boolean

states

  • states(): string[]

Returns boolean

state_is_terminal

  • state_is_terminal(whichState: string): boolean

states

  • states(): string[]

  • List all the states known by the machine. Please note that the order of these states is not guaranteed.

    -
    import * as jssm from 'jssm';

    const switch = jssm.from('on <=> off;');
    console.log( switch.states() );             // ['on', 'off']
+
    import * as jssm from 'jssm';

    const lswitch = jssm.from('on <=> off;');
    console.log( lswitch.states() );             // ['on', 'off']
+
    +

    Returns string[]

strict_prop

  • strict_prop(name: string): any
  • +

    Get the current value of a given property name. If missing on the state + and without a global default, throw, unlike prop, which would + return undefined instead.

    +
    -

    Returns string[]

theme

transition

  • transition(newState: string, newData?: mDT): boolean
  • -

    Instruct the machine to complete a transition.

    -
    const light = sm`red -> green -> yellow -> red; [red yellow green] 'shutdown' ~> off 'start' -> red;`;

    light.state();               // 'red'
    light.transition('green');   // true
    light.state();               // 'green'
+

    Parameters

    • name: string
      +

      The relevant property name to look up

      +

    Returns any

    The value behind the prop name. Because functional props are + evaluated as getters, this can be anything.

    +

style_for

  • +

    Gets the composite style for a specific node by individually imposing the + style layers on a given object, after determining which layers are + appropriate.

    +

    The order of composition is base, then theme, then user content. Each + item in the stack will be composited independently. First, the base state + style, then the theme state style, then the user state style.

    +

    After the three state styles, we'll composite the hooked styles; then the + terminal styles; then the start styles; then the end styles; finally, the + active styles. Remember, last wins.

    +

    The base state style must exist. All other styles are optional.

    +

    Parameters

    • state: string

    Returns Partial<JssmStateDeclaration>

transition

  • transition(newState: string, newData?: mDT): boolean
  • +

    Instruct the machine to complete a transition. Synonym for go.

    +
    const light = sm`
      off 'start' -> red;
      red 'next' -> green 'next' -> yellow 'next' -> red;
      [red yellow green] 'shutdown' ~> off;
    `;

    light.state();       // 'off'
    light.go('red');     // true
    light.state();       // 'red'
    light.go('green');   // true
    light.state();       // 'green'
    light.go('blue');    // !! false - no such state
    light.state();       // 'green'
    light.go('red');     // !! false - green may not go directly to red, only to yellow
    light.state();       // 'green'

    Parameters

    • newState: string

      The state to switch to

    • Optional newData: mDT

      The data change to insert during the transition

      -

    Returns boolean

transition_impl

  • transition_impl(newStateOrAction: string, newData: mDT, wasForced: boolean, wasAction: boolean): boolean

  • Parameters

    • newStateOrAction: string
    • newData: mDT
    • wasForced: boolean
    • wasAction: boolean

    Returns boolean

valid_action

  • valid_action(action: string, _newData?: mDT): boolean

valid_force_transition

  • valid_force_transition(newState: string, _newData?: mDT): boolean

valid_transition

  • valid_transition(newState: string, _newData?: mDT): boolean

Generated using TypeDoc

\ No newline at end of file +

Returns boolean

transition_impl

  • transition_impl(newStateOrAction: string, newData: mDT, wasForced: boolean, wasAction: boolean): boolean

  • Parameters

    • newStateOrAction: string
    • newData: mDT
    • wasForced: boolean
    • wasAction: boolean

    Returns boolean

valid_action

  • valid_action(action: string, _newData?: mDT): boolean

valid_force_transition

  • valid_force_transition(newState: string, _newData?: mDT): boolean

valid_transition

  • valid_transition(newState: string, _newData?: mDT): boolean

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter
  • Property
  • Method
  • Accessor

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/classes/jssm._internal_.circular_buffer.html b/docs/docs/classes/jssm._internal_.circular_buffer.html deleted file mode 100644 index b825ee3a..00000000 --- a/docs/docs/classes/jssm._internal_.circular_buffer.html +++ /dev/null @@ -1 +0,0 @@ -circular_buffer | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Class circular_buffer<T>

Type Parameters

  • T

Hierarchy

  • circular_buffer

Index

Constructors

Accessors

Methods

Constructors

constructor

  • Type Parameters

    • T

    Parameters

    • uCapacity: number

    Returns circular_buffer<T>

Accessors

available

  • get available(): number

  • Returns number

capacity

  • get capacity(): number
  • set capacity(newSize: number): void

  • Returns number

  • Parameters

    • newSize: number

    Returns void

first

  • get first(): T

  • Returns T

isEmpty

  • get isEmpty(): boolean

  • Returns boolean

isFull

  • get isFull(): boolean

  • Returns boolean

last

  • get last(): T

  • Returns T

length

  • get length(): number
  • set length(newLength: number): void

  • Returns number

  • Parameters

    • newLength: number

    Returns void

Methods

at

  • at(i: number): T

  • Parameters

    • i: number

    Returns T

clear

  • clear(): T[]

  • Returns T[]

every

  • Parameters

    Returns boolean

fill

  • fill(x: T): T[]

  • Parameters

    • x: T

    Returns T[]

find

  • Parameters

    Returns unknown

indexOf

  • indexOf(searchElement: T, fromIndex?: number): number

  • Parameters

    • searchElement: T
    • Optional fromIndex: number

    Returns number

offset

  • offset(): number

  • Returns number

pop

  • pop(): T

  • Returns T

pos

  • pos(i: number): T

  • Parameters

    • i: number

    Returns T

push

  • push(v: T): T

  • Parameters

    • v: T

    Returns T

resize

  • resize(newSize: number, preferEnd?: boolean): void

  • Parameters

    • newSize: number
    • Optional preferEnd: boolean

    Returns void

reverse

  • Returns circular_buffer<T>

shove

  • shove(v: T): T

  • Parameters

    • v: T

    Returns T

some

  • Parameters

    Returns boolean

toArray

  • toArray(): T[]

  • Returns T[]

Static from

  • Type Parameters

    • T

    Parameters

    • i: Iterable<T> | ArrayLike<T>
    • Optional map_fn: ((_k: T, _i: number) => T)
        • (_k: T, _i: number): T

        • Parameters

          • _k: T
          • _i: number

          Returns T

    • Optional t: unknown

    Returns circular_buffer<T>

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/classes/jssm_error.JssmError.html b/docs/docs/classes/jssm_error.JssmError.html index a8135abb..d8754495 100644 --- a/docs/docs/classes/jssm_error.JssmError.html +++ b/docs/docs/classes/jssm_error.JssmError.html @@ -1,6 +1,6 @@ -JssmError | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Class JssmError

Hierarchy

Index

Constructors

Properties

Methods

Constructors

constructor

Properties

base_message

base_message: string

message

message: string

name

name: string

requested_state

requested_state: string

Optional stack

stack?: string

Static Optional prepareStackTrace

prepareStackTrace?: ((err: <internal>.Error, stackTraces: CallSite[]) => any)

Type declaration

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter
  • Constructor
  • Property

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/classes/jssm_types._internal_.circular_buffer.html b/docs/docs/classes/jssm_types._internal_.circular_buffer.html new file mode 100644 index 00000000..e29f64c2 --- /dev/null +++ b/docs/docs/classes/jssm_types._internal_.circular_buffer.html @@ -0,0 +1 @@ +circular_buffer | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Class circular_buffer<T>

Type Parameters

  • T

Hierarchy

  • circular_buffer

Index

Constructors

Accessors

Methods

Constructors

constructor

  • Type Parameters

    • T

    Parameters

    • uCapacity: number

    Returns circular_buffer<T>

Accessors

available

  • get available(): number

  • Returns number

capacity

  • get capacity(): number
  • set capacity(newSize: number): void

  • Returns number

  • Parameters

    • newSize: number

    Returns void

first

  • get first(): T

  • Returns T

isEmpty

  • get isEmpty(): boolean

  • Returns boolean

isFull

  • get isFull(): boolean

  • Returns boolean

last

  • get last(): T

  • Returns T

length

  • get length(): number
  • set length(newLength: number): void

  • Returns number

  • Parameters

    • newLength: number

    Returns void

Methods

at

  • at(i: number): T

  • Parameters

    • i: number

    Returns T

clear

  • clear(): T[]

  • Returns T[]

every

  • Parameters

    Returns boolean

fill

  • fill(x: T): T[]

  • Parameters

    • x: T

    Returns T[]

find

  • Parameters

    Returns unknown

indexOf

  • indexOf(searchElement: T, fromIndex?: number): number

  • Parameters

    • searchElement: T
    • Optional fromIndex: number

    Returns number

offset

  • offset(): number

  • Returns number

pop

  • pop(): T

  • Returns T

pos

  • pos(i: number): T

  • Parameters

    • i: number

    Returns T

push

  • push(v: T): T

  • Parameters

    • v: T

    Returns T

resize

  • resize(newSize: number, preferEnd?: boolean): void

  • Parameters

    • newSize: number
    • Optional preferEnd: boolean

    Returns void

reverse

  • Returns circular_buffer<T>

shove

  • shove(v: T): T

  • Parameters

    • v: T

    Returns T

some

  • Parameters

    Returns boolean

toArray

  • toArray(): T[]

  • Returns T[]

Static from

  • Type Parameters

    • T

    Parameters

    • i: Iterable<T> | ArrayLike<T>
    • Optional map_fn: ((_k: T, _i: number) => T)
        • (_k: T, _i: number): T

        • Parameters

          • _k: T
          • _i: number

          Returns T

    • Optional t: unknown

    Returns circular_buffer<T>

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/index.html b/docs/docs/index.html index c03e3c10..79f2520a 100644 --- a/docs/docs/index.html +++ b/docs/docs/index.html @@ -115,4 +115,4 @@

High speed

Correct. Easy. Brief. Powerful. Fast.

Meet your new state machine.

Next: Let's get started.

-

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file +

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/interfaces/jssm._internal_.ArrayLike.html b/docs/docs/interfaces/jssm._internal_.ArrayLike.html deleted file mode 100644 index 87c1e38d..00000000 --- a/docs/docs/interfaces/jssm._internal_.ArrayLike.html +++ /dev/null @@ -1 +0,0 @@ -ArrayLike | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Interface ArrayLike<T>

Type Parameters

  • T

Hierarchy

  • ArrayLike

Indexable

[n: number]: T

Index

Properties

Properties

Readonly length

length: number

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/interfaces/jssm._internal_.ConcatArray.html b/docs/docs/interfaces/jssm._internal_.ConcatArray.html index 1ea4bd87..d05e7fc5 100644 --- a/docs/docs/interfaces/jssm._internal_.ConcatArray.html +++ b/docs/docs/interfaces/jssm._internal_.ConcatArray.html @@ -1 +1 @@ -ConcatArray | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Interface ConcatArray<T>

Type Parameters

  • T

Hierarchy

  • ConcatArray

Indexable

[n: number]: T

Index

Properties

Methods

Properties

Readonly length

length: number

Methods

join

  • join(separator?: string): string

  • Parameters

    • Optional separator: string

    Returns string

slice

  • slice(start?: number, end?: number): T[]

  • Parameters

    • Optional start: number
    • Optional end: number

    Returns T[]

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file +ConcatArray | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Interface ConcatArray<T>

Type Parameters

  • T

Hierarchy

  • ConcatArray

Indexable

[n: number]: T

Index

Properties

Methods

Properties

Readonly length

length: number

Methods

join

  • join(separator?: string): string

  • Parameters

    • Optional separator: string

    Returns string

slice

  • slice(start?: number, end?: number): T[]

  • Parameters

    • Optional start: number
    • Optional end: number

    Returns T[]

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/interfaces/jssm._internal_.Iterable.html b/docs/docs/interfaces/jssm._internal_.Iterable.html deleted file mode 100644 index 13cd4c6f..00000000 --- a/docs/docs/interfaces/jssm._internal_.Iterable.html +++ /dev/null @@ -1 +0,0 @@ -Iterable | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Interface Iterable<T>

Type Parameters

  • T

Hierarchy

  • Iterable

Index

Methods

Methods

[iterator]

  • [iterator](): Iterator<T, any, undefined>

  • Returns Iterator<T, any, undefined>

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/interfaces/jssm._internal_.IterableIterator.html b/docs/docs/interfaces/jssm._internal_.IterableIterator.html index 5ef22d7a..26a1b3fc 100644 --- a/docs/docs/interfaces/jssm._internal_.IterableIterator.html +++ b/docs/docs/interfaces/jssm._internal_.IterableIterator.html @@ -1 +1 @@ -IterableIterator | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Interface IterableIterator<T>

Type Parameters

  • T

Hierarchy

Index

Methods

Methods

[iterator]

  • Returns IterableIterator<T>

next

  • Parameters

    • Rest ...args: [] | [undefined]

    Returns IteratorResult<T, any>

Optional return

  • Parameters

    • Optional value: any

    Returns IteratorResult<T, any>

Optional throw

  • Parameters

    • Optional e: any

    Returns IteratorResult<T, any>

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file +IterableIterator | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Interface IterableIterator<T>

Type Parameters

  • T

Hierarchy

Index

Methods

Methods

[iterator]

  • Returns IterableIterator<T>

next

  • Parameters

    • Rest ...args: [] | [undefined]

    Returns IteratorResult<T, any>

Optional return

  • Parameters

    • Optional value: any

    Returns IteratorResult<T, any>

Optional throw

  • Parameters

    • Optional e: any

    Returns IteratorResult<T, any>

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/interfaces/jssm._internal_.Iterator.html b/docs/docs/interfaces/jssm._internal_.Iterator.html index 42e35280..81058768 100644 --- a/docs/docs/interfaces/jssm._internal_.Iterator.html +++ b/docs/docs/interfaces/jssm._internal_.Iterator.html @@ -1 +1 @@ -Iterator | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Interface Iterator<T, TReturn, TNext>

Type Parameters

  • T

  • TReturn = any

  • TNext = undefined

Hierarchy

Index

Methods

Methods

next

  • Parameters

    • Rest ...args: [] | [TNext]

    Returns IteratorResult<T, TReturn>

Optional return

  • Parameters

    • Optional value: TReturn

    Returns IteratorResult<T, TReturn>

Optional throw

  • Parameters

    • Optional e: any

    Returns IteratorResult<T, TReturn>

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file +Iterator | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Interface Iterator<T, TReturn, TNext>

Type Parameters

  • T

  • TReturn = any

  • TNext = undefined

Hierarchy

Index

Methods

Methods

next

  • Parameters

    • Rest ...args: [] | [TNext]

    Returns IteratorResult<T, TReturn>

Optional return

  • Parameters

    • Optional value: TReturn

    Returns IteratorResult<T, TReturn>

Optional throw

  • Parameters

    • Optional e: any

    Returns IteratorResult<T, TReturn>

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/interfaces/jssm._internal_.IteratorReturnResult.html b/docs/docs/interfaces/jssm._internal_.IteratorReturnResult.html index ecf37702..d0cf5688 100644 --- a/docs/docs/interfaces/jssm._internal_.IteratorReturnResult.html +++ b/docs/docs/interfaces/jssm._internal_.IteratorReturnResult.html @@ -1 +1 @@ -IteratorReturnResult | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Interface IteratorReturnResult<TReturn>

Type Parameters

  • TReturn

Hierarchy

  • IteratorReturnResult

Index

Properties

Properties

done

done: true

value

value: TReturn

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file +IteratorReturnResult | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Interface IteratorReturnResult<TReturn>

Type Parameters

  • TReturn

Hierarchy

  • IteratorReturnResult

Index

Properties

Properties

done

done: true

value

value: TReturn

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/interfaces/jssm._internal_.IteratorYieldResult.html b/docs/docs/interfaces/jssm._internal_.IteratorYieldResult.html index e13cfca4..77c2a891 100644 --- a/docs/docs/interfaces/jssm._internal_.IteratorYieldResult.html +++ b/docs/docs/interfaces/jssm._internal_.IteratorYieldResult.html @@ -1 +1 @@ -IteratorYieldResult | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Interface IteratorYieldResult<TYield>

Type Parameters

  • TYield

Hierarchy

  • IteratorYieldResult

Index

Properties

Properties

Optional done

done?: false

value

value: TYield

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file +IteratorYieldResult | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Interface IteratorYieldResult<TYield>

Type Parameters

  • TYield

Hierarchy

  • IteratorYieldResult

Index

Properties

Properties

Optional done

done?: false

value

value: TYield

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/interfaces/jssm._internal_.Object.html b/docs/docs/interfaces/jssm._internal_.Object.html index dd8e5541..b04c890d 100644 --- a/docs/docs/interfaces/jssm._internal_.Object.html +++ b/docs/docs/interfaces/jssm._internal_.Object.html @@ -18,4 +18,4 @@

Returns a string representation of an object.

Returns string

valueOf

  • Returns the primitive value of the specified object.

    -

    Returns <internal>.Object

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file +

Returns <internal>.Object

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/interfaces/jssm._internal_.TemplateStringsArray.html b/docs/docs/interfaces/jssm._internal_.TemplateStringsArray.html index b76314df..2aff2d79 100644 --- a/docs/docs/interfaces/jssm._internal_.TemplateStringsArray.html +++ b/docs/docs/interfaces/jssm._internal_.TemplateStringsArray.html @@ -154,4 +154,4 @@

Returns a string representation of an array.

Returns string

values

  • Returns an iterable of values in the array

    -

    Returns IterableIterator<string>

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file +

Returns IterableIterator<string>

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/interfaces/jssm_error._internal_.CallSite.html b/docs/docs/interfaces/jssm_error._internal_.CallSite.html index b640bebd..749d6476 100644 --- a/docs/docs/interfaces/jssm_error._internal_.CallSite.html +++ b/docs/docs/interfaces/jssm_error._internal_.CallSite.html @@ -31,4 +31,4 @@

Is this call in native V8 code?

Returns boolean

isToplevel

  • isToplevel(): boolean

  • Is this a toplevel invocation, that is, is "this" the global object?

    -

    Returns boolean

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file +

Returns boolean

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/interfaces/jssm_error._internal_.Error.html b/docs/docs/interfaces/jssm_error._internal_.Error.html index a3d08247..a29d55ae 100644 --- a/docs/docs/interfaces/jssm_error._internal_.Error.html +++ b/docs/docs/interfaces/jssm_error._internal_.Error.html @@ -1 +1 @@ -Error | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Interface Error

Hierarchy

  • Error

Index

Properties

Properties

message

message: string

name

name: string

Optional stack

stack?: string

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file +Error | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Interface Error

Hierarchy

  • Error

Index

Properties

Properties

message

message: string

name

name: string

Optional stack

stack?: string

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/interfaces/jssm_types._internal_.ArrayLike.html b/docs/docs/interfaces/jssm_types._internal_.ArrayLike.html new file mode 100644 index 00000000..3871597b --- /dev/null +++ b/docs/docs/interfaces/jssm_types._internal_.ArrayLike.html @@ -0,0 +1 @@ +ArrayLike | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Interface ArrayLike<T>

Type Parameters

  • T

Hierarchy

  • ArrayLike

Indexable

[n: number]: T

Index

Properties

Properties

Readonly length

length: number

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/interfaces/jssm_types._internal_.Iterable.html b/docs/docs/interfaces/jssm_types._internal_.Iterable.html new file mode 100644 index 00000000..8d4a1ede --- /dev/null +++ b/docs/docs/interfaces/jssm_types._internal_.Iterable.html @@ -0,0 +1 @@ +Iterable | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Interface Iterable<T>

Type Parameters

  • T

Hierarchy

  • Iterable

Index

Methods

Methods

[iterator]

  • [iterator](): Iterator<T, any, undefined>

  • Returns Iterator<T, any, undefined>

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/modules.html b/docs/docs/modules.html index af99dc07..3358c469 100644 --- a/docs/docs/modules.html +++ b/docs/docs/modules.html @@ -1 +1 @@ -JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

JSSM, a JavaScript state machine - the FSM for FSL

Index

Modules

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file +JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

JSSM, a JavaScript state machine - the FSM for FSL

Index

Modules

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/modules/jssm._internal_.html b/docs/docs/modules/jssm._internal_.html index 914f8a42..b032ec20 100644 --- a/docs/docs/modules/jssm._internal_.html +++ b/docs/docs/modules/jssm._internal_.html @@ -1,5 +1,5 @@ -<internal> | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Namespace <internal>

Index

Classes

Interfaces

Type Aliases

Variables

Type Aliases

FlatArray

FlatArray<Arr, Depth>: { done: Arr; recur: Arr extends ReadonlyArray<infer InnerArr> ? FlatArray<InnerArr, [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20][Depth]> : Arr }[Depth extends -1 ? "done" : "recur"]

Type Parameters

  • Arr

  • Depth extends number

IteratorResult

IteratorResult<T, TReturn>: IteratorYieldResult<T> | IteratorReturnResult<TReturn>

Type Parameters

  • T

  • TReturn = any

Partial

Partial<T>: { [ P in keyof T]?: T[P] }
+<internal> | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Namespace <internal>

Index

Interfaces

Type Aliases

Variables

Type Aliases

FlatArray

FlatArray<Arr, Depth>: { done: Arr; recur: Arr extends ReadonlyArray<infer InnerArr> ? FlatArray<InnerArr, [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20][Depth]> : Arr }[Depth extends -1 ? "done" : "recur"]

Type Parameters

  • Arr

  • Depth extends number

IteratorResult

IteratorResult<T, TReturn>: IteratorYieldResult<T> | IteratorReturnResult<TReturn>

Type Parameters

  • T

  • TReturn = any

Partial

Partial<T>: { [ P in keyof T]?: T[P] }

Make all properties in T optional

-

Type Parameters

  • T

PropertyKey

PropertyKey: string | number | symbol

TraversalFunctor

TraversalFunctor<T>: ((_element: T, _index?: number, _array?: T[]) => unknown)

Type Parameters

  • T

Type declaration

    • (_element: T, _index?: number, _array?: T[]): unknown

    • Parameters

      • _element: T
      • Optional _index: number
      • Optional _array: T[]

      Returns unknown

Variables

Object

Object: ObjectConstructor
+

Type Parameters

  • T

PropertyKey

PropertyKey: string | number | symbol

Variables

Object

Object: ObjectConstructor

Provides functionality common to all JavaScript objects.

-

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file +

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/modules/jssm.html b/docs/docs/modules/jssm.html index 5bb41eb5..65f2cfd1 100644 --- a/docs/docs/modules/jssm.html +++ b/docs/docs/modules/jssm.html @@ -1,22 +1,22 @@ -jssm | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Module jssm

Index

References

Namespaces

Classes

Functions

References

gviz_shapes

Re-exports gviz_shapes

histograph

Re-exports histograph

named_colors

Re-exports named_colors

seq

Re-exports seq

shapes

Re-exports shapes

version

Re-exports version

weighted_histo_key

Re-exports weighted_histo_key

weighted_rand_select

Re-exports weighted_rand_select

weighted_sample_select

Re-exports weighted_sample_select

Functions

abstract_hook_step

arrow_direction

arrow_left_kind

  • Return the direction of an arrow - right, left, or both.

    import { arrow_left_kind } from 'jssm';

    arrow_left_kind('<-');    // 'legal'
    arrow_left_kind('<=');    // 'main'
    arrow_left_kind('<~');    // 'forced'
    arrow_left_kind('<->');   // 'legal'
    arrow_left_kind('->');    // 'none'

    Parameters

    Returns JssmArrowKind

arrow_right_kind

Returns JssmArrowKind

arrow_right_kind

  • Return the direction of an arrow - right, left, or both.

    import { arrow_left_kind } from 'jssm';

    arrow_left_kind('->');    // 'legal'
    arrow_left_kind('=>');    // 'main'
    arrow_left_kind('~>');    // 'forced'
    arrow_left_kind('<->');   // 'legal'
    arrow_left_kind('<-');    // 'none'

    Parameters

    Returns JssmArrowKind

compile

Returns JssmArrowKind

compile

  • Compile a machine's JSON intermediate representation to a config object. If you're using this (probably don't,) you're probably also using parse to get the IR, and the object constructor @@ -34,38 +34,38 @@

    Hey!

    operator sm, and mostly falls back to .from when needing to parse strings dynamically instead of from template literals.

    Operator sm:

    -
    import { sm } from 'jssm';

    const switch = sm`on <=> off;`;
+
    import { sm } from 'jssm';

    const lswitch = sm`on <=> off;`;
 
    
 
     Method from:
    
 
    import * as jssm from 'jssm';

    const toggle = jssm.from('up <=> down;');
 
    
-

    Type Parameters

    • mDT

      +

      Type Parameters

      • StateType

      • mDT

        The type of the machine data member; usually omitted

        -

      Parameters

      Parameters

      • tree: JssmParseTree<StateType, mDT>

        The parse tree to be boiled down into a machine config

        -

      Returns JssmGenericConfig<mDT>

from

Returns JssmGenericConfig<StateType, mDT>

deserialize

from

  • Create a state machine from an implementation string. This is one of the two main paths for working with JSSM, alongside sm.

    Use this method when you want to conveniently pull a state machine from a string dynamically. Use operator sm when you just want to work with a template expression.

    -
    import * as jssm from 'jssm';

    const switch = jssm.from('on <=> off;');
+
    import * as jssm from 'jssm';

    const lswitch = jssm.from('on <=> off;');

    Type Parameters

    • mDT

      The type of the machine data member; usually omitted

    Parameters

    • MachineAsString: string

      The FSL code to evaluate

      -
    • Optional ExtraConstructorFields: Partial<JssmGenericConfig<mDT>>
      +
    • Optional ExtraConstructorFields: Partial<JssmGenericConfig<string, mDT>>

      Extra non-code configuration to pass at creation time

      -

    Returns Machine<mDT>

is_hook_complex_result

is_hook_rejection

  • is_hook_rejection<mDT>(hr: HookResult<mDT>): boolean

make

Returns Machine<mDT>

is_hook_complex_result

is_hook_rejection

  • is_hook_rejection<mDT>(hr: HookResult<mDT>): boolean

make

  • An internal convenience wrapper for parsing then compiling a machine string. Not generally meant for external use. Please see compile or sm.

    -

    Type Parameters

    • mDT

      +

      Type Parameters

      • StateType

      • mDT

        The type of the machine data member; usually omitted

      Parameters

      • plan: string

        The FSL code to be evaluated and built into a machine config

        -

      Returns JssmGenericConfig<mDT>

parse

Returns JssmGenericConfig<StateType, mDT>

parse

  • This method wraps the parser call that comes from the peg grammar, parse. Generally neither this nor that should be used directly unless you mean to develop plugins or extensions for the machine.

    @@ -85,7 +85,7 @@

    Hey!

    operator sm, and mostly falls back to .from when needing to parse strings dynamically instead of from template literals.

    Operator sm:

    -
    import { sm } from 'jssm';

    const switch = sm`on <=> off;`;
+
    import { sm } from 'jssm';

    const lswitch = sm`on <=> off;`;
 
    
 
     Method from:
    
 
    import * as jssm from 'jssm';

    const toggle = jssm.from('up <=> down;');
@@ -96,13 +96,13 @@ 
    Hey!
    
 
    The FSL code to be evaluated
  • Optional options: <internal>.Object

    Things to control about the instance

    -

Returns any

sm

Returns any

sm

  • Create a state machine from a template string. This is one of the two main paths for working with JSSM, alongside from.

    Use this method when you want to work directly and conveniently with a constant template expression. Use .from when you want to pull from dynamic strings.

    -
    import * as jssm from 'jssm';

    const switch = jssm.from('on <=> off;');
+
    import * as jssm from 'jssm';

    const lswitch = jssm.from('on <=> off;');

    Type Parameters

    • mDT

      The type of the machine data member; usually omitted

      @@ -110,8 +110,8 @@

      Hey!

      The assembled code

    • Rest ...remainder: any[]

      The mechanic for template argument insertion

      -

    Returns Machine<mDT>

transfer_state_properties

Returns Machine<mDT>

state_style_condense

transfer_state_properties

  • An internal method meant to take a series of declarations and fold them into a single multi-faceted declaration, in the process of building a state. Not generally meant for external use.

    -
    internal

    Parameters

    Returns JssmStateDeclaration

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file +
internal

Parameters

Returns JssmStateDeclaration

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/modules/jssm_constants.html b/docs/docs/modules/jssm_constants.html index 477e0073..1283c374 100644 --- a/docs/docs/modules/jssm_constants.html +++ b/docs/docs/modules/jssm_constants.html @@ -1 +1 @@ -jssm_constants | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Module jssm_constants

Index

Variables

Variables

Const gviz_shapes

gviz_shapes: string[] = ...

Const named_colors

named_colors: string[] = ...

Const shapes

shapes: string[] = gviz_shapes

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file +jssm_constants | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Module jssm_constants

Index

Variables

Variables

Const E

E: number = Math.E

Const Epsilon

Epsilon: number = Number.EPSILON

Const EulerC

EulerC: 0.5772156649015329 = 0.57721566490153286060

Const Ln10

Ln10: number = Math.LN10

Const Ln2

Ln2: number = Math.LN2

Const Log10E

Log10E: number = Math.LOG10E

Const Log2E

Log2E: number = Math.LOG2E

Const MaxPosNum

MaxPosNum: number = Number.MAX_VALUE

Const MaxSafeInt

MaxSafeInt: number = Number.MAX_SAFE_INTEGER

Const MinPosNum

MinPosNum: number = Number.MIN_VALUE

Const MinSafeInt

MinSafeInt: number = Number.MIN_SAFE_INTEGER

Const NegInfinity

NegInfinity: number = Number.NEGATIVE_INFINITY

Const Phi

Phi: 1.618033988749895 = 1.61803398874989484820

Const Pi

Pi: number = Math.PI

Const PosInfinity

PosInfinity: number = Number.POSITIVE_INFINITY

Const Root2

Root2: number = Math.SQRT2

Const RootHalf

RootHalf: number = Math.SQRT1_2

Const gviz_shapes

gviz_shapes: string[] = ...

Const named_colors

named_colors: string[] = ...

Const shapes

shapes: string[] = gviz_shapes

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/modules/jssm_error._internal_.html b/docs/docs/modules/jssm_error._internal_.html index b90ea182..a813f4f5 100644 --- a/docs/docs/modules/jssm_error._internal_.html +++ b/docs/docs/modules/jssm_error._internal_.html @@ -1 +1 @@ -<internal> | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Namespace <internal>

Index

Interfaces

Variables

Variables

Error

Error: ErrorConstructor

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file +<internal> | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Namespace <internal>

Index

Interfaces

Variables

Variables

Error

Error: ErrorConstructor

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/modules/jssm_error.html b/docs/docs/modules/jssm_error.html index 969360d4..30171670 100644 --- a/docs/docs/modules/jssm_error.html +++ b/docs/docs/modules/jssm_error.html @@ -1 +1 @@ -jssm_error | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Module jssm_error

Index

Namespaces

Classes

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file +jssm_error | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Module jssm_error

Index

Namespaces

Classes

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/modules/jssm_types._internal_.html b/docs/docs/modules/jssm_types._internal_.html index 8cee73da..d6dce591 100644 --- a/docs/docs/modules/jssm_types._internal_.html +++ b/docs/docs/modules/jssm_types._internal_.html @@ -1 +1 @@ -<internal> | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Namespace <internal>

Index

Type Aliases

Type Aliases

AnyActionHook

AnyActionHook<mDT>: { handler: HookHandler<mDT>; kind: "any action" }

Type Parameters

  • mDT

Type declaration

AnyTransitionHook

AnyTransitionHook<mDT>: { handler: HookHandler<mDT>; kind: "any transition" }

Type Parameters

  • mDT

Type declaration

BasicHookDescription

BasicHookDescription<mDT>: { from: string; handler: HookHandler<mDT>; kind: "hook"; to: string }

Type Parameters

  • mDT

Type declaration

  • from: string
  • handler: HookHandler<mDT>
  • kind: "hook"
  • to: string

EntryHook

EntryHook<mDT>: { handler: HookHandler<mDT>; kind: "entry"; to: string }

Type Parameters

  • mDT

Type declaration

ExitHook

ExitHook<mDT>: { from: string; handler: HookHandler<mDT>; kind: "exit" }

Type Parameters

  • mDT

Type declaration

ForcedTransitionHook

ForcedTransitionHook<mDT>: { handler: HookHandler<mDT>; kind: "forced transition" }

Type Parameters

  • mDT

Type declaration

GlobalActionHook

GlobalActionHook<mDT>: { action: string; handler: HookHandler<mDT>; kind: "global action" }

Type Parameters

  • mDT

Type declaration

  • action: string
  • handler: HookHandler<mDT>
  • kind: "global action"

HookDescriptionWithAction

HookDescriptionWithAction<mDT>: { action: string; from: string; handler: HookHandler<mDT>; kind: "named"; to: string }

Type Parameters

  • mDT

Type declaration

  • action: string
  • from: string
  • handler: HookHandler<mDT>
  • kind: "named"
  • to: string

JssmCorner

JssmCorner: "regular" | "rounded" | "lined"

JssmFailure

JssmFailure: { error: any; success: false }

Type declaration

  • error: any
  • success: false

JssmIncomplete

JssmIncomplete: { success: "incomplete" }

Type declaration

  • success: "incomplete"

JssmLineStyle

JssmLineStyle: "solid" | "dashed" | "dotted"

JssmStatePermitter

JssmStatePermitter<DataType>: ((OldState: StateType, NewState: StateType, OldData: DataType, NewData: DataType) => boolean)

Type Parameters

  • DataType

Type declaration

    • Parameters

      Returns boolean

JssmStatePermitterMaybeArray

JssmStatePermitterMaybeArray<DataType>: JssmStatePermitter<DataType> | JssmStatePermitter<DataType>[]

Type Parameters

  • DataType

JssmSuccess

JssmSuccess: { success: true }

Type declaration

  • success: true

JssmTransitionCycle

JssmTransitionCycle: { key: "cycle"; value: StateType }

Type declaration

JssmTransitionPermitter

JssmTransitionPermitter<DataType>: ((OldState: StateType, NewState: StateType, OldData: DataType, NewData: DataType) => boolean)

Type Parameters

  • DataType

Type declaration

    • Parameters

      Returns boolean

JssmTransitionPermitterMaybeArray

JssmTransitionPermitterMaybeArray<DataType>: JssmTransitionPermitter<DataType> | JssmTransitionPermitter<DataType>[]

Type Parameters

  • DataType

MainTransitionHook

MainTransitionHook<mDT>: { handler: HookHandler<mDT>; kind: "main transition" }

Type Parameters

  • mDT

Type declaration

PostAnyActionHook

PostAnyActionHook<mDT>: { handler: PostHookHandler<mDT>; kind: "post any action" }

Type Parameters

  • mDT

Type declaration

PostAnyTransitionHook

PostAnyTransitionHook<mDT>: { handler: PostHookHandler<mDT>; kind: "post any transition" }

Type Parameters

  • mDT

Type declaration

PostBasicHookDescription

PostBasicHookDescription<mDT>: { from: string; handler: PostHookHandler<mDT>; kind: "post hook"; to: string }

Type Parameters

  • mDT

Type declaration

PostEntryHook

PostEntryHook<mDT>: { handler: PostHookHandler<mDT>; kind: "post entry"; to: string }

Type Parameters

  • mDT

Type declaration

PostExitHook

PostExitHook<mDT>: { from: string; handler: PostHookHandler<mDT>; kind: "post exit" }

Type Parameters

  • mDT

Type declaration

PostForcedTransitionHook

PostForcedTransitionHook<mDT>: { handler: PostHookHandler<mDT>; kind: "post forced transition" }

Type Parameters

  • mDT

Type declaration

PostGlobalActionHook

PostGlobalActionHook<mDT>: { action: string; handler: PostHookHandler<mDT>; kind: "post global action" }

Type Parameters

  • mDT

Type declaration

PostHookDescriptionWithAction

PostHookDescriptionWithAction<mDT>: { action: string; from: string; handler: PostHookHandler<mDT>; kind: "post named"; to: string }

Type Parameters

  • mDT

Type declaration

  • action: string
  • from: string
  • handler: PostHookHandler<mDT>
  • kind: "post named"
  • to: string

PostHookHandler

PostHookHandler<mDT>: ((hook_context: HookContext<mDT>) => void)

Type Parameters

  • mDT

Type declaration

PostMainTransitionHook

PostMainTransitionHook<mDT>: { handler: PostHookHandler<mDT>; kind: "post main transition" }

Type Parameters

  • mDT

Type declaration

PostStandardTransitionHook

PostStandardTransitionHook<mDT>: { handler: PostHookHandler<mDT>; kind: "post standard transition" }

Type Parameters

  • mDT

Type declaration

StandardTransitionHook

StandardTransitionHook<mDT>: { handler: HookHandler<mDT>; kind: "standard transition" }

Type Parameters

  • mDT

Type declaration

StateType

StateType: string

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file +<internal> | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Namespace <internal>

Index

Classes

Interfaces

Type Aliases

Type Aliases

AnyActionHook

AnyActionHook<mDT>: { handler: HookHandler<mDT>; kind: "any action" }

Type Parameters

  • mDT

Type declaration

AnyTransitionHook

AnyTransitionHook<mDT>: { handler: HookHandler<mDT>; kind: "any transition" }

Type Parameters

  • mDT

Type declaration

BasicHookDescription

BasicHookDescription<mDT>: { from: string; handler: HookHandler<mDT>; kind: "hook"; to: string }

Type Parameters

  • mDT

Type declaration

  • from: string
  • handler: HookHandler<mDT>
  • kind: "hook"
  • to: string

EntryHook

EntryHook<mDT>: { handler: HookHandler<mDT>; kind: "entry"; to: string }

Type Parameters

  • mDT

Type declaration

ExitHook

ExitHook<mDT>: { from: string; handler: HookHandler<mDT>; kind: "exit" }

Type Parameters

  • mDT

Type declaration

ForcedTransitionHook

ForcedTransitionHook<mDT>: { handler: HookHandler<mDT>; kind: "forced transition" }

Type Parameters

  • mDT

Type declaration

GlobalActionHook

GlobalActionHook<mDT>: { action: string; handler: HookHandler<mDT>; kind: "global action" }

Type Parameters

  • mDT

Type declaration

  • action: string
  • handler: HookHandler<mDT>
  • kind: "global action"

HookDescriptionWithAction

HookDescriptionWithAction<mDT>: { action: string; from: string; handler: HookHandler<mDT>; kind: "named"; to: string }

Type Parameters

  • mDT

Type declaration

  • action: string
  • from: string
  • handler: HookHandler<mDT>
  • kind: "named"
  • to: string

JssmCorner

JssmCorner: "regular" | "rounded" | "lined"

JssmFailure

JssmFailure: { error: any; success: false }

Type declaration

  • error: any
  • success: false

JssmIncomplete

JssmIncomplete: { success: "incomplete" }

Type declaration

  • success: "incomplete"

JssmLineStyle

JssmLineStyle: "solid" | "dashed" | "dotted"

JssmStatePermitter

JssmStatePermitter<DataType>: ((OldState: StateType, NewState: StateType, OldData: DataType, NewData: DataType) => boolean)

Type Parameters

  • DataType

Type declaration

    • Parameters

      Returns boolean

JssmStatePermitterMaybeArray

JssmStatePermitterMaybeArray<DataType>: JssmStatePermitter<DataType> | JssmStatePermitter<DataType>[]

Type Parameters

  • DataType

JssmStateStyleBackgroundColor

JssmStateStyleBackgroundColor: { key: "background-color"; value: JssmColor }

Type declaration

JssmStateStyleBorderColor

JssmStateStyleBorderColor: { key: "border-color"; value: JssmColor }

Type declaration

JssmStateStyleColor

JssmStateStyleColor: { key: "color"; value: JssmColor }

Type declaration

JssmStateStyleCorners

JssmStateStyleCorners: { key: "corners"; value: JssmCorner }

Type declaration

JssmStateStyleLineStyle

JssmStateStyleLineStyle: { key: "line-style"; value: JssmLineStyle }

Type declaration

JssmStateStyleShape

JssmStateStyleShape: { key: "shape"; value: JssmShape }

Type declaration

JssmStateStyleStateLabel

JssmStateStyleStateLabel: { key: "state-label"; value: string }

Type declaration

  • key: "state-label"
  • value: string

JssmStateStyleTextColor

JssmStateStyleTextColor: { key: "text-color"; value: JssmColor }

Type declaration

JssmSuccess

JssmSuccess: { success: true }

Type declaration

  • success: true

JssmTransitionCycle

JssmTransitionCycle: { key: "cycle"; value: StateType }

Type declaration

JssmTransitionPermitter

JssmTransitionPermitter<DataType>: ((OldState: StateType, NewState: StateType, OldData: DataType, NewData: DataType) => boolean)

Type Parameters

  • DataType

Type declaration

    • Parameters

      Returns boolean

JssmTransitionPermitterMaybeArray

JssmTransitionPermitterMaybeArray<DataType>: JssmTransitionPermitter<DataType> | JssmTransitionPermitter<DataType>[]

Type Parameters

  • DataType

MainTransitionHook

MainTransitionHook<mDT>: { handler: HookHandler<mDT>; kind: "main transition" }

Type Parameters

  • mDT

Type declaration

PostAnyActionHook

PostAnyActionHook<mDT>: { handler: PostHookHandler<mDT>; kind: "post any action" }

Type Parameters

  • mDT

Type declaration

PostAnyTransitionHook

PostAnyTransitionHook<mDT>: { handler: PostHookHandler<mDT>; kind: "post any transition" }

Type Parameters

  • mDT

Type declaration

PostBasicHookDescription

PostBasicHookDescription<mDT>: { from: string; handler: PostHookHandler<mDT>; kind: "post hook"; to: string }

Type Parameters

  • mDT

Type declaration

PostEntryHook

PostEntryHook<mDT>: { handler: PostHookHandler<mDT>; kind: "post entry"; to: string }

Type Parameters

  • mDT

Type declaration

PostExitHook

PostExitHook<mDT>: { from: string; handler: PostHookHandler<mDT>; kind: "post exit" }

Type Parameters

  • mDT

Type declaration

PostForcedTransitionHook

PostForcedTransitionHook<mDT>: { handler: PostHookHandler<mDT>; kind: "post forced transition" }

Type Parameters

  • mDT

Type declaration

PostGlobalActionHook

PostGlobalActionHook<mDT>: { action: string; handler: PostHookHandler<mDT>; kind: "post global action" }

Type Parameters

  • mDT

Type declaration

PostHookDescriptionWithAction

PostHookDescriptionWithAction<mDT>: { action: string; from: string; handler: PostHookHandler<mDT>; kind: "post named"; to: string }

Type Parameters

  • mDT

Type declaration

  • action: string
  • from: string
  • handler: PostHookHandler<mDT>
  • kind: "post named"
  • to: string

PostHookHandler

PostHookHandler<mDT>: ((hook_context: HookContext<mDT>) => void)

Type Parameters

  • mDT

Type declaration

PostMainTransitionHook

PostMainTransitionHook<mDT>: { handler: PostHookHandler<mDT>; kind: "post main transition" }

Type Parameters

  • mDT

Type declaration

PostStandardTransitionHook

PostStandardTransitionHook<mDT>: { handler: PostHookHandler<mDT>; kind: "post standard transition" }

Type Parameters

  • mDT

Type declaration

StandardTransitionHook

StandardTransitionHook<mDT>: { handler: HookHandler<mDT>; kind: "standard transition" }

Type Parameters

  • mDT

Type declaration

StateType

StateType: string

TraversalFunctor

TraversalFunctor<T>: ((_element: T, _index?: number, _array?: T[]) => unknown)

Type Parameters

  • T

Type declaration

    • (_element: T, _index?: number, _array?: T[]): unknown

    • Parameters

      • _element: T
      • Optional _index: number
      • Optional _array: T[]

      Returns unknown

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/modules/jssm_types.html b/docs/docs/modules/jssm_types.html index 1755ce1c..c692e0d0 100644 --- a/docs/docs/modules/jssm_types.html +++ b/docs/docs/modules/jssm_types.html @@ -1,3 +1,3 @@ -jssm_types | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Module jssm_types

Index

Namespaces

Type Aliases

Type Aliases

FslDirection

FslDirection: "up" | "right" | "down" | "left"

FslTheme

FslTheme: "default" | "ocean" | "modern" | "none"

HookComplexResult

HookComplexResult<mDT>: { data?: mDT; pass: boolean; state?: StateType }

Type Parameters

  • mDT

Type declaration

  • Optional data?: mDT
  • pass: boolean
  • Optional state?: StateType

HookContext

HookContext<mDT>: { data: mDT }

Type Parameters

  • mDT

Type declaration

  • data: mDT

HookDescription

HookDescription<mDT>: BasicHookDescription<mDT> | HookDescriptionWithAction<mDT> | GlobalActionHook<mDT> | AnyActionHook<mDT> | StandardTransitionHook<mDT> | MainTransitionHook<mDT> | ForcedTransitionHook<mDT> | AnyTransitionHook<mDT> | EntryHook<mDT> | ExitHook<mDT> | PostBasicHookDescription<mDT> | PostHookDescriptionWithAction<mDT> | PostGlobalActionHook<mDT> | PostAnyActionHook<mDT> | PostStandardTransitionHook<mDT> | PostMainTransitionHook<mDT> | PostForcedTransitionHook<mDT> | PostAnyTransitionHook<mDT> | PostEntryHook<mDT> | PostExitHook<mDT>

Type Parameters

  • mDT

HookHandler

HookHandler<mDT>: ((hook_context: HookContext<mDT>) => HookResult<mDT>)

Type Parameters

  • mDT

Type declaration

HookResult

HookResult<mDT>: boolean | undefined | void | HookComplexResult<mDT>

Type Parameters

  • mDT

JssmArrow

JssmArrow: "->" | "<-" | "<->" | "<=->" | "<~->" | "=>" | "<=" | "<=>" | "<-=>" | "<~=>" | "~>" | "<~" | "<~>" | "<-~>" | "<=~>"

JssmArrowDirection

JssmArrowDirection: "left" | "right" | "both"

JssmArrowKind

JssmArrowKind: "none" | "legal" | "main" | "forced"

JssmColor

JssmColor: string

JssmCompileRule

JssmCompileRule: { agg_as: string; val: any }

Type declaration

  • agg_as: string
  • val: any

JssmCompileSe

JssmCompileSe: { kind: JssmArrow; l_action?: StateType; l_probability: number; r_action?: StateType; r_probability: number; se: JssmCompileSe; to: StateType }

Type declaration

JssmCompileSeStart

JssmCompileSeStart<DataType>: { from: DataType; key: string; name?: string; se: JssmCompileSe; value?: string | number }

Type Parameters

  • DataType

Type declaration

  • from: DataType
  • key: string
  • Optional name?: string
  • se: JssmCompileSe
  • Optional value?: string | number

JssmErrorExtendedInfo

JssmErrorExtendedInfo: { requested_state?: StateType }

Type declaration

JssmGenericConfig

JssmGenericConfig<DataType>: { actions?: JssmPermittedOpt; allow_force?: false; allow_islands?: false; arrange_declaration?: StateType[][]; arrange_end_declaration?: StateType[][]; arrange_start_declaration?: StateType[][]; auto_api?: boolean | string; check?: JssmStatePermitterMaybeArray<DataType>; complete?: StateType[]; data?: DataType; dot_preamble?: string; end_states?: StateType[]; flow?: FslDirection; fsl_version?: string; graph_layout?: JssmLayout; history?: number; instance_name?: string; machine_author?: string | string[]; machine_comment?: string; machine_contributor?: string | string[]; machine_definition?: string; machine_language?: string; machine_license?: string; machine_name?: string; machine_version?: string; max_exits?: number; min_exits?: number; name?: string; nodes?: StateType[]; simplify_bidi?: boolean; start_states: StateType[]; state_declaration?: <internal>.Object[]; theme?: FslTheme; transitions: JssmTransitions<DataType> }

Type Parameters

  • DataType

Type declaration

  • Optional actions?: JssmPermittedOpt
  • Optional allow_force?: false
  • Optional allow_islands?: false
  • Optional arrange_declaration?: StateType[][]
  • Optional arrange_end_declaration?: StateType[][]
  • Optional arrange_start_declaration?: StateType[][]
  • Optional auto_api?: boolean | string
  • Optional check?: JssmStatePermitterMaybeArray<DataType>
  • Optional complete?: StateType[]
  • Optional data?: DataType
  • Optional dot_preamble?: string
  • Optional end_states?: StateType[]
  • Optional flow?: FslDirection
  • Optional fsl_version?: string
  • Optional graph_layout?: JssmLayout
  • Optional history?: number
  • Optional instance_name?: string
  • Optional machine_author?: string | string[]
  • Optional machine_comment?: string
  • Optional machine_contributor?: string | string[]
  • Optional machine_definition?: string
  • Optional machine_language?: string
  • Optional machine_license?: string
  • Optional machine_name?: string
  • Optional machine_version?: string
  • Optional max_exits?: number
  • Optional min_exits?: number
  • Optional name?: string
  • Optional nodes?: StateType[]
  • Optional simplify_bidi?: boolean
  • start_states: StateType[]
  • Optional state_declaration?: <internal>.Object[]
  • Optional theme?: FslTheme
  • transitions: JssmTransitions<DataType>

JssmGenericMachine

JssmGenericMachine<DataType>: { allow_empty?: boolean; allow_force?: boolean; allow_islands?: boolean; check?: JssmStatePermitterMaybeArray<DataType>; data?: DataType; keep_history?: boolean | number; max_transitions?: number; min_transitions?: number; name?: string; nodes?: StateType[]; state: StateType; transitions: JssmTransitions<DataType> }

Type Parameters

  • DataType

Type declaration

  • Optional allow_empty?: boolean
  • Optional allow_force?: boolean
  • Optional allow_islands?: boolean
  • Optional check?: JssmStatePermitterMaybeArray<DataType>
  • Optional data?: DataType
  • Optional keep_history?: boolean | number
  • Optional max_transitions?: number
  • Optional min_transitions?: number
  • Optional name?: string
  • Optional nodes?: StateType[]
  • state: StateType
  • transitions: JssmTransitions<DataType>

JssmGenericState

JssmGenericState: { complete: boolean; from: StateType[]; name: StateType; to: StateType[] }

Type declaration

JssmLayout

JssmLayout: "dot" | "circo" | "twopi" | "fdp"

JssmMachineInternalState

JssmMachineInternalState<DataType>: { actions: Map<StateType, Map<StateType, number>>; edge_map: Map<StateType, Map<StateType, number>>; edges: JssmTransition<DataType>[]; internal_state_impl_version: 1; named_transitions: Map<StateType, number>; reverse_actions: Map<StateType, Map<StateType, number>>; state: StateType; states: Map<StateType, JssmGenericState> }

Type Parameters

  • DataType

Type declaration

JssmParseFunctionType

JssmParseFunctionType: ((string: any) => JssmParseTree)

Type declaration

JssmParseTree

JssmParseTree: JssmCompileSeStart<StateType>[]

JssmPermitted

JssmPermitted: "required" | "disallowed"

JssmPermittedOpt

JssmPermittedOpt: "required" | "disallowed" | "optional"

JssmResult

JssmResult: JssmSuccess | JssmFailure | JssmIncomplete

JssmShape

JssmShape: "box" | "polygon" | "ellipse" | "oval" | "circle" | "point" | "egg" | "triangle" | "plaintext" | "plain" | "diamond" | "trapezium" | "parallelogram" | "house" | "pentagon" | "hexagon" | "septagon" | "octagon" | "doublecircle" | "doubleoctagon" | "tripleoctagon" | "invtriangle" | "invtrapezium" | "invhouse" | "Mdiamond" | "Msquare" | "Mcircle" | "rect" | "rectangle" | "square" | "star" | "none" | "underline" | "cylinder" | "note" | "tab" | "folder" | "box3d" | "component" | "promoter" | "cds" | "terminator" | "utr" | "primersite" | "restrictionsite" | "fivepoverhang" | "threepoverhang" | "noverhang" | "assembly" | "signature" | "insulator" | "ribosite" | "rnastab" | "proteasesite" | "proteinstab" | "rpromoter" | "rarrow" | "larrow" | "lpromoter" | "record"
+jssm_types | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Module jssm_types

Index

Namespaces

Type Aliases

Variables

Type Aliases

FslDirection

FslDirection: typeof FslDirections[number]

FslTheme

FslTheme: typeof FslThemes[number]

HookComplexResult

HookComplexResult<mDT>: { data?: mDT; next_data?: mDT; pass: boolean; state?: StateType }

Type Parameters

  • mDT

Type declaration

  • Optional data?: mDT
  • Optional next_data?: mDT
  • pass: boolean
  • Optional state?: StateType

HookContext

HookContext<mDT>: { data: mDT; next_data: mDT }

Type Parameters

  • mDT

Type declaration

  • data: mDT
  • next_data: mDT

HookDescription

HookDescription<mDT>: BasicHookDescription<mDT> | HookDescriptionWithAction<mDT> | GlobalActionHook<mDT> | AnyActionHook<mDT> | StandardTransitionHook<mDT> | MainTransitionHook<mDT> | ForcedTransitionHook<mDT> | AnyTransitionHook<mDT> | EntryHook<mDT> | ExitHook<mDT> | PostBasicHookDescription<mDT> | PostHookDescriptionWithAction<mDT> | PostGlobalActionHook<mDT> | PostAnyActionHook<mDT> | PostStandardTransitionHook<mDT> | PostMainTransitionHook<mDT> | PostForcedTransitionHook<mDT> | PostAnyTransitionHook<mDT> | PostEntryHook<mDT> | PostExitHook<mDT>

Type Parameters

  • mDT

HookHandler

HookHandler<mDT>: ((hook_context: HookContext<mDT>) => HookResult<mDT>)

Type Parameters

  • mDT

Type declaration

HookResult

HookResult<mDT>: boolean | undefined | void | HookComplexResult<mDT>

Type Parameters

  • mDT

JssmAllowsOverride

JssmAllowsOverride: boolean | undefined

JssmArrow

JssmArrow: "->" | "<-" | "<->" | "<=->" | "<~->" | "=>" | "<=" | "<=>" | "<-=>" | "<~=>" | "~>" | "<~" | "<~>" | "<-~>" | "<=~>"

JssmArrowDirection

JssmArrowDirection: "left" | "right" | "both"

JssmArrowKind

JssmArrowKind: "none" | "legal" | "main" | "forced"

JssmBaseTheme

JssmBaseTheme: { action: undefined; active: JssmStateConfig; active_end: JssmStateConfig; active_hooked: JssmStateConfig; active_start: JssmStateConfig; active_terminal: JssmStateConfig; end: JssmStateConfig; forced: undefined; graph: undefined; hooked: JssmStateConfig; legal: undefined; main: undefined; name: string; start: JssmStateConfig; state: JssmStateConfig; terminal: JssmStateConfig; title: undefined }

Type declaration

JssmColor

JssmColor: string

JssmCompileRule

JssmCompileRule<StateType>: { agg_as: string; val: any }

Type Parameters

  • StateType

Type declaration

  • agg_as: string
  • val: any

JssmCompileSe

JssmCompileSe<StateType, mDT>: { kind: JssmArrow; l_action?: StateType; l_probability: number; r_action?: StateType; r_probability: number; se: JssmCompileSe<StateType, mDT>; to: StateType }

Type Parameters

  • StateType

  • mDT

Type declaration

  • kind: JssmArrow
  • Optional l_action?: StateType
  • l_probability: number
  • Optional r_action?: StateType
  • r_probability: number
  • se: JssmCompileSe<StateType, mDT>
  • to: StateType

JssmCompileSeStart

JssmCompileSeStart<StateType, DataType>: { default_value?: any; from: StateType; key: string; name?: string; required?: boolean; se: JssmCompileSe<StateType, DataType>; state?: string; value?: string | number }

Type Parameters

  • StateType

  • DataType

Type declaration

  • Optional default_value?: any
  • from: StateType
  • key: string
  • Optional name?: string
  • Optional required?: boolean
  • se: JssmCompileSe<StateType, DataType>
  • Optional state?: string
  • Optional value?: string | number

JssmErrorExtendedInfo

JssmErrorExtendedInfo: { requested_state?: StateType }

Type declaration

JssmGenericConfig

JssmGenericConfig<StateType, DataType>: { actions?: JssmPermittedOpt; allow_force?: false; allow_islands?: false; allows_override?: JssmAllowsOverride; arrange_declaration?: StateType[][]; arrange_end_declaration?: StateType[][]; arrange_start_declaration?: StateType[][]; auto_api?: boolean | string; check?: JssmStatePermitterMaybeArray<DataType>; complete?: StateType[]; config_allows_override?: JssmAllowsOverride; data?: DataType; default_active_state_config?: JssmStateStyleKeyList; default_end_state_config?: JssmStateStyleKeyList; default_hooked_state_config?: JssmStateStyleKeyList; default_start_state_config?: JssmStateStyleKeyList; default_state_config?: JssmStateStyleKeyList; default_terminal_state_config?: JssmStateStyleKeyList; dot_preamble?: string; end_states?: StateType[]; flow?: FslDirection; fsl_version?: string; graph_layout?: JssmLayout; history?: number; instance_name?: string; machine_author?: string | string[]; machine_comment?: string; machine_contributor?: string | string[]; machine_definition?: string; machine_language?: string; machine_license?: string; machine_name?: string; machine_version?: string; max_exits?: number; min_exits?: number; name?: string; nodes?: StateType[]; property_definition?: JssmPropertyDefinition[]; simplify_bidi?: boolean; start_states: StateType[]; state_declaration?: <internal>.Object[]; state_property?: JssmPropertyDefinition[]; theme?: FslTheme[]; transitions: JssmTransitions<StateType, DataType> }

Type Parameters

  • StateType

  • DataType

Type declaration

  • Optional actions?: JssmPermittedOpt
  • Optional allow_force?: false
  • Optional allow_islands?: false
  • Optional allows_override?: JssmAllowsOverride
  • Optional arrange_declaration?: StateType[][]
  • Optional arrange_end_declaration?: StateType[][]
  • Optional arrange_start_declaration?: StateType[][]
  • Optional auto_api?: boolean | string
  • Optional check?: JssmStatePermitterMaybeArray<DataType>
  • Optional complete?: StateType[]
  • Optional config_allows_override?: JssmAllowsOverride
  • Optional data?: DataType
  • Optional default_active_state_config?: JssmStateStyleKeyList
  • Optional default_end_state_config?: JssmStateStyleKeyList
  • Optional default_hooked_state_config?: JssmStateStyleKeyList
  • Optional default_start_state_config?: JssmStateStyleKeyList
  • Optional default_state_config?: JssmStateStyleKeyList
  • Optional default_terminal_state_config?: JssmStateStyleKeyList
  • Optional dot_preamble?: string
  • Optional end_states?: StateType[]
  • Optional flow?: FslDirection
  • Optional fsl_version?: string
  • Optional graph_layout?: JssmLayout
  • Optional history?: number
  • Optional instance_name?: string
  • Optional machine_author?: string | string[]
  • Optional machine_comment?: string
  • Optional machine_contributor?: string | string[]
  • Optional machine_definition?: string
  • Optional machine_language?: string
  • Optional machine_license?: string
  • Optional machine_name?: string
  • Optional machine_version?: string
  • Optional max_exits?: number
  • Optional min_exits?: number
  • Optional name?: string
  • Optional nodes?: StateType[]
  • Optional property_definition?: JssmPropertyDefinition[]
  • Optional simplify_bidi?: boolean
  • start_states: StateType[]
  • Optional state_declaration?: <internal>.Object[]
  • Optional state_property?: JssmPropertyDefinition[]
  • Optional theme?: FslTheme[]
  • transitions: JssmTransitions<StateType, DataType>

JssmGenericMachine

JssmGenericMachine<DataType>: { allow_empty?: boolean; allow_force?: boolean; allow_islands?: boolean; check?: JssmStatePermitterMaybeArray<DataType>; data?: DataType; keep_history?: boolean | number; max_transitions?: number; min_transitions?: number; name?: string; nodes?: StateType[]; state: StateType; transitions: JssmTransitions<StateType, DataType> }

Type Parameters

  • DataType

Type declaration

  • Optional allow_empty?: boolean
  • Optional allow_force?: boolean
  • Optional allow_islands?: boolean
  • Optional check?: JssmStatePermitterMaybeArray<DataType>
  • Optional data?: DataType
  • Optional keep_history?: boolean | number
  • Optional max_transitions?: number
  • Optional min_transitions?: number
  • Optional name?: string
  • Optional nodes?: StateType[]
  • state: StateType
  • transitions: JssmTransitions<StateType, DataType>

JssmGenericState

JssmGenericState: { complete: boolean; from: StateType[]; name: StateType; to: StateType[] }

Type declaration

JssmHistory

JssmHistory<mDT>: circular_buffer<[StateType, mDT]>

Type Parameters

  • mDT

JssmLayout

JssmLayout: "dot" | "circo" | "twopi" | "fdp"

JssmMachineInternalState

JssmMachineInternalState<DataType>: { actions: Map<StateType, Map<StateType, number>>; edge_map: Map<StateType, Map<StateType, number>>; edges: JssmTransition<StateType, DataType>[]; internal_state_impl_version: 1; named_transitions: Map<StateType, number>; reverse_actions: Map<StateType, Map<StateType, number>>; state: StateType; states: Map<StateType, JssmGenericState> }

Type Parameters

  • DataType

Type declaration

JssmParseFunctionType

JssmParseFunctionType<StateType, mDT>: ((string: any) => JssmParseTree<StateType, mDT>)

Type Parameters

  • StateType

  • mDT

Type declaration

JssmParseTree

JssmParseTree<StateType, mDT>: JssmCompileSeStart<StateType, mDT>[]

Type Parameters

  • StateType

  • mDT

JssmPermitted

JssmPermitted: "required" | "disallowed"

JssmPermittedOpt

JssmPermittedOpt: "required" | "disallowed" | "optional"

JssmPropertyDefinition

JssmPropertyDefinition: { default_value?: any; name: string; required?: boolean }

Type declaration

  • Optional default_value?: any
  • name: string
  • Optional required?: boolean

JssmResult

JssmResult: JssmSuccess | JssmFailure | JssmIncomplete

JssmSerialization

JssmSerialization<DataType>: { comment?: string; data: DataType; history: [string, DataType][]; history_capacity: number; jssm_version: string; state: StateType; timestamp: number }

Type Parameters

  • DataType

Type declaration

  • Optional comment?: string
  • data: DataType
  • history: [string, DataType][]
  • history_capacity: number
  • jssm_version: string
  • state: StateType
  • timestamp: number

JssmShape

JssmShape: "box" | "polygon" | "ellipse" | "oval" | "circle" | "point" | "egg" | "triangle" | "plaintext" | "plain" | "diamond" | "trapezium" | "parallelogram" | "house" | "pentagon" | "hexagon" | "septagon" | "octagon" | "doublecircle" | "doubleoctagon" | "tripleoctagon" | "invtriangle" | "invtrapezium" | "invhouse" | "Mdiamond" | "Msquare" | "Mcircle" | "rect" | "rectangle" | "square" | "star" | "none" | "underline" | "cylinder" | "note" | "tab" | "folder" | "box3d" | "component" | "promoter" | "cds" | "terminator" | "utr" | "primersite" | "restrictionsite" | "fivepoverhang" | "threepoverhang" | "noverhang" | "assembly" | "signature" | "insulator" | "ribosite" | "rnastab" | "proteasesite" | "proteinstab" | "rpromoter" | "rarrow" | "larrow" | "lpromoter" | "record"

A type teaching Typescript the various supported shapes for nodes, mostly inherited from GraphViz

-

JssmStateDeclaration

JssmStateDeclaration: { backgroundColor?: JssmColor; borderColor?: JssmColor; color?: JssmColor; corners?: JssmCorner; declarations: JssmStateDeclarationRule[]; linestyle?: JssmLineStyle; shape?: JssmShape; state: StateType; textColor?: JssmColor }

Type declaration

JssmStateDeclarationRule

JssmStateDeclarationRule: { key: string; value: any }

Type declaration

  • key: string
  • value: any

JssmTransition

JssmTransition<DataType>: { action?: StateType; check?: JssmTransitionPermitterMaybeArray<DataType>; forced_only: boolean; from: StateType; kind: JssmArrowKind; main_path: boolean; name?: string; probability?: number; to: StateType }

Type Parameters

  • DataType

Type declaration

JssmTransitionList

JssmTransitionList: { entrances: StateType[]; exits: StateType[] }

Type declaration

JssmTransitionRule

JssmTransitionRule: StateType | JssmTransitionCycle

JssmTransitions

JssmTransitions<DataType>: JssmTransition<DataType>[]

Type Parameters

  • DataType

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file +

JssmStateConfig

JssmStateConfig: Partial<JssmStateDeclaration>

JssmStateDeclaration

JssmStateDeclaration: { backgroundColor?: JssmColor; borderColor?: JssmColor; color?: JssmColor; corners?: JssmCorner; declarations: JssmStateDeclarationRule[]; lineStyle?: JssmLineStyle; property?: { name: string; value: unknown }; shape?: JssmShape; state: StateType; stateLabel?: string; textColor?: JssmColor }

Type declaration

JssmStateDeclarationRule

JssmStateDeclarationRule: { key: string; name?: string; value: any }

Type declaration

  • key: string
  • Optional name?: string
  • value: any

JssmStateStyleKey

JssmStateStyleKey: JssmStateStyleShape | JssmStateStyleColor | JssmStateStyleTextColor | JssmStateStyleCorners | JssmStateStyleLineStyle | JssmStateStyleBackgroundColor | JssmStateStyleStateLabel | JssmStateStyleBorderColor

JssmStateStyleKeyList

JssmStateStyleKeyList: JssmStateStyleKey[]

JssmTheme

JssmTheme: Partial<JssmBaseTheme>

JssmTransition

JssmTransition<StateType, DataType>: { action?: StateType; check?: JssmTransitionPermitterMaybeArray<DataType>; forced_only: boolean; from: StateType; kind: JssmArrowKind; main_path: boolean; name?: StateType; probability?: number; to: StateType }

Type Parameters

  • StateType

  • DataType

Type declaration

JssmTransitionList

JssmTransitionList: { entrances: StateType[]; exits: StateType[] }

Type declaration

JssmTransitionRule

JssmTransitionRule: StateType | JssmTransitionCycle

JssmTransitions

JssmTransitions<StateType, DataType>: JssmTransition<StateType, DataType>[]

Type Parameters

  • StateType

  • DataType

Variables

Const FslDirections

FslDirections: readonly ["up", "right", "down", "left"] = ...

Const FslThemes

FslThemes: readonly ["default", "ocean", "modern", "plain", "bold"] = ...

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/modules/jssm_util.html b/docs/docs/modules/jssm_util.html index cd3f9f4b..444383c6 100644 --- a/docs/docs/modules/jssm_util.html +++ b/docs/docs/modules/jssm_util.html @@ -1,22 +1,40 @@ -jssm_util | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Module jssm_util

Index

Variables

Functions

Variables

Const histograph

histograph: Function = ...
+jssm_util | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Module jssm_util

Index

Variables

Functions

Variables

Const histograph

histograph: Function = ...

Returns the histograph of an array as a Map. Makes no attempt to cope with deep equality; will fail for complex contents, as such.

import { histograph } from './jssm';

histograph( [0, 0, 1, 1, 2, 2, 1] );  // Map()
-

Const weighted_histo_key

weighted_histo_key: Function = ...

Const weighted_rand_select

weighted_rand_select: Function = ...

Const weighted_sample_select

weighted_sample_select: Function = ...

Functions

arr_uniq_p

  • arr_uniq_p<T>(el: T, i: number, source: T[]): boolean

Const weighted_histo_key

weighted_histo_key: Function = ...

Const weighted_rand_select

weighted_rand_select: Function = ...

Const weighted_sample_select

weighted_sample_select: Function = ...

Functions

arr_uniq_p

  • arr_uniq_p<T>(el: T, i: number, source: T[]): boolean

  • Predicate for validating an array for uniqueness. Not generally meant for external use.

    -

    Type Parameters

    • T

    Parameters

    • el: T
    • i: number
    • source: T[]

    Returns boolean

array_box_if_string

  • array_box_if_string(n: any): any

hook_name

  • hook_name(from: string, to: string): string

array_box_if_string

  • array_box_if_string(n: any): any

find_repeated

  • find_repeated<T>(arr: T[]): [T, number][]
  • +

    Lists all repeated items in an array along with their counts. Subject to + matching rules of Map. NaN is manually removed because of conflict rules + around unique. Because these are compared with === and because + arrays and objects never match that way unless they're the same object, + arrays and objects are never considered repeats.

    +
    find_repeated<string>([ ]);                     // []
    find_repeated<string>([ "one" ]);               // []
    find_repeated<string>([ "one", "two" ]);        // []
    find_repeated<string>([ "one", "one" ]);        // [ ["one", 2] ]
    find_repeated<string>([ "one", "two", "one" ]); // [ ["one", 2] ]
    find_repeated<number>([ 0, NaN, 0, NaN ]);      // [ [0,     2] ]
+
    +

    Type Parameters

    • T

    Parameters

    • arr: T[]

    Returns [T, number][]

hook_name

  • hook_name(from: string, to: string): string

  • Internal method generating names for edges for the hook lookup map. Not meant for external use.

    -

    Parameters

    • from: string
    • to: string

    Returns string

make_mulberry_rand

  • make_mulberry_rand(a?: number): (() => number)

make_mulberry_rand

  • make_mulberry_rand(a?: number): (() => number)

named_hook_name

  • named_hook_name(from: string, to: string, action: string): string

name_bind_prop_and_state

  • name_bind_prop_and_state(prop: string, state: string): string
  • +

    Internal method generating names for edges for the hook lookup map. Not + meant for external use.

    +

    Parameters

    • prop: string
    • state: string

    Returns string

named_hook_name

  • named_hook_name(from: string, to: string, action: string): string

  • Internal method generating names for actions for the hook lookup map. Not meant for external use.

    -

    Parameters

    • from: string
    • to: string
    • action: string

    Returns string

seq

  • seq(n: number): number[]

seq

  • seq(n: number): number[]

  • Returns, for a non-negative integer argument n, the series [0 .. n].

    import { seq } from './jssm';

    seq(5);  // [0, 1, 2, 3, 4]
    seq(0);  // []
    -

    Parameters

    • n: number

    Returns number[]

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file +

Parameters

  • n: number

Returns number[]

unique

  • unique<T>(arr?: T[]): T[]
  • +

    Reduces an array to its unique contents. Compares with === and makes no + effort to deep-compare contents; two matching arrays or objects contained + will be treated as distinct, according to javascript rules. This also means + that NaNs will be dropped, because they do not self-compare.

    +
    unique( [] );                     // []
    unique( [0,0] );                  // [0]
    unique( [0,1,2, 0,1,2, 0,1,2] );  // [0,1,2]
    unique( [ [1], [1] ] );           // [ [1], [1] ] because arrays don't match
    unique( [0,NaN,2] );              // [0,2]
+
    +

    Type Parameters

    • T

    Parameters

    • Optional arr: T[]

    Returns T[]

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/modules/version.html b/docs/docs/modules/version.html index fe4c6b78..78b3ec47 100644 --- a/docs/docs/modules/version.html +++ b/docs/docs/modules/version.html @@ -1 +1 @@ -version | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Module version

Index

Variables

Variables

Const version

version: string = "5.77.0"

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file +version | JSSM, a JavaScript state machine - the FSM for FSL
Options
All
  • Public
  • Public/Protected
  • All
Menu

Module version

Index

Variables

Variables

Const build_time

build_time: number = 1670139024155

Const version

version: string = "5.87.0"

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/pages/CHANGELOG.long.html b/docs/docs/pages/CHANGELOG.long.html index a8e69455..b5b2940d 100644 --- a/docs/docs/pages/CHANGELOG.long.html +++ b/docs/docs/pages/CHANGELOG.long.html @@ -3,59 +3,1715 @@

Changelog

All notable changes to this project will be documented in this file.

-

961 merges; 129 releases

+

1076 merges; 178 releases

 

 

Published tags:

-

5.76.2, 5.76.0, 5.75.1, 5.75.0, 5.74.0, 5.73.1, 5.73.0, 5.72.5, 5.72.4, 5.72.3, 5.72.2, 5.72.1, 5.72.0, 5.71.1, 5.71.0, 5.70.36, 5.70.35, 5.70.34, 5.70.33, 5.70.32, 5.70.31, 5.70.30, 5.70.29, 5.70.28, 5.70.27, 5.70.26, 5.70.25, 5.70.24, 5.70.23, 5.70.22, 5.70.21, 5.70.20, 5.70.19, 5.70.18, 5.70.16, 5.70.15, 5.70.14, 5.70.13, 5.70.12, 5.70.11, 5.70.10, 5.70.9, 5.70.8, 5.70.7, 5.70.6, 5.70.5, 5.70.4, 5.70.3, 5.70.2, 5.70.1, 5.70.0, 5.69.4, 5.69.3, 5.69.2, 5.69.0, 5.68.0, 5.67.2, 5.67.0, 5.66.0, 5.65.14, 5.65.12, 5.65.11, 5.65.10, 5.65.9, 5.65.8, 5.65.7, 5.65.5, 5.65.4, 5.65.3, 5.65.2, 5.65.1, 5.65.0, 5.64.2, 5.64.1, 5.64.0, 5.63.0, 5.62.0, 5.61.4, 5.61.3, 5.61.2, 5.61.1, 5.60.4, 5.60.3, 5.60.0, 5.59.1, 5.59.0, 5.58.1, 5.58.0, 5.57.1, 5.57.0, 5.56.2, 5.56.1, 5.55.0, 5.54.0, 5.53.0, 5.52.0, 5.51.0, 5.50.0, 5.49.0, 5.48.0, 5.47.0, 5.46.0, 5.45.2, 5.45.0, 5.44.0, 5.43.2, v5.42.0, 5.42.0, v5.41.15, 5.41.15, v5.41.14, 5.41.14, v5.41.12, 5.41.12, v5.41.10, 5.41.10, v5.41.9, 5.41.9, v5.41.8, 5.41.8, v5.41.7, v5.41.2, v5.41.1, v5.32.14, 5.14.0, 5.12.0, 5.11.12, 5.11.1, 5.11.0

+

5.87.0, 5.86.3, 5.86.2, 5.86.1, 5.86.0, 5.85.11, 5.85.10, 5.85.9, 5.85.8, 5.85.7, 5.85.6, 5.85.5, 5.85.4, 5.85.3, 5.85.2, 5.85.1, 5.85.0, 5.84.1, 5.84.0, 5.83.2, 5.83.1, 5.83.0, 5.82.5, 5.82.4, 5.82.3, 5.82.2, 5.82.1, 5.82.0, 5.81.2, 5.81.0, 5.80.1, 5.80.0, 5.79.18, 5.79.17, 5.79.16, 5.79.15, 5.79.11, 5.79.10, 5.79.9, 5.79.8, 5.79.6, 5.79.4, 5.79.3, 5.79.2, 5.79.1, 5.79.0, 5.78.0, 5.77.1, 5.77.0, 5.76.2, 5.76.0, 5.75.1, 5.75.0, 5.74.0, 5.73.1, 5.73.0, 5.72.5, 5.72.4, 5.72.3, 5.72.2, 5.72.1, 5.72.0, 5.71.1, 5.71.0, 5.70.36, 5.70.35, 5.70.34, 5.70.33, 5.70.32, 5.70.31, 5.70.30, 5.70.29, 5.70.28, 5.70.27, 5.70.26, 5.70.25, 5.70.24, 5.70.23, 5.70.22, 5.70.21, 5.70.20, 5.70.19, 5.70.18, 5.70.16, 5.70.15, 5.70.14, 5.70.13, 5.70.12, 5.70.11, 5.70.10, 5.70.9, 5.70.8, 5.70.7, 5.70.6, 5.70.5, 5.70.4, 5.70.3, 5.70.2, 5.70.1, 5.70.0, 5.69.4, 5.69.3, 5.69.2, 5.69.0, 5.68.0, 5.67.2, 5.67.0, 5.66.0, 5.65.14, 5.65.12, 5.65.11, 5.65.10, 5.65.9, 5.65.8, 5.65.7, 5.65.5, 5.65.4, 5.65.3, 5.65.2, 5.65.1, 5.65.0, 5.64.2, 5.64.1, 5.64.0, 5.63.0, 5.62.0, 5.61.4, 5.61.3, 5.61.2, 5.61.1, 5.60.4, 5.60.3, 5.60.0, 5.59.1, 5.59.0, 5.58.1, 5.58.0, 5.57.1, 5.57.0, 5.56.2, 5.56.1, 5.55.0, 5.54.0, 5.53.0, 5.52.0, 5.51.0, 5.50.0, 5.49.0, 5.48.0, 5.47.0, 5.46.0, 5.45.2, 5.45.0, 5.44.0, 5.43.2, v5.42.0, 5.42.0, v5.41.15, 5.41.15, v5.41.14, 5.41.14, v5.41.12, 5.41.12, v5.41.10, 5.41.10, v5.41.9, 5.41.9, v5.41.8, 5.41.8, v5.41.7, v5.41.2, v5.41.1, v5.32.14, 5.14.0, 5.12.0, 5.11.12, 5.11.1, 5.11.0

+

 

+

 

+ + + + +

[5.87.0] - 12/3/2022 8:18:35 PM

+ +

Commit 85963d8c154225916ec9bf1f494c480ca033dec9

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [dbb82ae, d6f77d1]

+
    +
  • Merge pull request #549 from StoneCypher/next_data
    • +
  • Next data
    • +
+

 

+

 

+ + +

[Untagged] - 12/3/2022 7:40:06 PM

+ +

Commit d6f77d1be4cf107f2eda1cfddca81d4ebcfc7c99

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • forgot version bump
    • +
+

 

+

 

+ + +

[Untagged] - 12/3/2022 7:32:06 PM

+ +

Commit e6227e3d26828277c002ff0dd67899ab89771fc2

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • next_data, fixes StoneCypher/fsl#1233
    • +
+

 

+

 

+ + +

[Untagged] - 12/2/2022 10:48:55 PM

+ +

Commit 5fa6e48645cb75fcd5fe38e6ff08c0d5d64a7a23

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • nextData underway
    • +
+

 

+

 

+ + + + +

[5.86.3] - 11/12/2022 6:09:16 PM

+ +

Commit dbb82aefc2744729fd17108d33d19f504dc1783e

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Implement override, implement in machine, allow override attribute
    • +
  • Fixes StoneCypher/fsl#1228, fixes StoneCypher/fsl#1222, fixes StoneCypher/fsl#1232
    • +
+

 

+

 

+ + + + +

[5.86.2] - 11/12/2022 12:49:23 PM

+ +

Commit a033eb38e784cbc5c6bf15bef576b69bb935f9b2

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [48b4f92, 99a5fd6]

+
    +
  • Merge pull request #548 from StoneCypher/AllowsOverrideInCompiler
    • +
  • allows override in compiler, constructor config to allow/disallow override, getters for override, cfg override, machine override
    • +
+

 

+

 

+ + +

[Untagged] - 11/12/2022 12:44:20 PM

+ +

Commit 99a5fd66ee5a342814cf34d89fb6dccc2f4ac7e9

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • allows override in compiler, constructor config to allow/disallow override, getters for override, cfg override, machine override
    • +
  • fixes StoneCypher/fsl#1225, fixes StoneCypher/fsl#1227, fixes StoneCypher/fsl#1229, fixes StoneCypher/fsl#1230, fixes StoneCypher/fsl#1231
    • +
+

 

+

 

+ + + + +

[5.86.1] - 11/11/2022 6:41:15 PM

+ +

Commit 48b4f928eb1a4597122b64e6eea38a57c19a112f

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Allow override attribute in grammar, fixes StoneCypher/fsl#1226
    • +
+

 

+

 

+ + + + +

[5.86.0] - 11/11/2022 6:22:48 PM

+ +

Commit 31077c9256ee31f80398460b3af95bc65a8dbc3a

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [793f2fc, 3941c30]

+
    +
  • Merge pull request #547 from StoneCypher/allows_override
    • +
  • .allows_override fixes StoneCypher/fsl#1224
    • +
+

 

+

 

+ + +

[Untagged] - 11/11/2022 6:16:32 PM

+ +

Commit 3941c3000e8544e6b674b4a060abb93a8f5c3455

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • .allows_override fixes StoneCypher/fsl#1224
    • +
+

 

+

 

+ + + + +

[5.85.11] - 9/16/2022 11:15:38 PM

+ +

Commit 793f2fcba840f39cb7442f6be54b0c272caad6ba

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [ab43e02, 03790c9]

+
    +
  • Merge pull request #546 from StoneCypher/uses_forced_transitions
    • +
  • Adds getter method uses_forced_transitions
    • +
+

 

+

 

+ + +

[Untagged] - 9/16/2022 11:15:13 PM

+ +

Commit 03790c9fc38db0ed5cb0ba35d50c4d5d820aafcc

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Adds getter method uses_forced_transitions
    • +
  • Fixes StoneCypher/fsl#1211
    • +
+

 

+

 

+ + + + +

[5.85.10] - 9/16/2022 5:34:40 PM

+ +

Commit ab43e02152256d19579efdb73c9fa6cb04d1b2b3

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [c0c574b, a6026d0]

+
    +
  • Merge pull request #545 from StoneCypher/PullThemesOutIntoModule
    • +
  • Pull themes out into module
    • +
+

 

+

 

+ + +

[Untagged] - 9/16/2022 5:30:09 PM

+ +

Commit a6026d0bdbec44c03303950130ed34df3a78576e

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Pull themes out into module
    • +
  • Fixes StoneCypher/fsl#1210
    • +
+

 

+

 

+ + + + +

[5.85.9] - 9/12/2022 9:15:59 PM

+ +

Commit c0c574b694f1d0511190be139135cdf745f476b7

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [c047caa, 090db83]

+
    +
  • Merge pull request #544 from StoneCypher/PullCompilerOutIntoModule
    • +
  • Pull compiler out into a module
    • +
+

 

+

 

+ + +

[Untagged] - 9/12/2022 9:06:27 PM

+ +

Commit 090db831d8df370b0937d2d37e6372b6df030481

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Pull compiler out into a module
    • +
  • Fixes StoneCypher/fsl#1207
    • +
+

 

+

 

+ + + + +

[5.85.8] - 9/12/2022 8:26:10 PM

+ +

Commit c047caac3f9d9bb24a9c0b517983088eb8ee2e4a

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [581fd8d, 013999a]

+
    +
  • Merge pull request #543 from StoneCypher/PullArrowsOutIntoModules
    • +
  • Pull arrows out into modules
    • +
+

 

+

 

+ + +

[Untagged] - 9/12/2022 8:18:05 PM

+ +

Commit 013999a77ce43ceed5eb982754ffe480fdddf159

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Pull arrows out into modules
    • +
  • Fixes StoneCypher/fsl#1206
    • +
+

 

+

 

+ + + + +

[5.85.7] - 9/12/2022 7:24:25 PM

+ +

Commit 581fd8dc33c4eb2ce190b696d952471abec192ef

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [7d741ba, 771f4c8]

+
    +
  • Merge pull request #542 from StoneCypher/AddUnicodeTestsForLabels
    • +
  • Add unicode tests for labels
    • +
+

 

+

 

+ + +

[Untagged] - 9/12/2022 7:19:21 PM

+ +

Commit 771f4c8d67274b40451ae6dfef168fe3c15949df

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Add tests for unicode labels (atom and string)
    • +
  • Fixes StoneCypher/fsl#1193, fixes StoneCypher/fsl#1194
    • +
+

 

+

 

+ + +

[Untagged] - 9/12/2022 6:52:26 PM

+ +

Commit 3eb246ddb992372ceca4c0adc9dc45295a0a7177

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Return twitter envvar to GHA yaml
    • +
+

 

+

 

+ + +

[Untagged] - 9/12/2022 6:52:26 PM

+ +

Commit 3a01b8d7ae2cee185e4f36c90a95338bf30002cb

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • that wasn't supposed to be removed...
    • +
+

 

+

 

+ + + + +

[5.85.6] - 9/12/2022 6:43:57 PM

+ +

Commit 7d741ba17ccee77138537f732b833efa028dbda7

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [4b9fefd, 37c0bdf]

+
    +
  • Merge pull request #541 from StoneCypher/StartStateRefining
    • +
  • Prevent request of illegal state as start state
    • +
+

 

+

 

+ + +

[Untagged] - 9/12/2022 6:39:19 PM

+ +

Commit 37c0bdf33263bf4b9dd60ba329108297cf5ea68f

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Prevent request of illegal state as start state
    • +
  • Fixes StoneCypher/fsl#1203, fixes StoneCypher/fsl#1204, fixes StoneCypher/fsl#1205
    • +
+

 

+

 

+ + +

[Untagged] - 9/12/2022 3:27:58 PM

+ +

Commit 4b9fefde004f1c1ac5f36ad760105109475af95a

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • expose build date directly on module (also -viz and -demo,) support logging in -demo
    • +
+

 

+

 

+ + + + +

[5.85.5] - 9/12/2022 3:10:10 PM

+ +

Commit 35ad7228d5bb15d963a2e4d9e6e35721cce36b33

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Add build time to module
    • +
+

 

+

 

+ + + + +

[5.85.4] - 9/12/2022 1:55:57 PM

+ +

Commit 293e2cb9c07734fef562b455d786b7c63ea7647b

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Clean up the gh action a skosh
    • +
+

 

+

 

+ + + + +

[5.85.3] - 9/12/2022 11:25:36 AM

+ +

Commit 87ec233d3511d30358660ad161f932e13eb1738e

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [98b7b14, 6475296]

+
    +
  • Merge pull request #540 from StoneCypher/ReintroduceDisplayText
    • +
  • Reintroduce display text, lost in a bad merge
    • +
+

 

+

 

+ + +

[Untagged] - 9/12/2022 11:24:38 AM

+ +

Commit 6475296d979dab3d227828b80319d60c4f6ab2f5

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Reintroduce display text, lost in a bad merge
    • +
+

 

+

 

+ + + + +

[5.85.2] - 9/12/2022 10:03:27 AM

+ +

Commit 98b7b14217ea7e83550e4ed15b6b6be80799e246

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [461a287, 0f3025a]

+
    +
  • Merge pull request #539 from StoneCypher/TrimTweet
    • +
  • Shorten the tweet notice
    • +
+

 

+

 

+ + +

[Untagged] - 9/12/2022 9:59:52 AM

+ +

Commit 0f3025ae2e484afbda57b5f39f5485c4831e7ce7

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Shorten the tweet notice
    • +
+

 

+

 

+ + + + +

[5.85.1] - 9/12/2022 9:49:05 AM

+ +

Commit 461a2874583d08da6db68e40b75047682625c73d

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [2eec2c8, 76d6729]

+
    +
  • Merge pull request #538 from StoneCypher/RemoveYmlEcho
    • +
  • Remove noisy echo in the YML
    • +
+

 

+

 

+ + +

[Untagged] - 9/12/2022 9:35:11 AM

+ +

Commit 76d6729a35a3f4eba666ff2d78cd284ed0668edd

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Remove noisy echo in the YML
    • +
+

 

+

 

+ + + + +

[5.85.0] - 9/12/2022 9:22:37 AM

+ +

Commit 2eec2c8b69d3e59cb06d7b0efc34b336e9ecc29a

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [a7b92f9, a0b9fb5]

+
    +
  • Merge pull request #537 from StoneCypher/DisplayText
    • +
  • simple display text function to resolve labels and node names
    • +
+

 

+

 

+ + +

[Untagged] - 9/12/2022 9:17:28 AM

+ +

Commit a0b9fb59c5dc92c94738a6d456ef5e5514a48d1f

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • simple display text function to resolve labels and node names
    • +
  • fixes StoneCypher/fsl#1202
    • +
+

 

+

 

+ + + + +

[5.84.1] - 9/12/2022 8:30:09 AM

+ +

Commit a7b92f9b1e94dcab843ab588d83d0c5f8eb9ca18

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [d4e6196, eedb4a7]

+
    +
  • Merge pull request #536 from StoneCypher/MoreStabsAtTweeting
    • +
  • Working on auto-tweeter; no associated issue
    • +
+

 

+

 

+ + +

[Untagged] - 9/12/2022 8:26:02 AM

+ +

Commit eedb4a7d6ea5392a252cf6dbe5bc2e6e3239591c

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Working on auto-tweeter; no associated issue
    • +
+

 

+

 

+ + + + +

[5.84.0] - 9/12/2022 7:41:49 AM

+ +

Commit d4e619611a04f24b76ad783a9b0f34393e45840a

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [cdaa32e, 9193c2d]

+
    +
  • Merge pull request #535 from StoneCypher/RenameParserAlready
    • +
  • Change parser name to fsl_parser, fixes StoneCypher/fsl#1201; another stab at Twitter
    • +
+

 

+

 

+ + +

[Untagged] - 9/12/2022 7:35:32 AM

+ +

Commit 9193c2d1f27f1c80ed4a3bfb41e586f5da24179a

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Change parser name to fsl_parser, fixes StoneCypher/fsl#1201; another stab at Twitter
    • +
+

 

+

 

+ + + + +

[5.83.2] - 9/11/2022 3:39:14 PM

+ +

Commit cdaa32e418ddf2f094fe5ab2adbc1a0a0b65a2d7

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • reduce-to-639-1 needs to be a dependency for downstream builds
    • +
+

 

+

 

+ + + + +

[5.83.1] - 9/11/2022 2:24:06 PM

+ +

Commit c46d677560dc06baf33c2088205051fedaf5be04

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [3256f05, 991d2dc]

+
    +
  • Merge pull request #534 from StoneCypher/BoldTheme
    • +
  • Add a bold theme
    • +
+

 

+

 

+ + +

[Untagged] - 9/11/2022 2:19:28 PM

+ +

Commit 991d2dcf113bd19026f037e6eb22f46eacde57aa

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Add a bold theme
    • +
+

 

+

 

+ + + + +

[5.83.0] - 9/3/2022 5:34:01 PM

+ +

Commit 3256f05a4f2b5c5d6e05c2eeba091899e73ef327

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [51ebcfc, 216dc9c]

+
    +
  • Merge pull request #533 from StoneCypher/AttemptToFixAstral
    • +
  • Attempt to fix astral
    • +
+

 

+

 

+ + +

[Untagged] - 9/3/2022 5:30:23 PM

+ +

Commit 216dc9cb659d634a6be9510264f48c26e8a471c0

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Need to make before the unicode tests
    • +
+

 

+

 

+ + +

[Untagged] - 9/3/2022 5:27:18 PM

+ +

Commit 7878070213ea189def19419eefa4a37ceff701c1

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Get the script names right in the yaml
    • +
+

 

+

 

+ + +

[Untagged] - 9/3/2022 5:25:50 PM

+ +

Commit ead26fe40eeb115a87de151b6d91fc83e9aab2b9

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Needed a version bump
    • +
+

 

+

 

+ + +

[Untagged] - 9/3/2022 5:21:12 PM

+ +

Commit 4deaa1ebabb4bbc3604103a3bcdde77259247fe7

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Unicode range tests for actions, very slow, fixes StoneCypher/fsl#1192
    • +
+

 

+

 

+ + +

[Untagged] - 9/3/2022 5:16:16 PM

+ +

Commit 72c4ac7e754ab32fe3ca2372fff1733ba8363b27

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Unicode range tests for atoms and strings, very slow, fixes StoneCypher/fsl#1190, fixes StoneCypher/fsl#1191
    • +
+

 

+

 

+ + +

[Untagged] - 9/3/2022 3:23:46 PM

+ +

Commit 54adb9e46e56254596ca0a710492d3ecf633ea85

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • on the way to unicode testing
    • +
+

 

+

 

+ + +

[Untagged] - 9/1/2022 7:14:42 PM

+ +

Commit 51ebcfc1ec163b8590d1a1a2065dcd8ad0458cc9

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [94c4f37, 3557437]

+
    +
  • Merge pull request #530 from machinshin/feature/new-readme
    • +
  • more-readable README
    • +
+

 

+

 

+ + +

[Untagged] - 9/1/2022 7:13:51 PM

+ +

Commit 35574377c523d8f48198b30ef77b12a5efe72b6c

+

Author: Vat Raghavan <machinshin@gmail.com>

+
    +
  • remake package-lock & upversion
    • +
+

 

+

 

+ + +

[Untagged] - 9/1/2022 7:05:32 PM

+ +

Commit c7bb4b01d3b5475d9ccb91ff7999556ef39e8805

+

Author: Vat Raghavan <machinshin@gmail.com>

+
    +
  • re-build
    • +
+

 

+

 

+ + +

[Untagged] - 9/1/2022 6:59:27 PM

+ +

Commit d916b2fe3b67c66ad6c47eef1df6dcfd9863d247

+

Author: Vat Raghavan <machinshin@gmail.com>

+
    +
  • update version number
    • +
+

 

+

 

+ + +

[Untagged] - 9/1/2022 6:56:09 PM

+ +

Commit 50b5d8b1a4efce1c7359f713a02cb0477abd7d4a

+

Author: Vat Raghavan <machinshin@gmail.com>

+

Merges [9e18022, 94c4f37]

+
    +
  • Merge branch 'main' into feature/new-readme
    • +
+

 

+

 

+ + + + +

[5.82.5] - 9/1/2022 6:44:36 PM

+ +

Commit 94c4f37805eea9179474c66011155368e6c4ed31

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [a307163, cf1cb12]

+
    +
  • Merge pull request #532 from machinshin/feature/shootout/all-inline
    • +
  • all example links are inline-d
    • +
+

 

+

 

+ + +

[Untagged] - 9/1/2022 6:41:25 PM

+ +

Commit cf1cb122a9f86e943258ce58ffe490e27d401319

+

Author: Vat Raghavan <machinshin@gmail.com>

+

Merges [1f69c53, a307163]

+
    +
  • Merge branch 'main' into feature/shootout/all-inline
    • +
+

 

+

 

+ + +

[Untagged] - 9/1/2022 6:08:10 PM

+ +

Commit 1f69c53f4d3851f205896c446c65e9ecdbf26bbc

+

Author: Vat Raghavan <machinshin@gmail.com>

+
    +
  • all example links are inline-d
    • +
+

 

+

 

+ + + + +

[5.82.4] - 9/1/2022 6:04:35 PM

+ +

Commit a307163e979abf8af53e4936f972c017f91198ba

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • add spurious single type return to theme getter to agree with the setter type, fixes StoneCypher/fsl#1189
    • +
+

 

+

 

+ + + + +

[5.82.3] - 9/1/2022 5:26:59 PM

+ +

Commit 58751e614c6f3f9223239af91f44079ee3a1f045

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [da69e65, a824b2f]

+
    +
  • Merge pull request #531 from machinshin/feature/shootout-inline-links
    • +
  • relative link to code in Shootout.md
    • +
+

 

+

 

+ + +

[Untagged] - 9/1/2022 5:06:20 PM

+ +

Commit a824b2fea98113f5c1ff04227ff4261a41e8634e

+

Author: Vat Raghavan <machinshin@gmail.com>

+
    +
  • all toggle examples are inline-linked
    • +
+

 

+

 

+ + +

[Untagged] - 9/1/2022 4:53:34 PM

+ +

Commit 07e19355674ecf8c44ceb54f31cafebefdf08921

+

Author: Vat Raghavan <machinshin@gmail.com>

+
    +
  • relative link to code in Shootout.md
    • +
+

 

+

 

+ + + + +

[5.82.2] - 9/1/2022 4:17:04 PM

+ +

Commit da69e65ee5a1567825b011d3e17655c2dbd6261d

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • re-enable stoch testing, fixes StoneCypher/fsl#1187; replace .replaceAll with .replace, fixes StoneCypher/fsl#1188
    • +
+

 

+

 

+ + +

[Untagged] - 9/1/2022 3:57:04 PM

+ +

Commit 9e18022f7b474f06e30df55df254f01a0bf6ceb6

+

Author: Vat Raghavan <machinshin@gmail.com>

+
    +
  • more-readable README
    • +
+

 

+

 

+ + + + +

[5.82.1] - 8/20/2022 11:19:53 AM

+ +

Commit 27480ec9b23dc281db0212e68f53aabcdc8b946f

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [5278df4, 03e1ad3]

+
    +
  • Merge pull request #529 from StoneCypher/ExposeThemesAndDirections
    • +
  • Expose themes and directions; fixes StoneCypher/fsl#540, fixes StoneCypher/fsl#541
    • +
+

 

+

 

+ + +

[Untagged] - 8/20/2022 11:16:34 AM

+ +

Commit 03e1ad3acf5074dd570eb9a2e2001abab10fb923

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Expose themes and directions; fixes StoneCypher/fsl#540, fixes StoneCypher/fsl#541
    • +
+

 

+

 

+ + + + +

[5.82.0] - 8/19/2022 11:11:19 PM

+ +

Commit 5278df4d94a347b37da6cdca2a64a6ca85665b42

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [72d6ef7, 88d7309]

+
    +
  • Merge pull request #528 from StoneCypher/SpinUpThemes
    • +
  • Spin up themes
    • +
+

 

+

 

+ + +

[Untagged] - 8/19/2022 11:04:20 PM

+ +

Commit 88d7309bfd2217fe9aeae3be681ae1f520542365

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Multiple themes, fixes StoneCypher/fsl#128
    • +
+

 

+

 

+ + +

[Untagged] - 8/19/2022 8:44:55 PM

+ +

Commit 2cf5a3f8121a68db58bba992e85b95a8b0e6315e

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • coverage pass prior to multitheme
    • +
+

 

+

 

+ + +

[Untagged] - 8/18/2022 10:12:07 PM

+ +

Commit 2f81a2682202a239acc8acbefe0360e3481c8ca9

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • draft themes in place
    • +
+

 

+

 

+ + +

[Untagged] - 8/17/2022 10:02:39 PM

+ +

Commit 9209392cd7e025b365da88aa29649c63b241074d

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • mostly done, just have to surface the themes then do testing
    • +
+

 

+

 

+ + + + +

[5.81.2] - 8/14/2022 4:22:34 PM

+ +

Commit 72d6ef77839234d9763ba3c5e667f0eb5ef43951

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Clarify composite style type before we start work on themes
    • +
+

 

+

 

+ + +

[Untagged] - 8/11/2022 9:01:49 PM

+ +

Commit df1dd4c1d190b6571cf43637183b831229793eba

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Small type changes preparing for theme
    • +
+

 

+

 

+ + + + +

[5.81.0] - 8/10/2022 11:32:42 PM

+ +

Commit 5162f2299530514aecba1bf78fbfe77910e3a417

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Engine and parser support for label substitution (no viz yet,) fixes StoneCypher/fsl#117; fixes StoneCypher/fsl#263
    • +
+

 

+

 

+ + +

[Untagged] - 8/10/2022 10:25:03 PM

+ +

Commit bab9f160ae1dab672a2800c175c21fed2e74f48e

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [59e95d8, c3939c3]

+
    +
  • Merge branch 'main' of github.com:StoneCypher/jssm
    • +
+

 

+

 

+ + +

[Untagged] - 8/10/2022 10:24:55 PM

+ +

Commit 59e95d8d4c06a63fb51b0c886d23612a4835ccfc

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • tests for property overriding from inline and for border lines
    • +
+

 

+

 

+ + + + +

[5.80.1] - 8/7/2022 11:57:01 PM

+ +

Commit c3939c3486d8ae2338385de375d753ef5a38673d

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [6cb2816, b59b5b5]

+
    +
  • Merge pull request #527 from StoneCypher/AddInlineStylesToResolver
    • +
  • Adds inline styles to resolver, fixes StoneCypher/fsl#1160
    • +
+

 

+

 

+ + +

[Untagged] - 8/7/2022 11:52:57 PM

+ +

Commit b59b5b530de566d82b6fa707d66f9b5ceb2037e8

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Adds inline styles to resolver, fixes StoneCypher/fsl#1160
    • +
+

 

+

 

+ + + + +

[5.80.0] - 8/4/2022 9:37:11 PM

+ +

Commit 6cb281616eaa3d70bc0ff4e14410c5caa07f70f2

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [4d79b09, ed398d3]

+
    +
  • Merge pull request #526 from StoneCypher/SupportForStartAndEndStateStyling
    • +
  • Support for start and end state styling
    • +
+

 

+

 

+ + +

[Untagged] - 8/4/2022 9:29:52 PM

+ +

Commit ed398d3627e63b7b64d009acb42779b814e2f6da

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • tests
    • +
+

 

+

 

+ + +

[Untagged] - 8/4/2022 9:15:50 PM

+ +

Commit 63304cd9d1dd4ea5801edb6437f361023e3d6c32

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Styling now works for start, end, and terminal state types too. Fixes StoneCypher/fsl#1143, fixes StoneCypher/fsl#1141, fixes StoneCypher/fsl#1156, fixes StoneCypher/fsl#1157, fixes StoneCypher/fsl#242
    • +
+

 

+

 

+ + +

[Untagged] - 8/4/2022 1:50:52 AM

+ +

Commit 89948de7b9857909a6132c95cd6019be08e82d18

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Semi-working implementation of style condensation, fixes StoneCypher/fsl#1141; added base stylesheet, fixes StoneCypher/fsl#1142
    • +
+

 

+

 

+ + +

[Untagged] - 8/2/2022 3:50:45 PM

+ +

Commit 9001216af66f3fc719a406402d1d07f66cea465c

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Six style modalities exposed, fixes StoneCypher/fsl#1136, fixes StoneCypher/fsl#1137, fixes StoneCypher/fsl#1138, fixes StoneCypher/fsl#1139, fixes StoneCypher/fsl#1140
    • +
+

 

+

 

+ + +

[Untagged] - 8/1/2022 12:08:55 PM

+ +

Commit 1c4fcaaf1b15087b8d2aaa4fcf08ee386fb7c90c

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • all six state styles (start end standard hooked terminal current) now make it through to the machine, fixes StoneCypher/fsl#1131, fixes StoneCypher/fsl#1132, fixes StoneCypher/fsl#1133, fixes StoneCypher/fsl#1134, fixes StoneCypher/fsl#1135
    • +
+

 

+

 

+ + + + +

[5.79.18] - 7/28/2022 11:21:27 PM

+ +

Commit 4d79b09ceed3385fbfd237092c5befd0b120f589

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Compile benchmark, fixes StoneCypher/fsl#1130
    • +
+

 

+

 

+ + + + +

[5.79.17] - 7/28/2022 10:21:48 PM

+ +

Commit 80a5f0821ce4e866bfdb6ed9123ee3e409fdfd99

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Definitions for language features in feature comparison matrix
    • +
+

 

+

 

+ + + + +

[5.79.16] - 7/28/2022 7:04:27 PM

+ +

Commit a76a9d87b7f1d691e982d9b5da8a5bc0d68fc1ea

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [3cceb0a, 3363432]

+
    +
  • Merge pull request #525 from StoneCypher/FinishComparisonMatrix
    • +
  • Adds stent, fsm, fsm-event, node-state, state-machine, stately.js to feature comparison table, fixes StoneCypher/fsl#1118, fixes StoneCypher/fsl#1119, fixes StoneCypher/fsl#1120, fixes StoneCypher/fsl#1121, fixes StoneCypher/fsl#1122, fixes StoneCypher/fsl#1123
    • +
+

 

+

 

+ + +

[Untagged] - 7/28/2022 7:01:10 PM

+ +

Commit 3363432b1abe446798ca41beff6ce7a9f3b6cee6

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Adds stent, fsm, fsm-event, node-state, state-machine, stately.js, node-state to feature comparison table, fixes StoneCypher/fsl#1118, fixes StoneCypher/fsl#1119, fixes StoneCypher/fsl#1120, fixes StoneCypher/fsl#1121, fixes StoneCypher/fsl#1122, fixes StoneCypher/fsl#1123
    • +
+

 

+

 

+ + + + +

[5.79.15] - 7/28/2022 3:47:24 PM

+ +

Commit 3cceb0ab8a9d56f7f3cd79b6ff64beb882e7bc86

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [bc39f54, 3ace82f]

+
    +
  • Merge pull request #524 from StoneCypher/MoreTryingToFixTwitterTweeter
    • +
  • More trying to fix twitter tweeter
    • +
+

 

+

 

+ + +

[Untagged] - 7/28/2022 3:37:38 PM

+ +

Commit 3ace82f3e03403765c72ffda4e4e8819bcd1e1ca

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Working on the Twitter release message
    • +
+

 

+

 

+ + +

[Untagged] - 7/28/2022 3:28:23 PM

+ +

Commit bc39f54865c2eb421261ee1a6ff9e3f6cc3f0b66

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [98eb7eb, 6324d89]

+
    +
  • Merge pull request #523 from StoneCypher/MoreComparisonChart
    • +
  • More comparison chart
    • +
+

 

+

 

+ + +

[Untagged] - 7/28/2022 3:25:12 PM

+ +

Commit 6483abdffc869f010f866110c55295da1bee022d

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [6324d89, 98eb7eb]

+
    +
  • Merge branch 'main' into MoreComparisonChart
    • +
+

 

+

 

+ + +

[Untagged] - 7/28/2022 3:24:41 PM

+ +

Commit 6324d89f41053d8129df931d56ef4a0fdf499500

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • try to fix the broken publish env
    • +
+

 

+

 

+ + +

[Untagged] - 7/28/2022 3:19:37 PM

+ +

Commit 915482bf57474c05cb0b8722e89d782eda4ea61c

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Adds machina, finity, fsm-iterator, fsm-as-promised to feature comparison table, fixes StoneCypher/fsl#1114, fixes StoneCypher/fsl#1115, fixes StoneCypher/fsl#1116, fixes StoneCypher/fsl#1117
    • +
+

 

+

 

+ + +

[Untagged] - 7/28/2022 1:46:09 PM

+ +

Commit 98eb7eb745ed5b8593e7695764ddee37eb8ecf9e

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [66cbb1d, 16920b1]

+
    +
  • Merge pull request #522 from StoneCypher/MoreComparisonChart
    • +
  • More comparison chart
    • +
+

 

+

 

+ + +

[Untagged] - 7/28/2022 1:45:17 PM

+ +

Commit 16920b102b96a8cc4e3db44abb5b17b716940090

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Adds robot3 to feature comparison table, fixes StoneCypher/fsl#1124
    • +
+

 

+

 

+ + +

[Untagged] - 7/28/2022 1:02:26 PM

+ +

Commit 6a7684e3a0b665e3c7b7f38e6adda08c09d18c1c

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Adds mood to feature comparison table, fixes StoneCypher/fsl#1125
    • +
+

 

+

 

+ + +

[Untagged] - 7/28/2022 12:52:20 PM

+ +

Commit b49af31975f4424923024f2cef459a975240a98e

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Add grammar-graph to comparison, fixes StoneCypher/fsl#1126
    • +
+

 

+

 

+ + + + +

[5.79.11] - 7/28/2022 8:22:55 AM

+ +

Commit 66cbb1d35679c7271a08bc31ab3a7b2557a15f3e

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Add javascript-state-machine to feature comparison, fixes StoneCypher/fsl#1113
    • +
+

 

+

 

+ + + + +

[5.79.10] - 7/27/2022 11:44:10 PM

+ +

Commit aa5e666f5f02e5fc0c6818dd7fb84dd689dc0448

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Feature comparison table, shots fired, fixes StoneCypher/fsl#839, fixes StoneCypher/fsl#643
    • +
+

 

+

 

+ + +

[Untagged] - 7/27/2022 10:21:23 PM

+ +

Commit 2f548fc2c2c8e02d9ac5da5279a6c8d69130316f

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • first sketch of feature comparison
    • +
+

 

+

 

+ + +

[Untagged] - 7/25/2022 11:11:11 AM

+ +

Commit d0a4b3e731b887da477f2dde109a5d57b39522b3

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Delete example-machine-template.md
    • +
+

 

+

 

+ + +

[Untagged] - 7/25/2022 11:09:21 AM

+ +

Commit 572a8a1e14f4b29a1bb021e9b76124d74959e59b

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Delete feature-requesting-template.md
    • +
+

 

+

 

+ + +

[Untagged] - 7/25/2022 11:09:07 AM

+ +

Commit 7379b2324c15a44ca98311121408b771d165b68a

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Delete bug-reporting-template.md
    • +
+

 

+

 

+ + +

[Untagged] - 7/25/2022 11:08:28 AM

+ +

Commit 412cabb32d87ffd91752ba5006c59e4b1867a469

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Create config.yml
    • +
+

 

+

 

+ + + + +

[5.79.9] - 7/25/2022 5:41:07 AM

+ +

Commit 014cafc52c34afb19f50e8ab60741ee8585b1213

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • centralize prior to tree tool
    • +
+

 

+

 

+ + + + +

[5.79.8] - 7/22/2022 12:23:51 AM

+ +

Commit 2c1ab4f936b061a7ffe46187f45fdc3949b3eb1f

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Expose a load of math constants; create a constants namespace. Leave the old ones in both places for compat. Fixes StoneCypher/fsl#1043, StoneCypher/fsl#1044, StoneCypher/fsl#1045, StoneCypher/fsl#1046, StoneCypher/fsl#1047, StoneCypher/fsl#1048, StoneCypher/fsl#1049, StoneCypher/fsl#1050, StoneCypher/fsl#1058, StoneCypher/fsl#1059, StoneCypher/fsl#1060, StoneCypher/fsl#1061, StoneCypher/fsl#1062, StoneCypher/fsl#1063, StoneCypher/fsl#1064, StoneCypher/fsl#1065, StoneCypher/fsl#1066
    • +
+

 

+

 

+ + + + +

[5.79.6] - 7/21/2022 11:56:00 PM

+ +

Commit e91095dc64dacebab0dafe96180219998e0d2891

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • add newline in gha envvar to support twitter action
    • +
+

 

+

 

+ + +

[Untagged] - 7/21/2022 11:03:43 PM

+ +

Commit a2a45dbfda6df7012651a55aa65f8e606c0a8768

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [3bf5c1d, 277683b]

+
    +
  • Merge pull request #521 from StoneCypher/StartTweetingInGha
    • +
  • improved tweet system, fixed gh action non-install
    • +
+

 

+

 

+ + +

[Untagged] - 7/21/2022 10:58:51 PM

+ +

Commit 277683b9ba40288005a0bf2d7044dea84696ac01

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • improved tweet system, fixed gh action non-install
    • +
+

 

+

 

+ + + + +

[5.79.4] - 7/21/2022 10:39:56 PM

+ +

Commit 3bf5c1d061d67524c5f97279a854473d9989e92b

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [02bf1ff, 39f3906]

+
    +
  • Merge pull request #520 from StoneCypher/StartTweetingInGha
    • +
  • Start tweeting in gha
    • +
+

 

+

 

+ + +

[Untagged] - 7/21/2022 10:35:56 PM

+ +

Commit 39f390677155346d07f55264f006c1067932670f

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Bump, rebuild
    • +
+

 

+

 

+ + +

[Untagged] - 7/21/2022 10:33:47 PM

+ +

Commit 03f81a35f2c158b1139589bb67fd230fa46be3be

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Automate GHA tweeting of releases to @FSL_and_JSSM; bump terser; fix protocol on youtube links
    • +
+

 

+

 

+ + + + +

[5.79.3] - 7/18/2022 6:41:12 PM

+ +

Commit 02bf1ff5ef650323c2ad5d4a54d2c21caf0f272a

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • changing to a protocol-free url in docs to get youtube vids to load, test 1
    • +
+

 

+

 

+ + + + +

[5.79.2] - 7/14/2022 11:39:18 PM

+ +

Commit 9f4e86c883c6bb776817da84ba3fe77473f47427

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [f756f21, 3a127c6]

+
    +
  • Merge pull request #518 from StoneCypher/RequiredProperties
    • +
  • Property requirement, fixes StoneCypher/fsl#1041
    • +
+

 

+

 

+ + +

[Untagged] - 7/14/2022 11:31:58 PM

+ +

Commit 3a127c6201604ec2323d72adabf72c07dd1425e3

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • caught a typo
    • +
+

 

+

 

+ + +

[Untagged] - 7/14/2022 11:26:20 PM

+ +

Commit 0a97cd4664b15047b265bd0bf72fd7da79b2d528

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Property requirement, fixes StoneCypher/fsl#1041
    • +
+

 

+

 

+ + + + +

[5.79.1] - 7/14/2022 2:45:12 PM

+ +

Commit f756f219a0b8ca95feae287a110261dc364030cc

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [ed93695, e2cc7d1]

+
    +
  • Merge pull request #517 from StoneCypher/StrictProp
    • +
  • .strict_prop, fixes StoneCypher/fsl#1037; tests to enforce, fixes StoneCypher/fsl#1035
    • +
+

 

+

 

+ + +

[Untagged] - 7/14/2022 2:37:44 PM

+ +

Commit e2cc7d1c49c6507572d26c30ff069aee19167eec

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • .strict_prop, fixes StoneCypher/fsl#1037; tests to enforce, fixes StoneCypher/fsl#1035
    • +
+

 

+

 

+ + + + +

[5.79.0] - 7/13/2022 9:32:13 PM

+ +

Commit ed936950b132042aeb299c02ad199fe84d5f41f5

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [7e9fc0d, d28ab5a]

+
    +
  • Merge pull request #516 from StoneCypher/Properties
    • +
  • Properties
    • +
+

 

+

 

+ + +

[Untagged] - 7/13/2022 6:41:37 PM

+ +

Commit d28ab5a2a576d25bf45d5fd2f55895441a10cd99

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • State properties make it to machine, fixes StoneCypher/fsl#1040; overrides, fixes StoneCypher/fsl#1023
    • +
+

 

+

 

+ + +

[Untagged] - 7/13/2022 2:23:16 PM

+ +

Commit ef4f483808e5aff64c4dee0ffac1472ac9202c4b

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • .props, fixes StoneCypher/fsl#1019; state props make it through compiler, fixes StoneCypher/fsl#1029; lots of doc improvements, numeric constants
    • +

 

 

- + +

[Untagged] - 7/13/2022 2:20:10 PM

+ +

Commit 7814c864c7bffeeb755bc0f3d7ec1faf8e4a965d

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • State properties in grammar, fixes StoneCypher/fsl#1030, fixes StoneCypher/fsl#1031, fixes StoneCypher/fsl#1032, fixes StoneCypher/fsl#1033, fixes StoneCypher/fsl#1034
    • +
+

 

+

 

- -

[5.76.2] - 7/6/2022 8:27:33 AM

+ +

[Untagged] - 7/13/2022 9:06:10 AM

 -

Commit d1b55ae8944031677c228f06eec6a5a28eb695ac

+

Commit 1349b752fd40db754dfa760bfb60b16646ef5108

Author: John Haugeland <stonecypher@gmail.com>

-

Merges [813d866, 40677c7]

    -
  • Merge pull request #510 from StoneCypher/BumpCloc
    • -
  • Bump CLOC, fixes StoneCypher/fsl#995
    • +
  • known_prop, fixes StoneCypher/fsl#1021

 

 

- -

[Untagged] - 7/5/2022 1:24:10 PM

+ +

[Untagged] - 7/13/2022 8:14:19 AM

 -

Commit 40677c744241e590d901c317cdcc0046833a5257

+

Commit c7191c8ba796bd21cb2ba123038b9c6b5b274057

Author: John Haugeland <stonecypher@gmail.com>

    -
  • Uh, you have to git add to git commit, dummy
    • +
  • Default props now making it into machine, fixes StoneCypher/fsl#1039; datastructures, fixes StoneCypher/fsl#1022
    • +
+

 

+

 

+ + +

[Untagged] - 7/12/2022 10:05:06 AM

+ +

Commit 1629741f34d564706e6c91f8cfc60edcfdd379bb

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Default properties now make it through compiler, fixes StoneCypher/fsl#1028; blocks repetition, fixes StoneCypher/fsl#1038
    • +
+

 

+

 

+ + +

[Untagged] - 7/11/2022 10:38:54 PM

+ +

Commit fd306ed88144815a2d2fb26250709d4fba8f99fe

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Basic machine properties now making it through aggregation
    • +
+

 

+

 

+ + +

[Untagged] - 7/11/2022 10:10:29 PM

+ +

Commit 400cbe62582aa2261b694f01e0d04704a76a12ef

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Basic tests for property defaults
    • +
+

 

+

 

+ + +

[Untagged] - 7/11/2022 9:55:08 PM

+ +

Commit 31425dd227fa0811e387d96f89e40e2c0e148df3

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Internal property datastructures, fixes StoneCypher/fsl#1022, getting started with StoneCypher/fsl#1018
    • +
+

 

+

 

+ + + + +

[5.78.0] - 7/9/2022 4:22:51 PM

+ +

Commit 7e9fc0d832e0e46b477e27758183cc6ffc288916

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [6497ed4, 1e742f0]

+
    +
  • Merge pull request #514 from StoneCypher/Serialize
    • +
  • Serialize
    • +
+

 

+

 

+ + +

[Untagged] - 7/9/2022 3:50:44 PM

+ +

Commit 1e742f089c9d0d012691abe9cc6db82d54925469

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Draft implementation of serialization and deserialization. Fixes StoneCypher/fsl#1000, fixes StoneCypher/fsl#1001, fixes StoneCypher/fsl#1002, fixes StoneCypher/fsl#1003, fixes StoneCypher/fsl#1004, fixes StoneCypher/fsl#1005, fixes StoneCypher/fsl#1006, fixes StoneCypher/fsl#1009, fixes StoneCypher/fsl#1011, fixes StoneCypher/fsl#1012
    • +
+

 

+

 

+ + +

[Untagged] - 7/9/2022 1:00:20 PM

+ +

Commit 05c1f81f02406cb3211e3d2bd84eefb2da201b3e

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Spec underway
    • +
+

 

+

 

+ + + + +

[5.77.1] - 7/7/2022 10:36:21 PM

+ +

Commit 6497ed49a6a7dbe55509ac552cc30adb9ee19c9c

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [e9400bd, 4623580]

+
    +
  • Merge pull request #512 from StoneCypher/SynonymDoForAction
    • +
  • Define do/1 to be a synonym for action/1, fixes StoneCypher/fsl#809
    • +
+

 

+

 

+ + +

[Untagged] - 7/7/2022 10:18:20 PM

+ +

Commit 462358017970f5d968d8309ba8ee96d74648ec03

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Define do/1 to be a synonym for action/1, fixes StoneCypher/fsl#809
    • +
+

 

+

 

+ + + + +

[5.77.0] - 7/7/2022 10:18:06 PM

+ +

Commit e9400bd62c93201bcc34a002469e21910979cb2e

+

Author: John Haugeland <stonecypher@gmail.com>

+

Merges [d1b55ae, 2c633a6]

+
    +
  • Merge pull request #511 from StoneCypher/SynonymGoForTransition
    • +
  • Define go/1 to be a synonym for transition/1, fixes StoneCypher/fsl#810
    • +
+

 

+

 

+ + +

[Untagged] - 7/7/2022 10:11:44 PM

+ +

Commit 2c633a61b2ee0f13583ddc85923596f6b473abe6

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • Define go/1 to be a synonym for transition/1, fixes StoneCypher/fsl#810
    • +
+

 

+

 

+ + +

[Untagged] - 7/7/2022 12:29:56 PM

+ +

Commit d29b22488e10f3ee798b7ecb23598654fe987fb8

+

Author: John Haugeland <stonecypher@gmail.com>

+
    +
  • it seems the bundling error I was facing when Discord insisted I just didn't get it might be a bug in deno

 

 

+ - -

[Untagged] - 7/5/2022 1:04:10 PM

+ + +

[5.76.2] - 7/6/2022 8:27:33 AM

 -

Commit 58e88fec3f6412cadfc762f646ed50f6bc10eac6

+

Commit d1b55ae8944031677c228f06eec6a5a28eb695ac

Author: John Haugeland <stonecypher@gmail.com>

-

Merges [1cc0629, 0cc8f7b]

+

Merges [813d866, 40677c7]

    -
  • WIP on IntroducingTheKitchenSinkDragon: 1cc0629 Sequester the stoch tests until they're more complete
    • +
  • Merge pull request #510 from StoneCypher/BumpCloc
    • +
  • Bump CLOC, fixes StoneCypher/fsl#995

 

 

- -

[Untagged] - 7/5/2022 1:04:10 PM

+ +

[Untagged] - 7/5/2022 1:24:10 PM

 -

Commit 0cc8f7bad92e4327128237bc9600cedd2e7cbb94

+

Commit 40677c744241e590d901c317cdcc0046833a5257

Author: John Haugeland <stonecypher@gmail.com>

    -
  • index on IntroducingTheKitchenSinkDragon: 1cc0629 Sequester the stoch tests until they're more complete
    • +
  • Uh, you have to git add to git commit, dummy

 

 

@@ -171,17 +1827,6 @@

[Untagged] - 7/3/2022 11:42:38 AM

 

 

- -

[Untagged] - 7/3/2022 11:41:29 AM

- -

Commit 7bf27e64e929c449d613d461fd1de1ceee4e8183

-

Author: John Haugeland <stonecypher@gmail.com>

-
    -
  • Force this directory to exist with a meaningles file that defies the gitignore, then roll version back because apparently .0 didn't get released
    • -
-

 

-

 

-

[Untagged] - 7/3/2022 11:41:18 AM

 @@ -214,28 +1859,6 @@

[Untagged] - 7/3/2022 10:08:02 AM

 

 

- - -

[Untagged] - 7/3/2022 10:08:02 AM

- -

Commit 986fd0dd50adcb739f54e4fa3712628c94004505

-

Author: John Haugeland <stonecypher@gmail.com>

-
    -
  • added cloc, turned to disk, made a cute little reporter, fixes StoneCypher/fsl#985
    • -
-

 

-

 

- - -

[Untagged] - 7/3/2022 10:08:02 AM

- -

Commit 0c34b68d5a5d6666895965e5f8b4b9a9dadfe397

-

Author: John Haugeland <stonecypher@gmail.com>

-
    -
  • added cloc, turned to disk, made a cute little reporter, fixes StoneCypher/fsl#985
    • -
-

 

-

 

@@ -1691,17 +3314,6 @@

[Untagged] - 5/22/2022 9:07:03 AM

 

 

- - -

[Untagged] - 5/22/2022 9:07:03 AM

- -

Commit 4dbe3833d503a7f5af7563e487ab6f722b01220f

-

Author: John Haugeland <stonecypher@gmail.com>

-
    -
  • Document arr_uniq_p; fix merge mess
    • -
-

 

-

 

@@ -1718,50 +3330,6 @@

[5.65.4] - 5/22/2022 8:52:51 AM

 

 

- -

[Untagged] - 5/22/2022 8:52:35 AM

- -

Commit 9c6982187896ea62e1a7bdc989d4d16e57975f8a

-

Author: John Haugeland <stonecypher@gmail.com>

-
    -
  • Document hook_name, fixes StoneCypher/#788, and named_hook_name, fixes StoneCypher/#789
    • -
-

 

-

 

- - -

[Untagged] - 5/22/2022 8:43:42 AM

- -

Commit cc3b7dda265226ef7ca818d387c06628132673ef

-

Author: John Haugeland <stonecypher@gmail.com>

-
    -
  • document seq/1, document histo/1, a little extra testing, fixes StoneCypher/fsl#786, fixes StoneCypher/fsl#787
    • -
-

 

-

 

- - -

[Untagged] - 5/22/2022 8:43:42 AM

- -

Commit 9dbc57da37b83d3fc2a26c7de17aae8fe976a025

-

Author: John Haugeland <stonecypher@gmail.com>

-
    -
  • document seq/1, document histo/1, a little extra testing
    • -
-

 

-

 

- - -

[Untagged] - 5/22/2022 8:43:42 AM

- -

Commit 780cc714651030e2a89343620dff20669d317e62

-

Author: John Haugeland <stonecypher@gmail.com>

-
    -
  • seq/1, a little extra testing
    • -
-

 

-

 

-

[Untagged] - 5/22/2022 8:41:28 AM

 @@ -2600,39 +4168,6 @@

[Untagged] - 5/9/2022 8:59:25 AM

 

 

- - -

[Untagged] - 5/8/2022 3:31:19 PM

- -

Commit 6f68f82516475c74e9ae958b0b9d9d9ea8496742

-

Author: John Haugeland <stonecypher@gmail.com>

-
    -
  • Bumps eslint, fixes StoneCypher/fsl#723
    • -
-

 

-

 

- - -

[Untagged] - 5/8/2022 3:14:51 PM

- -

Commit 7985afdecc47ec9247357e386efa126a705f6e7b

-

Author: John Haugeland <stonecypher@gmail.com>

-
    -
  • was pinned by ts-jest, re-bumped
    • -
-

 

-

 

- - -

[Untagged] - 5/8/2022 3:09:14 PM

- -

Commit ee261f9ce626b0df70932c82fe5e599abd4f1225

-

Author: John Haugeland <stonecypher@gmail.com>

-
    -
  • Bumps jest, fixes StoneCypher/fsl#719
    • -
-

 

-

 

@@ -2745,18 +4280,6 @@

[5.53.0] - 5/8/2022 3:11:52 AM

 

 

- -

[Untagged] - 5/8/2022 3:09:04 AM

- -

Commit fbcda324d66dd8b569a4e60b93794af1a3fea8f0

-

Author: John Haugeland <stonecypher@gmail.com>

-

Merges [23c50e2, e993d6b]

-
    -
  • Merge branch 'main' into AttemptToCorrectQualityDrop2
    • -
-

 

-

 

-

[Untagged] - 5/8/2022 3:07:48 AM

 @@ -3135,17 +4658,6 @@

[Untagged] - 5/2/2022 10:39:05 PM

 

 

- -

[Untagged] - 4/26/2022 12:26:11 AM

- -

Commit 330a670aaf0b8b793ad5d2c10d3321c9b1dd1b43

-

Author: John Haugeland <stonecypher@gmail.com>

-
    -
  • will get started here
    • -
-

 

-

 

-

[Untagged] - 4/25/2022 11:52:03 PM

 @@ -4851,17 +6363,6 @@

[Untagged] - 1/14/2021 1:59:21 PM

 

 

- -

[Untagged] - 1/14/2021 1:14:47 PM

- -

Commit 78a99337c1e690abeac5c9c03c745f50393c43ae

-

Author: John Haugeland <stonecypher@gmail.com>

-
    -
  • fix 531 soon
    • -
-

 

-

 

-

[Untagged] - 12/12/2020 12:12:47 AM

 @@ -5631,40 +7132,6 @@

[Untagged] - 1/28/2020 8:23:27 PM

 

 

- -

[Untagged] - 1/28/2020 7:50:46 PM

- -

Commit 92ecbf90777430ab2db1de3d0595c3150368ba6d

-

Author: John Haugeland <stonecypher@gmail.com>

-

Merges [1fa2e0b, 307ecf2]

-
    -
  • WIP on LetsSimplifyTheTautologies: 1fa2e0b first steps: centralize the constants
    • -
-

 

-

 

- - -

[Untagged] - 1/28/2020 7:50:44 PM

- -

Commit 307ecf2d66dc79fb6c6576641696a97b917d1b61

-

Author: John Haugeland <stonecypher@gmail.com>

-
    -
  • index on LetsSimplifyTheTautologies: 1fa2e0b first steps: centralize the constants
    • -
-

 

-

 

- - -

[Untagged] - 1/28/2020 7:11:13 PM

- -

Commit 1fa2e0be1bbfdbb4e2627bd4154d9e02da61e377

-

Author: John Haugeland <stonecypher@gmail.com>

-
    -
  • first steps: centralize the constants
    • -
-

 

-

 

-

[Untagged] - 1/28/2020 6:29:42 PM

 @@ -6593,29 +8060,6 @@

[Untagged] - 5/14/2019 1:34:48 PM

 

 

- -

[Untagged] - 5/6/2019 9:11:54 PM

- -

Commit 6a6dee46986db783cebbb6d7f7df9be594f61be6

-

Author: John Haugeland <stonecypher@gmail.com>

-

Merges [816a498, e98824f]

-
    -
  • WIP on (no branch): 816a498 attempt to surgery the lcov directly :|
    • -
-

 

-

 

- - -

[Untagged] - 5/6/2019 9:11:54 PM

- -

Commit e98824f54254cd8b32a755def3a5e0e6d936f842

-

Author: John Haugeland <stonecypher@gmail.com>

-
    -
  • index on (no branch): 816a498 attempt to surgery the lcov directly :|
    • -
-

 

-

 

-

[Untagged] - 5/5/2019 9:29:11 PM

 @@ -11234,4 +12678,4 @@

[Untagged] - 5/2/2017 9:58:10 PM

  • Update .gitignore
-

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file +

Legend

  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter

Settings

Theme

Generated using TypeDoc

\ No newline at end of file diff --git a/docs/docs/pages/ExampleMachines.html b/docs/docs/pages/ExampleMachines.html index 53f2ad0a..2c6e0d61 100644 --- a/docs/docs/pages/ExampleMachines.html +++ b/docs/docs/pages/ExampleMachines.html @@ -1263,7 +1263,7 @@

Light switch

Pretty obvious two-stater. Starts in Off; switches back and forth on toggle.

-
Off 'toggle' <=> 'toggle' On;
+
Off 'toggle' <=> 'toggle' On;
 

 
 

 
 

@@ -1275,7 +1275,7 @@ 
Traffic light

 
Pretty obvious two-stater.  Starts in Off; turns on with enable; when on,
 cycles on next, or back to Off with disable.  Does not offer enable or
 disable when not appropriate.

-
Off 'enable' -> Red;
Red 'next' => Green 'next' => Yellow 'next' => Red;
[Red Yellow Green] 'disable' ~> Off;
+
Off 'enable' -> Red;
Red 'next' => Green 'next' => Yellow 'next' => Red;
[Red Yellow Green] 'disable' ~> Off;
 

 
 

 
 

@@ -1286,7 +1286,7 @@ 
Traffic intersection

 

 
Offers six states - red yellow green for north, and the same for east.  Shows
 red in the unnamed direction.  Guarantees four-light sync at all times.

-
Off 'enable' -> GreenNorth;

GreenNorth 'next' => YellowNorth 'next' => RedNorth 'next' =>
GreenEast 'next'  => YellowEast  'next' => RedEast  'next' =>
GreenNorth;

[GreenNorth YellowNorth RedNorth GreenEast YellowEast RedEast] 'disable' ~> Off;
+
Off 'enable' -> GreenNorth;

GreenNorth 'next' => YellowNorth 'next' => RedNorth 'next' =>
GreenEast 'next'  => YellowEast  'next' => RedEast  'next' =>
GreenNorth;

[GreenNorth YellowNorth RedNorth GreenEast YellowEast RedEast] 'disable' ~> Off;
 

 
 

 
 

@@ -1299,11 +1299,11 @@ 
TCP/IP

 a state machine and currently codified on
 page 22 of RFC793.

 
A TCP/IP socket both starts and ends in Closed.

-
Closed 'Passive open'      -> Listen;
Closed 'Active Open / SYN' -> SynSent;

Listen 'Close'         -> Closed;
Listen 'Send / SYN'    -> SynSent;
Listen 'SYN / SYN+ACK' -> SynRcvd;

SynSent 'Close'         -> Closed;
SynSent 'SYN / SYN+ACK' -> SynRcvd;
SynSent 'SYN+ACK / ACK' -> Established;

SynRcvd 'Timeout / RST' -> Closed;
SynRcvd 'Close / FIN'   -> FinWait1;
SynRcvd 'ACK'           -> Established;

Established 'Close / FIN' -> FinWait1;
Established 'FIN / ACK'   -> CloseWait;

FinWait1 'FIN / ACK'     -> Closing;
FinWait1 'FIN+ACK / ACK' -> TimeWait;
FinWait1 'ACK / Nothing' -> FinWait2;

FinWait2  'FIN / ACK'   -> TimeWait;
Closing   'ACK'         -> TimeWait;
TimeWait  'Up to 2*MSL' -> Closed;
CloseWait 'Close / FIN' -> LastAck;

LastAck 'ACK' -> Closed;
+
Closed 'Passive open'      -> Listen;
Closed 'Active Open / SYN' -> SynSent;

Listen 'Close'         -> Closed;
Listen 'Send / SYN'    -> SynSent;
Listen 'SYN / SYN+ACK' -> SynRcvd;

SynSent 'Close'         -> Closed;
SynSent 'SYN / SYN+ACK' -> SynRcvd;
SynSent 'SYN+ACK / ACK' -> Established;

SynRcvd 'Timeout / RST' -> Closed;
SynRcvd 'Close / FIN'   -> FinWait1;
SynRcvd 'ACK'           -> Established;

Established 'Close / FIN' -> FinWait1;
Established 'FIN / ACK'   -> CloseWait;

FinWait1 'FIN / ACK'     -> Closing;
FinWait1 'FIN+ACK / ACK' -> TimeWait;
FinWait1 'ACK / Nothing' -> FinWait2;

FinWait2  'FIN / ACK'   -> TimeWait;
Closing   'ACK'         -> TimeWait;
TimeWait  'Up to 2*MSL' -> Closed;
CloseWait 'Close / FIN' -> LastAck;

LastAck 'ACK' -> Closed;
 

 
If you want to play golf, you can get that down to seven lines using lists and
 chaining:

-
Closed 'Passive open' -> Listen 'Send / SYN' -> SynSent;
[Listen SynSent] 'Close' -> Closed 'Active Open / SYN' -> SynSent 'SYN+ACK / ACK' -> Established 'FIN / ACK' -> CloseWait 'Close / FIN' -> LastAck 'ACK' -> Closed;
[SynRcvd Established] 'Close / FIN' -> FinWait1 'FIN / ACK' -> Closing 'ACK' -> TimeWait
[Listen SynSent] 'SYN / SYN+ACK' -> SynRcvd 'Timeout / RST' -> Closed;
FinWait1 'FIN+ACK / ACK' -> TimeWait 'Up to 2*MSL' -> Closed;
FinWait1 'ACK / Nothing' -> FinWait2 'FIN / ACK' -> TimeWait;
SynRcvd 'ACK' -> Established;
+
Closed 'Passive open' -> Listen 'Send / SYN' -> SynSent;
[Listen SynSent] 'Close' -> Closed 'Active Open / SYN' -> SynSent 'SYN+ACK / ACK' -> Established 'FIN / ACK' -> CloseWait 'Close / FIN' -> LastAck 'ACK' -> Closed;
[SynRcvd Established] 'Close / FIN' -> FinWait1 'FIN / ACK' -> Closing 'ACK' -> TimeWait
[Listen SynSent] 'SYN / SYN+ACK' -> SynRcvd 'Timeout / RST' -> Closed;
FinWait1 'FIN+ACK / ACK' -> TimeWait 'Up to 2*MSL' -> Closed;
FinWait1 'ACK / Nothing' -> FinWait2 'FIN / ACK' -> TimeWait;
SynRcvd 'ACK' -> Established;
 

 
 

 
 

@@ -1334,4 +1334,4 @@ 
Unprison Your Think Rhino

   
Pluggging In USB

 
 

-
Legend
  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter
Settings
Theme 
Generated using TypeDoc

\ No newline at end of file
+
Legend
  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter
Settings
Theme 
Generated using TypeDoc

\ No newline at end of file
diff --git a/docs/docs/pages/FeatureComparison.html b/docs/docs/pages/FeatureComparison.html
index c6760b0e..c6d8a503 100644
--- a/docs/docs/pages/FeatureComparison.html
+++ b/docs/docs/pages/FeatureComparison.html
@@ -2,9 +2,2155 @@
 
   
Feature Comparison

 
-
Does your machine do what you need?

+
A quick look at what machines offer what functionality, across the 16 most
+popular FSMs on NPM at the time of writing.  Updates and extensions are
+encouraged.

+
Definitions and a change link follow the tables.

+

 
-
-  
TODO

+
+  
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+
Language features
jssmXStatejavascript-state-machinemachinafinityfsm-iteratorfsm-as-promisedstately.jsstate-machinenode-statefsm-eventfsmstentrobot3moodgrammar-graph
States16✅✅✅✅✅✅✅✅✅✅✅✅✅✅✅✅
Transitions14✅✅✅✅✅❌✅✅✅✅✅✅❌✅✅❌
Actions11✅✅✅❌✅❌✅✅✅✅✅✅✅❌❌❌
Data6✅✅✅❌✅❌❌❌❌❌❌❌✅✅❌❌
TypeScript data2✅✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌
General hooks7✅✅❌❌✅❌✅❌✅❌❌❌✅✅❌❌
Specific hooks10✅❌✅✅✅❌✅✅✅✅✅❌❌✅❌❌
Post-hooks4✅❌❌❌❌❌✅✅✅❌❌❌❌❌❌❌
Hook rejection4✅✅❌❌✅❌❌❌❌❌❌❌❌✅❌❌
Transactions1✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Extending machines3❌✅❌✅❌❌❌❌❌❌❌❌❌✅❌❌
Machine composition3❌❌❌❌✅❌❌❌❌❌❌✅❌✅❌❌
Dynamic graphs2❌❌❌❌❌❌❌❌✅❌❌❌❌❌✅❌
Properties3✅✅✅❌❌❌❌❌❌❌❌❌❌❌❌❌
Methods2✅❌✅❌❌❌❌❌❌❌❌❌❌❌❌❌
Weighted edges1✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Heirarchical states3❌✅❌✅✅❌❌❌❌❌❌❌❌❌❌❌
State groups2⌚❌❌✅❌❌❌❌❌❌❌❌❌❌❌✅
Timeouts4⌚✅❌✅✅❌❌❌❌✅❌❌❌❌❌❌
Immediates1⌚❌❌❌❌❌❌❌❌❌❌❌❌✅❌❌
Error hooks1✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Input/output tape1⌚❌❌❌❌✅❌❌❌❌❌❌❌❌❌✅
Tape validator1⌚❌❌❌❌❌❌❌❌❌❌❌❌❌❌✅
Termination6✅✅❌❌❌❌✅❌❌❌❌✅❌✅❌✅
Async transitions4❌❌✅❌❌❌✅❌❌❌❌❌❌✅✅❌
Event emitter3⌚✅✅✅❌❌❌❌❌❌❌❌❌❌❌❌
Random walks2✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌✅
Serialization2✅✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Factories4✅❌✅✅❌❌❌❌❌❌❌❌❌✅❌❌
Named instances2✅❌❌✅❌❌❌❌❌❌❌❌❌❌❌❌
Automatic API1⌚❌❌❌❌❌❌✅❌❌❌❌❌❌❌❌
Count1913101110286754541246
Notations
jssmXStatejavascript-state-machinemachinafinityfsm-iteratorfsm-as-promisedstately.jsstate-machinenode-statefsm-eventfsmstentrobot3moodgrammar-graph
String DSL3✅❌❌❌❌❌❌❌✅✅❌❌❌❌❌❌
Wildcards1❌❌❌❌❌❌❌❌❌✅❌❌❌❌❌❌
Stripes0⌚❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Cycles0⌚❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Kinds0⌚❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
State spread1✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Complex labels0⌚❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Count2000000001200000
API
jssmXStatejavascript-state-machinemachinafinityfsm-iteratorfsm-as-promisedstately.jsstate-machinenode-statefsm-eventfsmstentrobot3moodgrammar-graph
In-place extrapolation1⌚❌❌❌❌❌❌❌❌❌❌❌❌❌❌✅
Graph reflection API7✅✅✅❌✅❌✅❌✅❌❌❌❌❌❌✅
History4✅✅✅❌❌✅❌❌❌❌❌❌❌❌❌❌
State histograms1✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Count3220111010000002
Docs, Support, and Community
jssmXStatejavascript-state-machinemachinafinityfsm-iteratorfsm-as-promisedstately.jsstate-machinenode-statefsm-eventfsmstentrobot3moodgrammar-graph
Defined lifecycle4✅✅✅❌❌❌❌❌✅❌❌❌❌❌❌❌
Detailed errors2✅✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Extend existing objects2❌❌✅❌❌✅❌❌❌❌❌❌❌❌❌❌
Defined start states6✅❌✅✅✅❌✅❌❌❌❌❌❌✅❌❌
Probabilistic starts2✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌✅
In-source debugger1✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Browser debugger2❌❌❌✅❌❌❌❌❌❌❌❌✅❌❌❌
Compiler0⌚❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Cross-compiler0⌚❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Graph renderer4✅✅✅❌❌❌✅❌❌❌❌❌❌❌❌❌
Visual styling2✅❌✅❌❌❌❌❌❌❌❌❌❌❌❌❌
Manual5✅✅✅❌❌❌❌❌✅❌❌❌❌✅❌❌
API samples1✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Demo videos2✅✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Tutorial videos2✅✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Chat community3✅✅❌❌❌❌❌❌❌❌❌❌✅❌❌❌
Example library2✅✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Count13862112020002201
Testing
jssmXStatejavascript-state-machinemachinafinityfsm-iteratorfsm-as-promisedstately.jsstate-machinenode-statefsm-eventfsmstentrobot3moodgrammar-graph
100% test coverage1✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Fuzz testing1✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Mutation testing0⌚❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
i18n testing1✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Count3000000000000000
Tools
jssmXStatejavascript-state-machinemachinafinityfsm-iteratorfsm-as-promisedstately.jsstate-machinenode-statefsm-eventfsmstentrobot3moodgrammar-graph
Live editor2✅✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌
CLI1✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
VS Code Extension1❌✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Github Action0⌚❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
URL live-paste1✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Linter0⌚❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Minifier0⌚❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Count3200000000000000
Totals
jssmXStatejavascript-state-machinemachinafinityfsm-iteratorfsm-as-promisedstately.jsstate-machinenode-statefsm-eventfsmstentrobot3moodgrammar-graph
Language features1914101110286754541246
Notations2000000001200000
API3220111010000002
Docs/support13862112020002201
Testing3000000000000000
Tools3200000000000000
Sum totals432618131241161066561449

+
+

+
+
+
+
+
+
 

+
 

+
+
+  
Definitions

+
+
By section:

+
 

+
 

+
+
+  

+
+

+
+  
States

+  

+    The bread and butter of a state machine - the states that the machine is
+    permitted to occupy.  It's hard to understand what a state machine that
+    didn't support states would actually be.  On a traffic light, we probably
+    have red, yellow, green, and off.
+  

+
+  
Transitions

+  

+    A machine that supports transitions allows you to specify which state to
+    move to directly.  Almost all machines support transitions.  A handful of
+    machines do not (usually by only supporting actions instead.)  These are
+    often called go, switch, change,
+    state, set, or assign.
+  

+
+  
Actions

+  

+    Actions are things that can be done, from a given state.  These are distinct
+    from transitions, which specify the end goal, by being a label specifying
+    what's being done, instead; since these are also not part of the input or
+    output alphabets, these are effectively a layer of indirection on behavior.
+    What's useful here is the names can be repeated from different starting
+    points.  To progress in our traffic light without actions, we need to know
+    what color we're on to ask for the successor by title; with actions, we can
+    just teach each color the idea of next.  Actions are sometimes
+    called tasks, raise, signal,
+    event, or do.  In some machines these are mandatory;
+    in FSL they are optional.
+  

+
+  
Data

+  

+    Data is the difference between a Mealy and a Moore machine - data support
+    means you can track more than just states.  In a vending machine, having no
+    data means you need states for every valid sum of coin values (one for five
+    cents, one for ten cents, etc;) having data means you just track
+    a number for what's already contained.  Some machines call this
+    context, or occasionally input.
+  

+
+  
TypeScript data

+  

+    We say the machine supports TypeScript data if the machine's data object
+    type is customizable, is exposed to TypeScript, and can be enforced by
+    TypeScript.  In this way, the machine's data is fully part of the TypeScript
+    system.
+  

+
+  
General hooks

+  

+    Hooks allow you to specify a function that gets called because of something
+    that happened.  Support for general hooks means that you can establish a
+    hook on general or global events, such as "any transition" or "any event."
+  

+
+  
Specific hooks

+  

+    Support for specific hooks means that you can establish a hook on particular
+    states, transitions, or actions.
+  

+
+  
Post-hooks

+  

+    Posthooks fire after a transition is complete, rather than before, and the
+    data passed to the posthook reflects the later configuration.  If you wanted
+    to make an editor that visualized states' actions with buttons, you'd need
+    to use posthooks, not hooks, so that the buttons were for what state they're
+    now on, rather than the ones in the previous configuration.
+  

+
+  
Hook rejection

+  

+    Support for hook rejection means that a given hook is allowed to deny a
+    given behavior.  An example is a state machine representing a user
+    interface, which has a data member representing whether the user is logged
+    in, and which disallows switching to the personal profile when not. Hooks
+    that reject are sometimes called guards, and were called
+    guards in earlier versions of this machine.
+  

+
+  
Transactions

+  

+    In a transactional FSM, everything is transactional - if any hook in a
+    process rejects, none of the other transformations that would have taken
+    place do, and everything is rolled back to the end result of the last
+    successful transition.
+  

+
+  
Extending machines

+  

+    Support for extending machines means that an existing machine can be
+    augmented in place, while keeping its state and any data intact.  This is
+    distinct from changing the source that made a machine and recompiling it;
+    machine extension works on instances, not definitions.
+  

+
+  
Machine composition

+  

+    Machine composition is either the combination of two machines, or the
+    subordination of one machine to another using internal mechanisms.  This is
+    distinct from putting something together externally using hooks.
+  

+
+  
Dynamic graphs

+  

+    In a machine which supports dynamic graphs, the structure of the machine can
+    be changed while it is running, either in its states, its transitions, or
+    its actions.
+  

+
+  
Properties

+  

+    Support for properties means that states can and may be required to express
+    named values.  This can obviate repetitive switching to make decisions based
+    on the state outside, and unify the behavior of things depending on machines
+    under the machines' specification.  A traffic light state machine's light
+    color states might have properties regarding whether you may drive, or
+    whether to go slowly.
+  

+
+  
Methods

+  

+    Support for methods means that states may express named functions.  Consider
+    a state machine representing a network connection, which might be online or
+    offline; it might express a lookup function which falls back to a local
+    cache outside the presence of a network connection, but queries a backend
+    when connected.  This feature, when used fully, makes a state machine
+    equivalent to Strategy Pattern.
+  

+
+  
Weighted edges

+  

+    In a machine with weighted edges, transitions can be randomized, and some
+    probabilities may be stronger than others.  This allows machines to directly
+    model simple probabilities, or probability meshes when used with random
+    walks.  Use of this feature makes a state machine equivalent to a First
+    Order Markhov Chain.
+  

+
+  
Heirarchical states

+  

+    Heirarchical states are a major approach to reducing the number of
+    transitions in a machine, by allowing them to source from or target groups
+    of states rather than individual states, frequently reducing a typical
+    edge count from o(n^2) from state count down towards o(n)
+    from group count.  In an FSM representing a microwave, all states except
+    idle will have an action for cancel, which could be
+    reduced to the non-idle heirarchy.  A limitation of heirarchies is that they
+    generally cannot overlap, and groups frequently need to overlap.
+  

+
+  
State groups

+  

+    Another method of reducing transition count is to allow the definition of
+    arbitrary lists of states, and to treat them as heirarchical groups are
+    treated, as valid source and endpoints.  This is slightly more laborious,
+    but also more flexible, and can be used to implement heirarchical FSMs
+    directly.
+  

+
+  
Timeouts

+  

+    A state with a timeout will, if unchanged and unacted, switch of its own
+    volition to another state after a specified amount of time.  Any transition
+    or action automatically ends this timer.  This is extremely helpful when
+    implementing protocols, network behavior, enemy agent AI, or timed
+    element demonstrations.
+  

+
+  
Immediates

+  

+    In a machine with support for immediates, after a relevant transition,
+    action, or hook to a target state, a new transition will automatically occur
+    to a successor state with no delay.  The most common uses for immediates are
+    merging groups of paths and hooking the groups on the way through, inserting
+    things into history, coursing during parsing and random construction, or
+    construction of transfer states for things that wouldn't otherwise be
+    allowed, such as multiple actions that (eventually) have the same source and
+    destination states.
+  

+
+  
Error hooks

+  

+    An error hook is a hook that's called when an error fires.  Errors are
+    distinct from refusals - asking to switch to a state that isn't allowed, or
+    one that doesn't exist, are refusals, and should not fire this hook.  Errors
+    are for when you ask for things that don't make sense, such as a string with
+    an opening quote but not a closing quote.  Errors of that form are
+    relatively rare in finite state machines, but can be important when dealing
+    with data, dynamic graphs, or combined machines.
+  

+
+  
Input/output tape

+  

+    This is the formal classical finite state machine
+    (Σ,Γ,S,s0,𝛿,F) from the textbooks, which is defined as
+    two alphabets, one set of transformations, an initial state, and two token
+    streams.  From this worldview on finite state machines, the input alphabet
+    Σ is the things that are allowed to be on the input tape; the
+    output alphabet is the your state list by default, but could be changed by
+    your hooks; the set of states S is just the states you've defined;
+    the set of transformations 𝛿 is your transitions, accepts an input
+    symbol (from the tape) if Moore and also some data if Mealy; and
+    the two streams are the input tape and the output tape.  If you'd like to
+    write a FSM as an acceptor or a validator, typically you would use these
+    tape facilities.  These tend to be found in parsing, iteration, and utility
+    oriented machines.  If you are only using the input tape and a halting state
+    (by example, a machine that checks if the input is a number,) you create an
+    acceptor; if you use the output tape to produce a transformed set
+    of symbols (by example, an upper-casing machine,) you have instead made a
+    transducer.  Support for tape is quite rare, despite being high
+    value.
+  

+
+  
Tape validator

+  

+    A machine with tape validation has API to repeatedly use the same machine
+    to validate a set of inputs through tape, without making the user implement
+    the feed machinery repeatedly.  These are found almost exclusively in
+    parsing oriented machines.
+  

+
+  
Termination

+  

+    Machine support for termination implies that a machine pays attention to
+    when a state has no valid exits, frequently offering hooks or callbacks to
+    let the machine user know that a machine has finalized.  This is typically
+    found in parsing and validation oriented machines.
+  

+
+  
Async transitions

+  

+    Asynchronous transitions in machines typically mean that transitions may not
+    be instantaneous, and that the result of a transition may be a callback,
+    promise, or generator, instead of an immediately reflected change.  This
+    approach has tradeoffs.  On the upside, the number of states being tracked
+    is often significantly lower, and as such, the transition count quite a bit
+    lower.  On the other hand, this means that state machines may become locked
+    and unavailable, introducing concurrency concerns, and requiring an api for
+    mechanisms like is_changing.  An alternative approach is to
+    maintain the instantaneous API, and have states representing things
+    underway, which is closer to the fundamental nature of an FSM, single
+    threaded, and more precise, but also more verbose.
+  

+
+  
Event emitter

+  

+    An event emitter emits Javascript events for transitions, actions, and so
+    forth, as a convenient alternative way to notify the outside world besides
+    hooks.  As many Javascript tools consume events, this can remove a lot of
+    dispatch boilerplate.
+  

+
+  
Random walks

+  

+    Random walks allow you to wander over the possibilities in your state
+    machine.  Some state machines, like the canonical weather example, are well
+    suited to using this directly; in others, this is a great way to validate
+    that everything in your machine is reachable in a certain depth
+    (particularly valuable for machines which represent user interfaces.)  This
+    is also frequently a constituent piece of generating state heatmaps.
+  

+
+  
Serialization

+  

+    Serialization permits you to take the current state of a machine (with or
+    without its definition, with or without history, always with data) into a
+    string format which is safe for storage, and can be reliably unpacked again
+    later.  This is highly useful for save states, database storage, things
+    moving through queues, and state exchange.
+  

+
+  
Factories

+  

+    Factories allow you to create new instances of the same machine with other
+    configurations quickly and easily, and make it straightforward to map a
+    container as a set of configurations for new machines, or to treat a machine
+    specification as a generator.  Factories are useful when the same machine
+    will be used in large numbers.  An example would be the people in a game
+    like Roller Coaster Tycoon - every time a new customer enters the park, the
+    factory should spin off a new Person with a set of random preferences,
+    clothes, money, and so forth.
+  

+
+  
Named instances

+  

+    When re-using a machine frequently, such as with a factory method or a
+    generator, it is often useful to name the instances so that you can tell
+    them apart.  By example, this can be useful when making network connections,
+    parsing files in parallel, or when state machines represent assets in a
+    system, such as the people and objects in a video game.  As the number of
+    machines you manage grows, so too grows the value of naming instances.
+  

+
+  
Automatic API

+  

+    In a machine with an automatic API, transitions and/or actions are
+    automatically added to the object's method namespace as functions, so that
+    you don't need to call an indirection like .action('foo'), but
+    instead just .foo().  This can be complex - one may need a slugging
+    function, and collisions might become a problem.  However, this can also
+    yield more readable and usable machines, when done skillfully.
+  

+
+

+
+
+
+
+
+
 

+
 

+
+
+  
Updates

 
-
Legend
  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter
Settings
Theme 
Generated using TypeDoc

\ No newline at end of file
+
Mistake?  Something out of date?  New row or column needed?

+
Please let us know.

+
Legend
  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter
Settings
Theme 
Generated using TypeDoc

\ No newline at end of file
diff --git a/docs/docs/pages/GettingStarted.html b/docs/docs/pages/GettingStarted.html
index bbc85f7e..97a64ca1 100644
--- a/docs/docs/pages/GettingStarted.html
+++ b/docs/docs/pages/GettingStarted.html
@@ -23,10 +23,10 @@ 
Just getting going from CDN

 
 
To start with, let's do things the sloppy, "just run already" way.  We'll load
 the library directly in the HTML, from CDN.

-
<!doctype html>
<html>

  <head>

    <script type="text/javascript"
            src="https://cdn.jsdelivr.net/npm/jssm/dist/jssm.es5.iife.min.js">
    </script>

  </head>

</html>
+
<!doctype html>
<html>

  <head>

    <script type="text/javascript"
            src="https://cdn.jsdelivr.net/npm/jssm/dist/jssm.es5.iife.min.js">
    </script>

  </head>

</html>
 

 
At this point, you can already play with the library, in the developer console.

-

+

 
 
 
@@ -39,16 +39,16 @@ 
Just getting going from CDN

   
Let's make it visible

 
 
First, we need a toy traffic light.  Here's some HTML structure:

-
<!doctype html>
<html>

  <head>
    <title>Traffic light example</title>
  </head>

  <body>

    <table id="light" class="light_off">
      <tr><td id="red"><span></span></td></tr>
      <tr><td id="yellow"><span></span></td></tr>
      <tr><td id="green"><span></span></td></tr>
    </table>

  </body>

</html>
+
<!doctype html>
<html>

  <head>
    <title>Traffic light example</title>
  </head>

  <body>

    <table id="light" class="light_off">
      <tr><td id="red"><span></span></td></tr>
      <tr><td id="yellow"><span></span></td></tr>
      <tr><td id="green"><span></span></td></tr>
    </table>

  </body>

</html>
 

 
And a bit of CSS to get it to look just so:

-
    <style type="text/css">

      #light    { border-collapse: collapse; }  /* don't separate cells */
      #light td { border: 2px solid #e3a31d; }  /* mildly darker orange border around cells */

      #light span {
        height        : 4em;              /* size the lightbulb */
        width         : 4em;              /* size the lightbulb */
        border        : 2px solid black;  /* looks weird without an edge */
        border-radius : 50%;              /* make it round */
        display       : inline-block;     /* so that it will lay out margins correctly */
        margin        : 0.5em;            /* space around bulb */
      }

      #red    span { background-color: #300; } /* very dark when not lit */
      #yellow span { background-color: #220; }
      #green  span { background-color: #030; }

      .light_red    #red    span { background-color: #F00; } /* bright when lit */
      .light_yellow #yellow span { background-color: #EE0; }
      .light_green  #green  span { background-color: #0F0; }

      td { background-color: #FCC550; } /* that yellow-slightly-orange frame */

    </style>
+
    <style type="text/css">

      #light    { border-collapse: collapse; }  /* don't separate cells */
      #light td { border: 2px solid #e3a31d; }  /* mildly darker orange border around cells */

      #light span {
        height        : 4em;              /* size the lightbulb */
        width         : 4em;              /* size the lightbulb */
        border        : 2px solid black;  /* looks weird without an edge */
        border-radius : 50%;              /* make it round */
        display       : inline-block;     /* so that it will lay out margins correctly */
        margin        : 0.5em;            /* space around bulb */
      }

      #red    span { background-color: #300; } /* very dark when not lit */
      #yellow span { background-color: #220; }
      #green  span { background-color: #030; }

      .light_red    #red    span { background-color: #F00; } /* bright when lit */
      .light_yellow #yellow span { background-color: #EE0; }
      .light_green  #green  span { background-color: #0F0; }

      td { background-color: #FCC550; } /* that yellow-slightly-orange frame */

    </style>
 

 
We'll also add a bit of Javascript to make it usable.

-
<script type="text/javascript">

  function light(what) {
    if (['red','yellow','green','off'].includes(what)) {
      document.getElementById('light').className = `light_${what}`;
    }
  }

</script>
+
<script type="text/javascript">

  function light(what) {
    if (['red','yellow','green','off'].includes(what)) {
      document.getElementById('light').className = `light_${what}`;
    }
  }

</script>
 

 
End result should look a bit like this:

-

+

 
 
 
@@ -63,7 +63,7 @@ 
Wiring up the machine to the UI

 
Next, let's have the machine and the UI interact a bit.

 
If you pull the CSS out from the previous example into a file called tl.css
 and otherwise assume it hasn't changed, you're left with this:

-
<!doctype html>
<html>

  <head>

    <link rel="stylesheet" type="text/css" href="tl.css" />

    <script type="text/javascript"
            src="./jssm.es5.iife.js"></script>

    <script type="text/javascript">

      function set_color(what) {
        if (['red','yellow','green','off'].includes(what)) {
          document.getElementById('light').className = `light_${what}`;
        }
      }

      window.onload = () => {

        const traffic_light = sm`
          Red 'next' => Green 'next' => Yellow 'next' => Red;
        `;

      };

    </script>

  </head>

</html>
+
<!doctype html>
<html>

  <head>

    <link rel="stylesheet" type="text/css" href="tl.css" />

    <script type="text/javascript"
            src="./jssm.es5.iife.js"></script>

    <script type="text/javascript">

      function set_color(what) {
        if (['red','yellow','green','off'].includes(what)) {
          document.getElementById('light').className = `light_${what}`;
        }
      }

      window.onload = () => {

        const traffic_light = sm`
          Red 'next' => Green 'next' => Yellow 'next' => Red;
        `;

      };

    </script>

  </head>

</html>
 

 
We'll add a simple "hook," which means the state machine will call functions you
 provide when things happen.  In this case, we'll call the hook whenever any
@@ -81,7 +81,7 @@ 
Wiring up the machine to the UI

 
window.onload = () => {

  const traffic_light = window.jssm.sm`
    red 'next' => green 'next' => yellow 'next' => red;
  `;

  traffic_light.hook_any_transition( ({to}) => set_color(to) );
  window.tl = traffic_light;

};
 

 
And now, they're linked.

-

+

 
 
 
@@ -105,7 +105,7 @@ 
Adding buttons to the UI

 
We've a convention here.  Putting several names in [] square brackets makes a
 "list," and when we make an arrow from the list, it actually makes a distinct
 arrow for each element in the list.  So, the line

-
[red yellow green] 'disable' -> off;
+
[red yellow green] 'disable' -> off;
 

 
actually makes three transitions, and gives them all the same action.

 
The state machine will now start in off, because unless you specify otherwise,
@@ -113,7 +113,7 @@ 
Adding buttons to the UI

 
We'll need to add two labelled containers to our UI - one for the available
 actions, and one for the available transitions.  Those might initially just be
 empty <div>s, and look like this:

-
<div id="avail_actions"></div>
<div id="avail_transitions"></div>
+
<div id="avail_actions"></div>
<div id="avail_transitions"></div>
 

 
Which actions and transitions are available at any given time on this machine
 change, and we don't want to have to manage knowing what's going on, so we'll
@@ -133,4 +133,4 @@ 
Adding buttons to the UI

 

 
window.onload = () => {
  // ...
  update_action_buttons();
  update_transition_buttons();
};
 

-
Legend
  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter
Settings
Theme 
Generated using TypeDoc

\ No newline at end of file
+
Legend
  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter
Settings
Theme 
Generated using TypeDoc

\ No newline at end of file
diff --git a/docs/docs/pages/LanguageReference.html b/docs/docs/pages/LanguageReference.html
index 5a1a4218..89f3b83d 100644
--- a/docs/docs/pages/LanguageReference.html
+++ b/docs/docs/pages/LanguageReference.html
@@ -18,13 +18,13 @@ 
Quick start

 
Write states by their names, separated by arrows.  Chains are valid.  Finish
 with a semicolon.

 
The basic traffic light example looks like this:

-
Red -> Green -> Yellow -> Red;
+
Red -> Green -> Yellow -> Red;
 

 
With actions:

-
Red 'next' -> Green 'next' -> Yellow 'next' -> Red;
+
Red 'next' -> Green 'next' -> Yellow 'next' -> Red;
 

 
Writing three links to an off state using a list:

-
Red 'next' -> Green 'next' -> Yellow 'next' -> Red;
[Red Yellow Green] 'shut down' -> Off 'start' -> Red;
+
Red 'next' -> Green 'next' -> Yellow 'next' -> Red;
[Red Yellow Green] 'shut down' -> Off 'start' -> Red;
 

 
Hooking an edge, a state, and an action:

 
const TL = sm`
  Red 'next' -> Green 'next' -> Yellow 'next' -> Red;
  [Red Yellow Green] 'shut down' -> Off 'start' -> Red;
`;

TL.hook('Red', 'Green', () =>
  console.log('Go go go!'));

TL.hook_entry('Off', () =>
  console.log('Where did the power go?'));

TL.hook_global_action('next', () =>
  console.log('next color now'));
@@ -70,6 +70,6 @@ 
The basics

 
Expressing states is implicit.  An FSL user expresses transitions only.

 
Transitions in the simple form are expressed as the name of two or more states,
 with arrows between them, ending in a semicolon.  A traffic light:

-
Red -> Green -> Yellow -> Red;
+
Red -> Green -> Yellow -> Red;
 

-
Legend
  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter
Settings
Theme 
Generated using TypeDoc

\ No newline at end of file
+
Legend
  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter
Settings
Theme 
Generated using TypeDoc

\ No newline at end of file
diff --git a/docs/docs/pages/Shootout.html b/docs/docs/pages/Shootout.html
index 9a2bcc78..c2f2f237 100644
--- a/docs/docs/pages/Shootout.html
+++ b/docs/docs/pages/Shootout.html
@@ -35,72 +35,72 @@ 
Lines of Code shootout

 
 
 jssm
-1
-2
-5
+1
+2
+5
 2.66
 
 
 state-machine
-5
-8
-14
+5
+8
+14
 9
 
 
 faste
-4
-14
-24
+4
+14
+24
 10.66
 
 
 javascript-state-machine
-7
-13
-23
+7
+13
+23
 14.33
 
 
 finity
-7
-10
-28
+7
+10
+28
 15
 
 
 stately
-8
-18
-24
+8
+18
+24
 16.66
 
 
 robot
-17
-24
-31
+17
+24
+31
 24
 
 
 xstate
-16
-36
-33
+16
+36
+33
 28.33
 
 
 nanostate
-8
-12
-15
+8
+12
+15
 11.66
 
 
 machina
-20
-26
-36
+20
+26
+36
 27.33
 
 
@@ -124,43 +124,43 @@ 
Toggle machine

 
 
 jssm
-1
+1
 
 
 faste
-4
+4
 
 
 state-machine
-5
+5
 
 
 finity
-7
+7
 
 
 javascript-state-machine
-7
+7
 
 
 stately
-8
+8
 
 
 nanostate
-8
+8
 
 
 xstate
-16
+16
 
 
 robot
-17
+17
 
 
 machina
-20
+20
 
 
 
 

@@ -275,43 +275,43 @@ 
Traffic light

 
 
 jssm
-2
+2
 
 
 state-machine
-8
+8
 
 
 finity
-10
+10
 
 
 javascript-state-machine
-13
-
-
-nanostate
-12
+13
 
 
 faste
-14
+14
 
 
 stately
-18
+18
 
 
 robot
-24
+24
 
 
 xstate
-36
+36
+
+
+nanostate
+12
 
 
 machina
-26
+26
 
 
 
 

@@ -434,43 +434,43 @@ 
States of Matter

 
 
 jssm
-5
+5
 
 
 state-machine
-14
+14
 
 
 nanostate
-15 ❌
+15 ❌
 
 
 javascript-state-machine
-23
+23
 
 
 stately
-24
+24
 
 
 faste
-24
+24
 
 
 finity
-28
+28
 
 
 robot
-31
+31
 
 
 xstate
-35
+33
 
 
 machina
-36 ❌
+36 ❌
 
 
 
 

@@ -584,4 +584,4 @@ 
machina states of matter, 36 lines, ❌ cannot implement

 grounds, machina cannot implement this machine correctly.

 
export const matter = new machina.Fsm({
  initialState: "solid",
  states: {
    uninitialized: {
      "*": function () {
        this.deferUntilTransition();
        this.transition("solid");
      },
    },
    solid: {
      _melt: "liquid",
    },
    liquid: {
      _freeze: "solid",
      _vaporize: "gas",
    },
    gas: {
      _condense: "liquid",
      _onEnter: function () {
        console.log("Red light!");
      },
    },
  },
  melt: function () {
    this.handle("_melt");
  },
  freeze: function () {
    this.handle("_freeze");
  },
  vaporize: function () {
    this.handle("_vaporize");
  },
  condense: function () {
    this.handle("_condense");
  },
});
 

-
Legend
  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter
Settings
Theme 
Generated using TypeDoc

\ No newline at end of file
+
Legend
  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter
Settings
Theme 
Generated using TypeDoc

\ No newline at end of file
diff --git a/docs/docs/pages/Styling.html b/docs/docs/pages/Styling.html
index 71e0f2e4..1cac15f8 100644
--- a/docs/docs/pages/Styling.html
+++ b/docs/docs/pages/Styling.html
@@ -3,4 +3,4 @@
   
Styling nodes and graphs

 
 
This help page has not yet been written.

-
Legend
  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter
Settings
Theme 
Generated using TypeDoc

\ No newline at end of file
+
Legend
  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter
Settings
Theme 
Generated using TypeDoc

\ No newline at end of file
diff --git a/docs/docs/pages/WhatAreStateMachines.html b/docs/docs/pages/WhatAreStateMachines.html
index d85348a0..83ef2c14 100644
--- a/docs/docs/pages/WhatAreStateMachines.html
+++ b/docs/docs/pages/WhatAreStateMachines.html
@@ -2,12 +2,27 @@
 
   
What are Finite State Machines?

 
+
Support tools are important to keeping software running correctly.  As
+programmers move from small software to medium software, they often find that
+teaching the computer more about what's going on, so that the computer can
+meaningfully argue, is a productive strategy.

+
Type systems are an obvious example - if you have a variable meant to store a
+number, and accidentally attempt to assign some text to it, it is useful for
+your programming lanugage or environment to be able to discover and announce the
+mistake.  Check constraints, foreign keys, specs, and unit tests are
+other examples of teaching the computer to say "no."

+
Finite State Machines are a very powerful mechanism for teaching the computer
+what's actually happening.  They represent something as a collection of states
+(finite because you predefine which ones exist,) then define which states may
+turn into which other states.  Most of the value of a state machine comes from
+this modelling, and from refusing inappropriate transitions.

 
Finite State Machines are a classic tool from the 1950s, meant to allow a
 system to be better defined.  In formal and high safety systems they are a
 critical tool.  FSL, the Finite State Language, exists to make them easier to
 write, debug, and maintain.

-
Most likely, you're already pretty familiar with a lot of state machines.  On
-those grounds, we teach state machines by example.

+
Most likely, you're already pretty familiar with a lot of state machines -
+light switches, traffic lights, microwaves, and so forth.  On those grounds, we
+teach state machines by example.

 
 

 
 

 
@@ -19,23 +34,24 @@ 
The light switch

 On, it can't be turned On again; the rules are similar for Off.

 
In FSL, we write states as just their names, and then connections as arrows
 ->; as such, we would write a light switch this way:

-
On -> Off -> On;
+
On -> Off -> On;
 

 
Or, to save time, we can use a double-sided arrow <->:

-
On <-> Off;
+
On <-> Off;
 

 
It might also be reasonable to say that to toggle is to switch from either
 state to the other, without needing to know ahead of time.  We call that an
 action, and write it in single quotes ', inbetween the state and the
 relevant arrow.

-
On 'toggle' -> Off 'toggle' -> On;
+
On 'toggle' -> Off 'toggle' -> On;
 

 
The placement of the action on double-sided arrows matches the arrow itself:

-
On 'toggle' <-> 'toggle' Off;
+
On 'toggle' <-> 'toggle' Off;
 

 
And were we to graph this, it might look like so:

 

-
But, a light switch is hardly convincing, or much worth paying attention to.

+
But, a light switch is hardly convincing, or much worth paying attention to.
+There isn't a whole lot of value here, except for showing notation.

 
 

 
 

 
@@ -46,21 +62,27 @@ 
The traffic light

 (or four if you count Off,) and there's a good reason for it to be there: it's
 important that a traffic light doesn't "go backwards."

 
Traffic lights are directional in several ways.  The important one is color: a
-traffic light that's Yellow must next go to Red.  If the wrong thing
+traffic light that's Yellow must next go to Red.  If the wrong thing
 happens, and the light goes from Yellow to Green instead, an accident might
-happen.  People could die.

+happen.  People could die.

 
In code, you'd need to do something like this:

-
const allowed = {
  'green'  : ['yellow', 'off'],
  'yellow' : ['red', 'off'],
  'red'    : ['green', 'off'],
  'off'    : ['red']
};

let state = 'off';

function switch_to(next) {

  if (allowed[state].includes(next)) {
    state = next;
    return true;
  } else {
    return false;
  }

}

switch_to('red');
+
const allowed = {
  'green'  : ['yellow', 'off'],
  'yellow' : ['red', 'off'],
  'red'    : ['green', 'off'],
  'off'    : ['red']
};

let state = 'off';

function switch_to(next) {

  if (allowed[state].includes(next)) {
    state = next;
    return true;
  } else {
    return false;
  }

}

switch_to('red');
switch_to('green');
switch_to('yellow');
switch_to('red');
 

 
And that is a rudimentary state machine.

+
 

+
 

+
+
+  
Doing it in FSL

+
 
Of course, we're in a state machine programming language and library whose
 design is meant to make them simple, so, we'd write this, instead:

-
const TrafficLight = sm`
  Off -> Red -> Green -> Yellow -> Red;
  [Red Yellow Green] -> Off;
`;

TrafficLight.transition('Red');
+
const TrafficLight = sm`
  Off -> Red -> Green -> Yellow -> Red;
  [Red Yellow Green] -> Off;
`;

TrafficLight.go('Red');
TrafficLight.go('Green');
TrafficLight.go('Yellow');
TrafficLight.go('Red');
 

 
It's implied that, unless you say otherwise, the first mentioned state is the
 state the machine starts in, so, this traffic light starts in Off.

 
For purposes of the tutorial, we'll just focus on the language part:

-
Off -> Red -> Green -> Yellow -> Red;
[Red Yellow Green] -> Off;
+
Off -> Red -> Green -> Yellow -> Red;
[Red Yellow Green] -> Off;
 

 
What's important here is that we've taught the machine light color order.  If
 it's in Yellow, it knows that it isn't allowed to go to Green, and if you
@@ -68,18 +90,27 @@ 
The traffic light

 
This is, roughly, the value of type systems, check constraints, proof systems,
 some kinds of constraint programming, and arguably of testing and even linting:
 teaching the machine what wrong is, so that it can support you.

+
 

+
 

+
+
+  
Making life easier.

+
 
State machines are an extremely powerful tool for machine auditing and machine
-self-diagnosis.  They can also, however, be supportive and convenient.  By
-example, the previous state machine requires a user to know what color it's
-currently in to proceed.  This seems undesirable.  Let's teach it to accept an
-instruction next to proeed to whatever the next correct color is:

-
Off -> Red;
Red 'next' -> Green 'next' -> Yellow 'next' -> Red;
[Red Yellow Green] -> Off;
+self-diagnosis.

+
They can also, however, be supportive and convenient.  By example, the previous
+version of our traffic light state machine requires a user to know what color
+it's currently in, in order to proceed.

+
This seems undesirable.  Less thinking is better.

+
Let's teach our machine to accept an instruction next to proeed to whatever
+the correct successor color is:

+
Off 'enable' -> Red;
Red 'next' -> Green 'next' -> Yellow 'next' -> Red;
[Red Yellow Green] 'disable' -> Off;
 

 
We didn't have to break off the opening Off -> Red that way; the author just
 thinks it's cleaner looking (indeed, this machine can be a one-liner if you
 don't much care about readability.)

-
Now, we can interact with the machine as such:

-
TrafficLight.action('next');
+
Now, we can interact with the machine in this easier way:

+
TrafficLight.do('enable');  // to red
TrafficLight.do('next');    // to green
TrafficLight.do('next');    // to yellow
TrafficLight.do('next');    // to red
 

 
 

 
 

@@ -89,21 +120,33 @@ 
More simple machines

 
 
And, already, a bunch of other simple machines are accessable.  Some examples:

 
 

+
+
+  
Three brightness lamp

+
 
Three brightness lamp is pretty similar to a traffic light, except that Off is
 part of the main loop instead of an extra state:

-
Off 'touch' -> Bright 'touch' -> Medium 'touch' -> Dim 'touch' -> Off;
+
Off 'touch' -> Bright 'touch' -> Medium 'touch' -> Dim 'touch' -> Off;
 

 

 
 

+
+
+  
Locking door

+
 
A locking door, by contrast, might have a state for Unlocked which responds to
 open by switching to Opened, but a state Locked which responds to open
 by going to itself (or perhaps just not expressing the action at all.)

-
Opened 'close' <-> 'open' Closed 'lock' <-> 'unlock' Locked;
Locked 'open' -> Locked;
+
Opened 'close' <-> 'open' Closed 'lock' <-> 'unlock' Locked;
Locked 'open' -> Locked;
 

 

 
 

+
+
+  
States of matter

+
 
The basic four states of matter on Earth:

-
 Solid      'melt' <-> 'freeze'    Liquid;
Liquid  'vaporize' <-> 'condense'  Gas;
   Gas    'ionize' <-> 'recombine' Plasma;
 Solid 'sublimate' <-> 'deposit'   Gas;
+
 Solid      'melt' <-> 'freeze'    Liquid;
Liquid  'vaporize' <-> 'condense'  Gas;
   Gas    'ionize' <-> 'recombine' Plasma;
 Solid 'sublimate' <-> 'deposit'   Gas;
 

 

-
Legend
  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter
Settings
Theme 
Generated using TypeDoc

\ No newline at end of file
+
Legend
  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter
Settings
Theme 
Generated using TypeDoc

\ No newline at end of file
diff --git a/docs/docs/pages/community.html b/docs/docs/pages/community.html
index 91f6d770..937a9eb9 100644
--- a/docs/docs/pages/community.html
+++ b/docs/docs/pages/community.html
@@ -11,4 +11,4 @@ 
Discord

 
 
Please join us on Discord!  https://discord.gg/9P95USqnMK

 
Discord community

-
Legend
  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter
Settings
Theme 
Generated using TypeDoc

\ No newline at end of file
+
Legend
  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter
Settings
Theme 
Generated using TypeDoc

\ No newline at end of file
diff --git a/docs/docs/pages/live_editor.html b/docs/docs/pages/live_editor.html
index d778867a..cc52efbc 100644
--- a/docs/docs/pages/live_editor.html
+++ b/docs/docs/pages/live_editor.html
@@ -6,4 +6,4 @@ 
Live Editor

 sharing.

 

 
Try the live editor now.

-
Legend
  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter
Settings
Theme 
Generated using TypeDoc

\ No newline at end of file
+
Legend
  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter
Settings
Theme 
Generated using TypeDoc

\ No newline at end of file
diff --git a/docs/docs/pages/todo.html b/docs/docs/pages/todo.html
index 7ed51b32..bcae2951 100644
--- a/docs/docs/pages/todo.html
+++ b/docs/docs/pages/todo.html
@@ -3,4 +3,4 @@
   
todo

 
 
This help page has not yet been written.

-
Legend
  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter
Settings
Theme 
Generated using TypeDoc

\ No newline at end of file
+
Legend
  • Namespace
  • Variable
  • Function
  • Function with type parameter
  • Type alias
  • Type alias with type parameter
  • Class
  • Class with type parameter
Settings
Theme 
Generated using TypeDoc

\ No newline at end of file
diff --git a/docs/typedoc-addon.css b/docs/typedoc-addon.css
index ddb83006..757087d7 100644
--- a/docs/typedoc-addon.css
+++ b/docs/typedoc-addon.css
@@ -69,4 +69,31 @@ html li.pages-entry-depth-4 { padding-left: 75px; }
 html li.pages-entry-depth-5 { padding-left: 90px; }
 
 .youtube-embed        { position: relative; padding-bottom: 56.25%; /* enforces 16:9 aspect */ }
-.youtube-embed iframe { position: absolute; top: 0; left: 0; width: 100%; height: 100%; border: 1px solid black; }
\ No newline at end of file
+.youtube-embed iframe { position: absolute; top: 0; left: 0; width: 100%; height: 100%; border: 1px solid black; }
+
+.frot_th_tab                         { vertical-align: bottom; }
+.frot_th_tab table tbody th          { position: relative; font-weight: normal; padding: 6px 4px; }
+.frot_th_tab tr.headings th          { height: 12em; width: 1.25em; }
+.frot_th_tab td, .frot_th_tab th     { vertical-align: bottom; font-weight: normal; text-align: center; }
+.frot_th_tab table tbody td          { padding: 6px 4px; min-width: 1em; max-width: 1em; }
+.frot                                { transform-origin: 0 0; transform: rotate(-90deg); display: inline-block; position: absolute; left: 0em; bottom: -0.75em; font-weight: 400; }
+.frot_th_tab th span                 { width: 12em; text-align: left; }
+.frot_th_tab .rot                    { left: 0.2em; }
+.frot_th_tab table tr+tr th          { width: 11em; text-align: right; }
+.frot_th_tab th.tablenotch           { background: transparent; border-top-color: transparent; border-left-color: transparent; }
+
+.tsd-panel .frot_th_tab table tbody tr.headings { background: transparent; }
+           .frot_th_tab tr+tr th+th             { width: 1.25em; text-align: center; }
+
+.tsd-panel .frot_th_tab table tr.faketitle    { background: transparent; }
+.tsd-panel .frot_th_tab table tr.faketitle td { background: transparent; border: 0; text-align: left; font-weight: bold; font-size: 150%; padding: 1.5em 0 0.5em 0; }
+
+.sums td { font-weight: bold; }
+
+dt+dd { margin-top: 0.25em; }
+dd+dt { margin-top: 1em; }
+dt    { font-weight: bold; font-size: 110%; }
+dd    { line-height: 120%; padding: 0; margin: 0 0 0 2em; }
+
+dl tt  { background-color: rgba(0,0,0,   0.1); border-radius: 0.25em; display: inline-block; padding: 0 0.1em; }
+dl syn { background-color: rgba(0,0,128, 0.1); border-radius: 0.25em; display: inline-block; padding: 0 0.1em; }
diff --git a/jssm-dot.d.ts b/fsl_parser.d.ts
similarity index 100%
rename from jssm-dot.d.ts
rename to fsl_parser.d.ts
diff --git a/jest-dragon.config.js b/jest-dragon.config.js
index a0f498e6..138e6715 100644
--- a/jest-dragon.config.js
+++ b/jest-dragon.config.js
@@ -22,7 +22,7 @@ module.exports = {
     },
   },
 
-  collectCoverageFrom: ["src/ts/**/{!(jssm-dot),}.{js,ts}"],
+  collectCoverageFrom: ["src/ts/**/{!(fsl_parser),}.{js,ts}"],
 
   reporters: [
     ['default',             {}],
diff --git a/jest-spec.config.js b/jest-spec.config.js
index eaaca276..40199176 100644
--- a/jest-spec.config.js
+++ b/jest-spec.config.js
@@ -22,7 +22,7 @@ module.exports = {
     },
   },
 
-  collectCoverageFrom: ["src/ts/**/{!(jssm-dot),}.{js,ts}"],
+  collectCoverageFrom: ["src/ts/**/{!(fsl_parser),}.{js,ts}"],
 
   reporters: [
     ['default',             {}],
diff --git a/jest-stoch.config.js b/jest-stoch.config.js
index aefeaadf..f3597491 100644
--- a/jest-stoch.config.js
+++ b/jest-stoch.config.js
@@ -22,7 +22,7 @@ module.exports = {
     },
   },
 
-  collectCoverageFrom: ["src/ts/**/{!(jssm-dot),}.{js,ts}"],
+  collectCoverageFrom: ["src/ts/**/{!(fsl_parser),}.{js,ts}"],
 
   reporters: [
     ['default',             {}],
diff --git a/jest-unicode.config.js b/jest-unicode.config.js
new file mode 100644
index 00000000..6db22261
--- /dev/null
+++ b/jest-unicode.config.js
@@ -0,0 +1,33 @@
+
+module.exports = {
+
+  testEnvironment            : 'node',
+
+  moduleFileExtensions       : ['js', 'ts'],
+  coveragePathIgnorePatterns : ["/node_modules/", "/src/ts/tests/"],
+  testMatch                  : ['**/*.uspec.ts'],
+
+  transform                  : { '^.+\\.ts$': 'ts-jest' },
+
+  verbose                    : false,
+  collectCoverage            : true,
+  coverageDirectory          : "coverage/unicode/",
+
+  coverageThreshold : {
+    global : {
+      branches   : 0,
+      functions  : 0,
+      lines      : 0,
+      statements : 0,
+    },
+  },
+
+  collectCoverageFrom: ["src/ts/**/{!(fsl_parser),}.{js,ts}"],
+
+  reporters: [
+    ['default',             {}],
+    ['jest-json-reporter2', { outputDir: './coverage/unicode', outputFile: 'metrics.json',          fullOutput: false }],
+//  ['jest-json-reporter2', { outputDir: './coverage/unicode', outputFile: 'extended-metrics.json', fullOutput: true  }],
+  ]
+
+};
diff --git a/jssm.d.ts b/jssm.d.ts
index 2d44b798..b5251055 100644
--- a/jssm.d.ts
+++ b/jssm.d.ts
@@ -1,183 +1,12 @@
 declare type StateType = string;
-import { circular_buffer } from 'circular_buffer_js';
-import { JssmGenericState, JssmGenericConfig, JssmTransition, JssmTransitionList, // JssmTransitionRule,
-JssmMachineInternalState, JssmParseTree, JssmStateDeclaration, JssmArrow, JssmArrowDirection, JssmArrowKind, JssmLayout, FslDirection, FslTheme, HookDescription, HookHandler, HookContext, HookResult, HookComplexResult } from './jssm_types';
-import { seq, weighted_rand_select, weighted_sample_select, histograph, weighted_histo_key } from './jssm_util';
-import { shapes, gviz_shapes, named_colors } from './jssm_constants';
-import { version } from './version';
-/*********
- *
- *  Return the direction of an arrow - `right`, `left`, or `both`.
- *
- *  ```typescript
- *  import { arrow_direction } from 'jssm';
- *
- *  arrow_direction('->');    // 'right'
- *  arrow_direction('<~=>');  // 'both'
- *  ```
- *
- *  @param arrow The arrow to be evaluated
- *
- */
-declare function arrow_direction(arrow: JssmArrow): JssmArrowDirection;
-/*********
- *
- *  Return the direction of an arrow - `right`, `left`, or `both`.
- *
- *  ```typescript
- *  import { arrow_left_kind } from 'jssm';
- *
- *  arrow_left_kind('<-');    // 'legal'
- *  arrow_left_kind('<=');    // 'main'
- *  arrow_left_kind('<~');    // 'forced'
- *  arrow_left_kind('<->');   // 'legal'
- *  arrow_left_kind('->');    // 'none'
- *  ```
- *
- *  @param arrow The arrow to be evaluated
- *
- */
-declare function arrow_left_kind(arrow: JssmArrow): JssmArrowKind;
-/*********
- *
- *  Return the direction of an arrow - `right`, `left`, or `both`.
- *
- *  ```typescript
- *  import { arrow_left_kind } from 'jssm';
- *
- *  arrow_left_kind('->');    // 'legal'
- *  arrow_left_kind('=>');    // 'main'
- *  arrow_left_kind('~>');    // 'forced'
- *  arrow_left_kind('<->');   // 'legal'
- *  arrow_left_kind('<-');    // 'none'
- *  ```
- *
- *  @param arrow The arrow to be evaluated
- *
- */
-declare function arrow_right_kind(arrow: JssmArrow): JssmArrowKind;
-/*********
- *
- *  This method wraps the parser call that comes from the peg grammar,
- *  {@link parse}.  Generally neither this nor that should be used directly
- *  unless you mean to develop plugins or extensions for the machine.
- *
- *  Parses the intermediate representation of a compiled string down to a
- *  machine configuration object.  If you're using this (probably don't,) you're
- *  probably also using {@link compile} and {@link Machine.constructor}.
- *
- *  ```typescript
- *  import { parse, compile, Machine } from 'jssm';
- *
- *  const intermediate = wrap_parse('a -> b;', {});
- *  // [ {key:'transition', from:'a', se:{kind:'->',to:'b'}} ]
- *
- *  const cfg = compile(intermediate);
- *  // { start_states:['a'], transitions: [{ from:'a', to:'b', kind:'legal', forced_only:false, main_path:false }] }
- *
- *  const machine = new Machine(cfg);
- *  // Machine { _instance_name: undefined, _state: 'a', ...
- *  ```
- *
- *  This method is mostly for plugin and intermediate tool authors, or people
- *  who need to work with the machine's intermediate representation.
- *
- *  # Hey!
- *
- *  Most people looking at this want either the `sm` operator or method `from`,
- *  which perform all the steps in the chain.  The library's author mostly uses
- *  operator `sm`, and mostly falls back to `.from` when needing to parse
- *  strings dynamically instead of from template literals.
- *
- *  Operator {@link sm}:
- *
- *  ```typescript
- *  import { sm } from 'jssm';
- *
- *  const switch = sm`on <=> off;`;
- *  ```
- *
- *  Method {@link from}:
- *
- *  ```typescript
- *  import * as jssm from 'jssm';
- *
- *  const toggle = jssm.from('up <=> down;');
- *  ```
- *
- *  `wrap_parse` itself is an internal convenience method for alting out an
- *  object as the options call.  Not generally meant for external use.
- *
- *  @param input The FSL code to be evaluated
- *
- *  @param options Things to control about the instance
- *
- */
-declare function wrap_parse(input: string, options?: Object): any;
-/*********
- *
- *  Compile a machine's JSON intermediate representation to a config object.  If
- *  you're using this (probably don't,) you're probably also using
- *  {@link parse} to get the IR, and the object constructor
- *  {@link Machine.construct} to turn the config object into a workable machine.
- *
- *  ```typescript
- *  import { parse, compile, Machine } from 'jssm';
- *
- *  const intermediate = parse('a -> b;');
- *  // [ {key:'transition', from:'a', se:{kind:'->',to:'b'}} ]
- *
- *  const cfg = compile(intermediate);
- *  // { start_states:['a'], transitions: [{ from:'a', to:'b', kind:'legal', forced_only:false, main_path:false }] }
- *
- *  const machine = new Machine(cfg);
- *  // Machine { _instance_name: undefined, _state: 'a', ...
- *  ```
- *
- *  This method is mostly for plugin and intermediate tool authors, or people
- *  who need to work with the machine's intermediate representation.
- *
- *  # Hey!
- *
- *  Most people looking at this want either the `sm` operator or method `from`,
- *  which perform all the steps in the chain.  The library's author mostly uses
- *  operator `sm`, and mostly falls back to `.from` when needing to parse
- *  strings dynamically instead of from template literals.
- *
- *  Operator {@link sm}:
- *
- *  ```typescript
- *  import { sm } from 'jssm';
- *
- *  const switch = sm`on <=> off;`;
- *  ```
- *
- *  Method {@link from}:
- *
- *  ```typescript
- *  import * as jssm from 'jssm';
- *
- *  const toggle = jssm.from('up <=> down;');
- *  ```
- *
- *  @typeparam mDT The type of the machine data member; usually omitted
- *
- *  @param tree The parse tree to be boiled down into a machine config
- *
- */
-declare function compile(tree: JssmParseTree): JssmGenericConfig;
-/*********
- *
- *  An internal convenience wrapper for parsing then compiling a machine string.
- *  Not generally meant for external use.  Please see {@link compile} or
- *  {@link sm}.
- *
- *  @typeparam mDT The type of the machine data member; usually omitted
- *
- *  @param plan The FSL code to be evaluated and built into a machine config
- *
- */
-declare function make(plan: string): JssmGenericConfig;
+import { JssmGenericState, JssmGenericConfig, JssmStateConfig, JssmTransition, JssmTransitionList, // JssmTransitionRule,
+JssmMachineInternalState, JssmAllowsOverride, JssmStateDeclaration, JssmStateStyleKeyList, JssmLayout, JssmHistory, JssmSerialization, FslDirection, FslDirections, FslTheme, HookDescription, HookHandler, HookContext, HookResult, HookComplexResult } from './jssm_types';
+import { arrow_direction, arrow_left_kind, arrow_right_kind } from './jssm_arrow';
+import { compile, make, wrap_parse } from './jssm_compiler';
+import { seq, unique, find_repeated, weighted_rand_select, weighted_sample_select, histograph, weighted_histo_key } from './jssm_util';
+import * as constants from './jssm_constants';
+declare const shapes: string[], gviz_shapes: string[], named_colors: string[];
+import { version, build_time } from './version';
 /*********
  *
  *  An internal method meant to take a series of declarations and fold them into
@@ -188,15 +17,18 @@ declare function make(plan: string): JssmGenericConfig;
  *
  */
 declare function transfer_state_properties(state_decl: JssmStateDeclaration): JssmStateDeclaration;
+declare function state_style_condense(jssk: JssmStateStyleKeyList): JssmStateConfig;
 declare class Machine {
     _state: StateType;
     _states: Map;
-    _edges: Array>;
+    _edges: Array>;
     _edge_map: Map>;
     _named_transitions: Map;
     _actions: Map>;
     _reverse_actions: Map>;
     _reverse_action_targets: Map>;
+    _start_states: Set;
+    _end_states: Set;
     _machine_author?: Array;
     _machine_comment?: string;
     _machine_contributor?: Array;
@@ -215,7 +47,7 @@ declare class Machine {
     _arrange_declaration: Array>;
     _arrange_start_declaration: Array>;
     _arrange_end_declaration: Array>;
-    _theme: FslTheme;
+    _themes: FslTheme[];
     _flow: FslDirection;
     _has_hooks: boolean;
     _has_basic_hooks: boolean;
@@ -224,6 +56,7 @@ declare class Machine {
     _has_exit_hooks: boolean;
     _has_global_action_hooks: boolean;
     _has_transition_hooks: boolean;
+    _has_forced_transitions: boolean;
     _hooks: Map>;
     _named_hooks: Map>;
     _entry_hooks: Map>;
@@ -241,6 +74,8 @@ declare class Machine {
     _has_post_exit_hooks: boolean;
     _has_post_global_action_hooks: boolean;
     _has_post_transition_hooks: boolean;
+    _code_allows_override: JssmAllowsOverride;
+    _config_allows_override: JssmAllowsOverride;
     _post_hooks: Map>;
     _post_named_hooks: Map>;
     _post_entry_hooks: Map>;
@@ -251,9 +86,20 @@ declare class Machine {
     _post_main_transition_hook: HookHandler | undefined;
     _post_forced_transition_hook: HookHandler | undefined;
     _post_any_transition_hook: HookHandler | undefined;
-    _history: circular_buffer<[StateType, mDT]>;
+    _property_keys: Set;
+    _default_properties: Map;
+    _state_properties: Map;
+    _required_properties: Set;
+    _history: JssmHistory;
     _history_length: number;
-    constructor({ start_states, complete, transitions, machine_author, machine_comment, machine_contributor, machine_definition, machine_language, machine_license, machine_name, machine_version, state_declaration, fsl_version, dot_preamble, arrange_declaration, arrange_start_declaration, arrange_end_declaration, theme, flow, graph_layout, instance_name, history, data }: JssmGenericConfig);
+    _state_style: JssmStateConfig;
+    _active_state_style: JssmStateConfig;
+    _hooked_state_style: JssmStateConfig;
+    _terminal_state_style: JssmStateConfig;
+    _start_state_style: JssmStateConfig;
+    _end_state_style: JssmStateConfig;
+    _state_labels: Map;
+    constructor({ start_states, end_states, complete, transitions, machine_author, machine_comment, machine_contributor, machine_definition, machine_language, machine_license, machine_name, machine_version, state_declaration, property_definition, state_property, fsl_version, dot_preamble, arrange_declaration, arrange_start_declaration, arrange_end_declaration, theme, flow, graph_layout, instance_name, history, data, default_state_config, default_active_state_config, default_hooked_state_config, default_terminal_state_config, default_start_state_config, default_end_state_config, allows_override, config_allows_override }: JssmGenericConfig);
     /********
      *
      *  Internal method for fabricating states.  Not meant for external use.
@@ -269,17 +115,58 @@ declare class Machine {
      *  ```typescript
      *  import * as jssm from 'jssm';
      *
-     *  const switch = jssm.from('on <=> off;');
-     *  console.log( switch.state() );             // 'on'
+     *  const lswitch = jssm.from('on <=> off;');
+     *  console.log( lswitch.state() );             // 'on'
      *
-     *  switch.transition('off');
-     *  console.log( switch.state() );             // 'off'
+     *  lswitch.transition('off');
+     *  console.log( lswitch.state() );             // 'off'
      *  ```
      *
      *  @typeparam mDT The type of the machine data member; usually omitted
      *
      */
     state(): StateType;
+    /*********
+     *
+     *  Get the label for a given state, if any; return `undefined` otherwise.
+     *
+     *  ```typescript
+     *  import * as jssm from 'jssm';
+     *
+     *  const lswitch = jssm.from('a -> b; state a: { label: "Foo!"; };');
+     *  console.log( lswitch.label_for('a') );              // 'Foo!'
+     *  console.log( lswitch.label_for('b') );              // undefined
+     *  ```
+     *
+     *  See also {@link display_text}.
+     *
+     *  @typeparam mDT The type of the machine data member; usually omitted
+     *
+     */
+    label_for(state: StateType): string;
+    /*********
+     *
+     *  Get whatever the node should show as text.
+     *
+     *  Currently, this means to get the label for a given state, if any;
+     *  otherwise to return the node's name.  However, this definition is expected
+     *  to grow with time, and it is currently considered ill-advised to manually
+     *  parse this text.
+     *
+     *  See also {@link label_for}.
+     *
+     *  ```typescript
+     *  import * as jssm from 'jssm';
+     *
+     *  const lswitch = jssm.from('a -> b; state a: { label: "Foo!"; };');
+     *  console.log( lswitch.display_text('a') );              // 'Foo!'
+     *  console.log( lswitch.display_text('b') );              // 'b'
+     *  ```
+     *
+     *  @typeparam mDT The type of the machine data member; usually omitted
+     *
+     */
+    display_text(state: StateType): string;
     /*********
      *
      *  Get the current data of a machine.
@@ -287,14 +174,180 @@ declare class Machine {
      *  ```typescript
      *  import * as jssm from 'jssm';
      *
-     *  const switch = jssm.from('on <=> off;', {data: 1});
-     *  console.log( switch.data() );              // 1
+     *  const lswitch = jssm.from('on <=> off;', {data: 1});
+     *  console.log( lswitch.data() );              // 1
      *  ```
      *
      *  @typeparam mDT The type of the machine data member; usually omitted
      *
      */
     data(): mDT;
+    /*********
+     *
+     *  Get the current value of a given property name.
+     *
+     *  ```typescript
+     *
+     *  ```
+     *
+     *  @param name The relevant property name to look up
+     *
+     *  @returns The value behind the prop name.  Because functional props are
+     *  evaluated as getters, this can be anything.
+     *
+     */
+    prop(name: string): any;
+    /*********
+     *
+     *  Get the current value of a given property name.  If missing on the state
+     *  and without a global default, throw, unlike {@link prop}, which would
+     *  return `undefined` instead.
+     *
+     *  ```typescript
+     *
+     *  ```
+     *
+     *  @param name The relevant property name to look up
+     *
+     *  @returns The value behind the prop name.  Because functional props are
+     *  evaluated as getters, this can be anything.
+     *
+     */
+    strict_prop(name: string): any;
+    /*********
+     *
+     *  Get the current value of every prop, as an object.  If no current definition
+     *  exists for a prop - that is, if the prop was defined without a default and
+     *  the current state also doesn't define the prop - then that prop will be listed
+     *  in the returned object with a value of `undefined`.
+     *
+     *  ```typescript
+     *  const traffic_light = sm`
+     *
+     *    property can_go     default true;
+     *    property hesitate   default true;
+     *    property stop_first default false;
+     *
+     *    Off -> Red => Green => Yellow => Red;
+     *    [Red Yellow Green] ~> [Off FlashingRed];
+     *    FlashingRed -> Red;
+     *
+     *    state Red:         { property stop_first true;  property can_go false; };
+     *    state Off:         { property stop_first true;  };
+     *    state FlashingRed: { property stop_first true;  };
+     *    state Green:       { property hesitate   false; };
+     *
+     *  `;
+     *
+     *  traffic_light.state();  // Off
+     *  traffic_light.props();  // { can_go: true,  hesitate: true,  stop_first: true;  }
+     *
+     *  traffic_light.go('Red');
+     *  traffic_light.props();  // { can_go: false, hesitate: true,  stop_first: true;  }
+     *
+     *  traffic_light.go('Green');
+     *  traffic_light.props();  // { can_go: true,  hesitate: false, stop_first: false; }
+     *  ```
+     *
+     */
+    props(): object;
+    /*********
+     *
+     *  Get the current value of every prop, as an object.  Compare
+     *  {@link prop_map}, which returns a `Map`.
+     *
+     *  ```typescript
+     *
+     *  ```
+     *
+     */
+    /*********
+     *
+     *  Get the current value of every prop, as an object.  Compare
+     *  {@link prop_map}, which returns a `Map`.  Akin to {@link strict_prop},
+     *  this throws if a required prop is missing.
+     *
+     *  ```typescript
+     *
+     *  ```
+     *
+     */
+    /*********
+     *
+     *  Check whether a given string is a known property's name.
+     *
+     *  ```typescript
+     *  const example = sm`property foo default 1; a->b;`;
+     *
+     *  example.known_prop('foo');  // true
+     *  example.known_prop('bar');  // false
+     *  ```
+     *
+     *  @param prop_name The relevant property name to look up
+     *
+     */
+    known_prop(prop_name: string): boolean;
+    /*********
+     *
+     *  List all known property names.  If you'd also like values, use
+     *  {@link props} instead.  The order of the properties is not defined, and
+     *  the properties generally will not be sorted.
+     *
+     *  ```typescript
+     *  ```
+     *
+     */
+    known_props(): string[];
+    /********
+     *
+     *  Check whether a given state is a valid start state (either because it was
+     *  explicitly named as such, or because it was the first mentioned state.)
+     *
+     *  ```typescript
+     *  import { sm, is_start_state } from 'jssm';
+     *
+     *  const example = sm`a -> b;`;
+     *
+     *  console.log( final_test.is_start_state('a') );   // true
+     *  console.log( final_test.is_start_state('b') );   // false
+     *
+     *  const example = sm`start_states: [a b]; a -> b;`;
+     *
+     *  console.log( final_test.is_start_state('a') );   // true
+     *  console.log( final_test.is_start_state('b') );   // true
+     *  ```
+     *
+     *  @typeparam mDT The type of the machine data member; usually omitted
+     *
+     *  @param whichState The name of the state to check
+     *
+     */
+    is_start_state(whichState: StateType): boolean;
+    /********
+     *
+     *  Check whether a given state is a valid start state (either because it was
+     *  explicitly named as such, or because it was the first mentioned state.)
+     *
+     *  ```typescript
+     *  import { sm, is_end_state } from 'jssm';
+     *
+     *  const example = sm`a -> b;`;
+     *
+     *  console.log( final_test.is_start_state('a') );   // false
+     *  console.log( final_test.is_start_state('b') );   // true
+     *
+     *  const example = sm`end_states: [a b]; a -> b;`;
+     *
+     *  console.log( final_test.is_start_state('a') );   // true
+     *  console.log( final_test.is_start_state('b') );   // true
+     *  ```
+     *
+     *  @typeparam mDT The type of the machine data member; usually omitted
+     *
+     *  @param whichState The name of the state to check
+     *
+     */
+    is_end_state(whichState: StateType): boolean;
     /********
      *
      *  Check whether a given state is final (either has no exits or is marked
@@ -321,7 +374,7 @@ declare class Machine {
      *  `complete`.)
      *
      *  ```typescript
-     *  import { sm, state_is_final } from 'jssm';
+     *  import { sm, is_final } from 'jssm';
      *
      *  const final_test = sm`first -> second;`;
      *
@@ -330,10 +383,19 @@ declare class Machine {
      *  console.log( final_test.is_final() );   // true
      *  ```
      *
+     */
+    is_final(): boolean;
+    /********
+     *
+     *  Serialize the current machine, including all defining state but not the
+     *  machine string, to a structure.  This means you will need the machine
+     *  string to recreate (to not waste repeated space;) if you want the machine
+     *  string embedded, call {@link serialize_with_string} instead.
+     *
      *  @typeparam mDT The type of the machine data member; usually omitted
      *
      */
-    is_final(): boolean;
+    serialize(comment?: string | undefined): JssmSerialization;
     graph_layout(): string;
     dot_preamble(): string;
     machine_author(): Array;
@@ -357,8 +419,8 @@ declare class Machine {
      *  ```typescript
      *  import * as jssm from 'jssm';
      *
-     *  const switch = jssm.from('on <=> off;');
-     *  console.log( switch.states() );             // ['on', 'off']
+     *  const lswitch = jssm.from('on <=> off;');
+     *  console.log( lswitch.states() );             // ['on', 'off']
      *  ```
      *
      *  @typeparam mDT The type of the machine data member; usually omitted
@@ -373,10 +435,10 @@ declare class Machine {
      *  ```typescript
      *  import * as jssm from 'jssm';
      *
-     *  const switch = jssm.from('on <=> off;');
+     *  const lswitch = jssm.from('on <=> off;');
      *
-     *  console.log( switch.has_state('off') );     // true
-     *  console.log( switch.has_state('dance') );   // false
+     *  console.log( lswitch.has_state('off') );     // true
+     *  console.log( lswitch.has_state('dance') );   // false
      *  ```
      *
      *  @typeparam mDT The type of the machine data member; usually omitted
@@ -418,13 +480,35 @@ declare class Machine {
      *  @typeparam mDT The type of the machine data member; usually omitted
      *
      */
-    list_edges(): Array>;
+    list_edges(): Array>;
     list_named_transitions(): Map;
     list_actions(): Array;
-    theme(): FslTheme;
+    get uses_actions(): boolean;
+    get uses_forced_transitions(): boolean;
+    /*********
+     *
+     *  Check if the code that built the machine allows overriding state and data.
+     *
+     */
+    get code_allows_override(): JssmAllowsOverride;
+    /*********
+     *
+     *  Check if the machine config allows overriding state and data.
+     *
+     */
+    get config_allows_override(): JssmAllowsOverride;
+    /*********
+     *
+     *  Check if a machine allows overriding state and data.
+     *
+     */
+    get allows_override(): JssmAllowsOverride;
+    all_themes(): FslTheme[];
+    get themes(): FslTheme | FslTheme[];
+    set themes(to: FslTheme | FslTheme[]);
     flow(): FslDirection;
     get_transition_by_state_names(from: StateType, to: StateType): number;
-    lookup_transition_for(from: StateType, to: StateType): JssmTransition;
+    lookup_transition_for(from: StateType, to: StateType): JssmTransition;
     /********
      *
      *  List all transitions attached to the current state, sorted by entrance and
@@ -449,7 +533,10 @@ declare class Machine {
     /********
      *
      *  List all entrances attached to the current state.  Please note that the
-     *  order of the list is not defined.
+     *  order of the list is not defined.  This list includes both unforced and
+     *  forced entrances; if this isn't desired, consider
+     *  {@link list_unforced_entrances} or {@link list_forced_entrances} as
+     *  appropriate.
      *
      *  ```typescript
      *  import { sm } from 'jssm';
@@ -469,7 +556,9 @@ declare class Machine {
     /********
      *
      *  List all exits attached to the current state.  Please note that the order
-     *  of the list is not defined.
+     *  of the list is not defined.  This list includes both unforced and forced
+     *  exits; if this isn't desired, consider {@link list_unforced_exits} or
+     *  {@link list_forced_exits} as appropriate.
      *
      *  ```typescript
      *  import { sm } from 'jssm';
@@ -486,7 +575,7 @@ declare class Machine {
      *
      */
     list_exits(whichState?: StateType): Array;
-    probable_exits_for(whichState: StateType): Array>;
+    probable_exits_for(whichState: StateType): Array>;
     probabilistic_transition(): boolean;
     probabilistic_walk(n: number): Array;
     probabilistic_histo_walk(n: number): Map;
@@ -579,7 +668,27 @@ declare class Machine {
     post_hook_any_transition(handler: HookHandler): Machine;
     post_hook_entry(to: string, handler: HookHandler): Machine;
     post_hook_exit(from: string, handler: HookHandler): Machine;
-    edges_between(from: string, to: string): JssmTransition[];
+    edges_between(from: string, to: string): JssmTransition[];
+    /*********
+     *
+     *  Replace the current state and data with no regard to the graph.
+     *
+     *  ```typescript
+     *  import { sm } from 'jssm';
+     *
+     *  const machine = sm`a -> b -> c;`;
+     *  console.log( machine.state() );    // 'a'
+     *
+     *  machine.go('b');
+     *  machine.go('c');
+     *  console.log( machine.state() );    // 'c'
+     *
+     *  machine.override('a');
+     *  console.log( machine.state() );    // 'a'
+     *  ```
+     *
+     */
+    override(newState: StateType, newData?: mDT | undefined): void;
     transition_impl(newStateOrAction: StateType, newData: mDT | undefined, wasForced: boolean, wasAction: boolean): boolean;
     /*********
      *
@@ -665,7 +774,7 @@ declare class Machine {
     set history_length(to: number);
     /********
      *
-     *  Instruct the machine to complete an action.
+     *  Instruct the machine to complete an action.  Synonym for {@link do}.
      *
      *  ```typescript
      *  const light = sm`red 'next' -> green 'next' -> yellow 'next' -> red; [red yellow green] 'shutdown' ~> off 'start' -> red;`;
@@ -685,14 +794,214 @@ declare class Machine {
     action(actionName: StateType, newData?: mDT): boolean;
     /********
      *
-     *  Instruct the machine to complete a transition.
+     *  Get the standard style for a single state.  ***Does not*** include
+     *  composition from an applied theme, or things from the underlying base
+     *  stylesheet; only the modifications applied by this machine.
      *
      *  ```typescript
-     *  const light = sm`red -> green -> yellow -> red; [red yellow green] 'shutdown' ~> off 'start' -> red;`;
+     *  const light = sm`a -> b;`;
+     *  console.log(light.standard_state_style);
+     *  // {}
      *
-     *  light.state();               // 'red'
-     *  light.transition('green');   // true
-     *  light.state();               // 'green'
+     *  const light = sm`a -> b; state: { shape: circle; };`;
+     *  console.log(light.standard_state_style);
+     *  // { shape: 'circle' }
+     *  ```
+     *
+     *  @typeparam mDT The type of the machine data member; usually omitted
+     *
+     */
+    get standard_state_style(): JssmStateConfig;
+    /********
+     *
+     *  Get the hooked state style.  ***Does not*** include
+     *  composition from an applied theme, or things from the underlying base
+     *  stylesheet; only the modifications applied by this machine.
+     *
+     *  The hooked style is only applied to nodes which have a named hook in the
+     *  graph.  Open hooks set through the external API aren't graphed, because
+     *  that would be literally every node.
+     *
+     *  ```typescript
+     *  const light = sm`a -> b;`;
+     *  console.log(light.hooked_state_style);
+     *  // {}
+     *
+     *  const light = sm`a -> b; hooked_state: { shape: circle; };`;
+     *  console.log(light.hooked_state_style);
+     *  // { shape: 'circle' }
+     *  ```
+     *
+     *  @typeparam mDT The type of the machine data member; usually omitted
+     *
+     */
+    get hooked_state_style(): JssmStateConfig;
+    /********
+     *
+     *  Get the start state style.  ***Does not*** include composition from an
+     *  applied theme, or things from the underlying base stylesheet; only the
+     *  modifications applied by this machine.
+     *
+     *  Start states are defined by the directive `start_states`, or in absentia,
+     *  are the first mentioned state.
+     *
+     *  ```typescript
+     *  const light = sm`a -> b;`;
+     *  console.log(light.start_state_style);
+     *  // {}
+     *
+     *  const light = sm`a -> b; start_state: { shape: circle; };`;
+     *  console.log(light.start_state_style);
+     *  // { shape: 'circle' }
+     *  ```
+     *
+     *  @typeparam mDT The type of the machine data member; usually omitted
+     *
+     */
+    get start_state_style(): JssmStateConfig;
+    /********
+     *
+     *  Get the end state style.  ***Does not*** include
+     *  composition from an applied theme, or things from the underlying base
+     *  stylesheet; only the modifications applied by this machine.
+     *
+     *  End states are defined in the directive `end_states`, and are distinct
+     *  from terminal states.  End states are voluntary successful endpoints for a
+     *  process.  Terminal states are states that cannot be exited.  By example,
+     *  most error states are terminal states, but not end states.  Also, since
+     *  some end states can be exited and are determined by hooks, such as
+     *  recursive or iterative nodes, there is such a thing as an end state that
+     *  is not a terminal state.
+     *
+     *  ```typescript
+     *  const light = sm`a -> b;`;
+     *  console.log(light.standard_state_style);
+     *  // {}
+     *
+     *  const light = sm`a -> b; end_state: { shape: circle; };`;
+     *  console.log(light.standard_state_style);
+     *  // { shape: 'circle' }
+     *  ```
+     *
+     *  @typeparam mDT The type of the machine data member; usually omitted
+     *
+     */
+    get end_state_style(): JssmStateConfig;
+    /********
+     *
+     *  Get the terminal state style.  ***Does not*** include
+     *  composition from an applied theme, or things from the underlying base
+     *  stylesheet; only the modifications applied by this machine.
+     *
+     *  Terminal state styles are automatically determined by the machine.  Any
+     *  state without a valid exit transition is terminal.
+     *
+     *  ```typescript
+     *  const light = sm`a -> b;`;
+     *  console.log(light.terminal_state_style);
+     *  // {}
+     *
+     *  const light = sm`a -> b; terminal_state: { shape: circle; };`;
+     *  console.log(light.terminal_state_style);
+     *  // { shape: 'circle' }
+     *  ```
+     *
+     *  @typeparam mDT The type of the machine data member; usually omitted
+     *
+     */
+    get terminal_state_style(): JssmStateConfig;
+    /********
+     *
+     *  Get the style for the active state.  ***Does not*** include
+     *  composition from an applied theme, or things from the underlying base
+     *  stylesheet; only the modifications applied by this machine.
+     *
+     *  ```typescript
+     *  const light = sm`a -> b;`;
+     *  console.log(light.active_state_style);
+     *  // {}
+     *
+     *  const light = sm`a -> b; active_state: { shape: circle; };`;
+     *  console.log(light.active_state_style);
+     *  // { shape: 'circle' }
+     *  ```
+     *
+     *  @typeparam mDT The type of the machine data member; usually omitted
+     *
+     */
+    get active_state_style(): JssmStateConfig;
+    /********
+     *
+     *  Gets the composite style for a specific node by individually imposing the
+     *  style layers on a given object, after determining which layers are
+     *  appropriate.
+     *
+     *  The order of composition is base, then theme, then user content.  Each
+     *  item in the stack will be composited independently.  First, the base state
+     *  style, then the theme state style, then the user state style.
+     *
+     *  After the three state styles, we'll composite the hooked styles; then the
+     *  terminal styles; then the start styles; then the end styles; finally, the
+     *  active styles.  Remember, last wins.
+     *
+     *  The base state style must exist.  All other styles are optional.
+     *
+     *  @typeparam mDT The type of the machine data member; usually omitted
+     *
+     */
+    style_for(state: StateType): JssmStateConfig;
+    /********
+     *
+     *  Instruct the machine to complete an action.  Synonym for {@link action}.
+     *
+     *  ```typescript
+     *  const light = sm`
+     *    off 'start' -> red;
+     *    red 'next' -> green 'next' -> yellow 'next' -> red;
+     *    [red yellow green] 'shutdown' ~> off;
+     *  `;
+     *
+     *  light.state();       // 'off'
+     *  light.do('start');   // true
+     *  light.state();       // 'red'
+     *  light.do('next');    // true
+     *  light.state();       // 'green'
+     *  light.do('next');    // true
+     *  light.state();       // 'yellow'
+     *  light.do('dance');   // !! false - no such action
+     *  light.state();       // 'yellow'
+     *  light.do('start');   // !! false - yellow does not have the action start
+     *  light.state();       // 'yellow'
+     *  ```
+     *
+     *  @typeparam mDT The type of the machine data member; usually omitted
+     *
+     *  @param actionName The action to engage
+     *
+     *  @param newData The data change to insert during the action
+     *
+     */
+    do(actionName: StateType, newData?: mDT): boolean;
+    /********
+     *
+     *  Instruct the machine to complete a transition.  Synonym for {@link go}.
+     *
+     *  ```typescript
+     *  const light = sm`
+     *    off 'start' -> red;
+     *    red 'next' -> green 'next' -> yellow 'next' -> red;
+     *    [red yellow green] 'shutdown' ~> off;
+     *  `;
+     *
+     *  light.state();       // 'off'
+     *  light.go('red');     // true
+     *  light.state();       // 'red'
+     *  light.go('green');   // true
+     *  light.state();       // 'green'
+     *  light.go('blue');    // !! false - no such state
+     *  light.state();       // 'green'
+     *  light.go('red');     // !! false - green may not go directly to red, only to yellow
+     *  light.state();       // 'green'
      *  ```
      *
      *  @typeparam mDT The type of the machine data member; usually omitted
@@ -703,6 +1012,26 @@ declare class Machine {
      *
      */
     transition(newState: StateType, newData?: mDT): boolean;
+    /********
+     *
+     *  Instruct the machine to complete a transition.  Synonym for {@link transition}.
+     *
+     *  ```typescript
+     *  const light = sm`red -> green -> yellow -> red; [red yellow green] 'shutdown' ~> off 'start' -> red;`;
+     *
+     *  light.state();       // 'red'
+     *  light.go('green');   // true
+     *  light.state();       // 'green'
+     *  ```
+     *
+     *  @typeparam mDT The type of the machine data member; usually omitted
+     *
+     *  @param newState The state to switch to
+     *
+     *  @param newData The data change to insert during the transition
+     *
+     */
+    go(newState: StateType, newData?: mDT): boolean;
     /********
      *
      *  Instruct the machine to complete a forced transition (which will reject if
@@ -727,7 +1056,7 @@ declare class Machine {
      */
     force_transition(newState: StateType, newData?: mDT): boolean;
     current_action_for(action: StateType): number;
-    current_action_edge_for(action: StateType): JssmTransition;
+    current_action_edge_for(action: StateType): JssmTransition;
     valid_action(action: StateType, _newData?: mDT): boolean;
     valid_transition(newState: StateType, _newData?: mDT): boolean;
     valid_force_transition(newState: StateType, _newData?: mDT): boolean;
@@ -747,7 +1076,7 @@ declare class Machine {
  *  ```typescript
  *  import * as jssm from 'jssm';
  *
- *  const switch = jssm.from('on <=> off;');
+ *  const lswitch = jssm.from('on <=> off;');
  *  ```
  *
  *  @typeparam mDT The type of the machine data member; usually omitted
@@ -770,7 +1099,7 @@ declare function sm(template_strings: TemplateStringsArray, ...remainder: a
  *  ```typescript
  *  import * as jssm from 'jssm';
  *
- *  const switch = jssm.from('on <=> off;');
+ *  const lswitch = jssm.from('on <=> off;');
  *  ```
  *
  *  @typeparam mDT The type of the machine data member; usually omitted
@@ -780,8 +1109,9 @@ declare function sm(template_strings: TemplateStringsArray, ...remainder: a
  *  @param ExtraConstructorFields Extra non-code configuration to pass at creation time
  *
  */
-declare function from(MachineAsString: string, ExtraConstructorFields?: Partial> | undefined): Machine;
+declare function from(MachineAsString: string, ExtraConstructorFields?: Partial> | undefined): Machine;
 declare function is_hook_complex_result(hr: unknown): hr is HookComplexResult;
 declare function is_hook_rejection(hr: HookResult): boolean;
 declare function abstract_hook_step(maybe_hook: HookHandler | undefined, hook_args: HookContext): HookComplexResult;
-export { version, transfer_state_properties, Machine, make, wrap_parse as parse, compile, sm, from, arrow_direction, arrow_left_kind, arrow_right_kind, seq, weighted_rand_select, histograph, weighted_sample_select, weighted_histo_key, shapes, gviz_shapes, named_colors, is_hook_rejection, is_hook_complex_result, abstract_hook_step };
+declare function deserialize(machine_string: string, ser: JssmSerialization): Machine;
+export { version, build_time, transfer_state_properties, Machine, deserialize, make, wrap_parse as parse, compile, sm, from, arrow_direction, arrow_left_kind, arrow_right_kind, seq, unique, find_repeated, weighted_rand_select, histograph, weighted_sample_select, weighted_histo_key, constants, shapes, gviz_shapes, named_colors, is_hook_rejection, is_hook_complex_result, abstract_hook_step, state_style_condense, FslDirections };
diff --git a/jssm_arrow.d.ts b/jssm_arrow.d.ts
new file mode 100644
index 00000000..3d560838
--- /dev/null
+++ b/jssm_arrow.d.ts
@@ -0,0 +1,53 @@
+import { JssmArrow, JssmArrowDirection, JssmArrowKind } from './jssm_types';
+/*********
+ *
+ *  Return the direction of an arrow - `right`, `left`, or `both`.
+ *
+ *  ```typescript
+ *  import { arrow_direction } from 'jssm';
+ *
+ *  arrow_direction('->');    // 'right'
+ *  arrow_direction('<~=>');  // 'both'
+ *  ```
+ *
+ *  @param arrow The arrow to be evaluated
+ *
+ */
+declare function arrow_direction(arrow: JssmArrow): JssmArrowDirection;
+/*********
+ *
+ *  Return the direction of an arrow - `right`, `left`, or `both`.
+ *
+ *  ```typescript
+ *  import { arrow_left_kind } from 'jssm';
+ *
+ *  arrow_left_kind('<-');    // 'legal'
+ *  arrow_left_kind('<=');    // 'main'
+ *  arrow_left_kind('<~');    // 'forced'
+ *  arrow_left_kind('<->');   // 'legal'
+ *  arrow_left_kind('->');    // 'none'
+ *  ```
+ *
+ *  @param arrow The arrow to be evaluated
+ *
+ */
+declare function arrow_left_kind(arrow: JssmArrow): JssmArrowKind;
+/*********
+ *
+ *  Return the direction of an arrow - `right`, `left`, or `both`.
+ *
+ *  ```typescript
+ *  import { arrow_left_kind } from 'jssm';
+ *
+ *  arrow_left_kind('->');    // 'legal'
+ *  arrow_left_kind('=>');    // 'main'
+ *  arrow_left_kind('~>');    // 'forced'
+ *  arrow_left_kind('<->');   // 'legal'
+ *  arrow_left_kind('<-');    // 'none'
+ *  ```
+ *
+ *  @param arrow The arrow to be evaluated
+ *
+ */
+declare function arrow_right_kind(arrow: JssmArrow): JssmArrowKind;
+export { arrow_direction, arrow_left_kind, arrow_right_kind };
diff --git a/jssm_compiler.d.ts b/jssm_compiler.d.ts
new file mode 100644
index 00000000..2bf6c259
--- /dev/null
+++ b/jssm_compiler.d.ts
@@ -0,0 +1,135 @@
+import { JssmTransition, JssmCompileSe, JssmParseTree, JssmGenericConfig } from './jssm_types';
+/*********
+ *
+ *  Internal method meant to perform factory assembly of an edge.  Not meant for
+ *  external use.
+ *
+ *  @internal
+ *
+ *  @typeparam mDT The type of the machine data member; usually omitted
+ *
+ */
+declare function makeTransition(this_se: JssmCompileSe, from: StateType, to: StateType, isRight: boolean, _wasList?: Array, _wasIndex?: number): JssmTransition;
+/*********
+ *
+ *  This method wraps the parser call that comes from the peg grammar,
+ *  {@link parse}.  Generally neither this nor that should be used directly
+ *  unless you mean to develop plugins or extensions for the machine.
+ *
+ *  Parses the intermediate representation of a compiled string down to a
+ *  machine configuration object.  If you're using this (probably don't,) you're
+ *  probably also using {@link compile} and {@link Machine.constructor}.
+ *
+ *  ```typescript
+ *  import { parse, compile, Machine } from 'jssm';
+ *
+ *  const intermediate = wrap_parse('a -> b;', {});
+ *  // [ {key:'transition', from:'a', se:{kind:'->',to:'b'}} ]
+ *
+ *  const cfg = compile(intermediate);
+ *  // { start_states:['a'], transitions: [{ from:'a', to:'b', kind:'legal', forced_only:false, main_path:false }] }
+ *
+ *  const machine = new Machine(cfg);
+ *  // Machine { _instance_name: undefined, _state: 'a', ...
+ *  ```
+ *
+ *  This method is mostly for plugin and intermediate tool authors, or people
+ *  who need to work with the machine's intermediate representation.
+ *
+ *  # Hey!
+ *
+ *  Most people looking at this want either the `sm` operator or method `from`,
+ *  which perform all the steps in the chain.  The library's author mostly uses
+ *  operator `sm`, and mostly falls back to `.from` when needing to parse
+ *  strings dynamically instead of from template literals.
+ *
+ *  Operator {@link sm}:
+ *
+ *  ```typescript
+ *  import { sm } from 'jssm';
+ *
+ *  const lswitch = sm`on <=> off;`;
+ *  ```
+ *
+ *  Method {@link from}:
+ *
+ *  ```typescript
+ *  import * as jssm from 'jssm';
+ *
+ *  const toggle = jssm.from('up <=> down;');
+ *  ```
+ *
+ *  `wrap_parse` itself is an internal convenience method for alting out an
+ *  object as the options call.  Not generally meant for external use.
+ *
+ *  @param input The FSL code to be evaluated
+ *
+ *  @param options Things to control about the instance
+ *
+ */
+declare function wrap_parse(input: string, options?: Object): any;
+/*********
+ *
+ *  Compile a machine's JSON intermediate representation to a config object.  If
+ *  you're using this (probably don't,) you're probably also using
+ *  {@link parse} to get the IR, and the object constructor
+ *  {@link Machine.construct} to turn the config object into a workable machine.
+ *
+ *  ```typescript
+ *  import { parse, compile, Machine } from 'jssm';
+ *
+ *  const intermediate = parse('a -> b;');
+ *  // [ {key:'transition', from:'a', se:{kind:'->',to:'b'}} ]
+ *
+ *  const cfg = compile(intermediate);
+ *  // { start_states:['a'], transitions: [{ from:'a', to:'b', kind:'legal', forced_only:false, main_path:false }] }
+ *
+ *  const machine = new Machine(cfg);
+ *  // Machine { _instance_name: undefined, _state: 'a', ...
+ *  ```
+ *
+ *  This method is mostly for plugin and intermediate tool authors, or people
+ *  who need to work with the machine's intermediate representation.
+ *
+ *  # Hey!
+ *
+ *  Most people looking at this want either the `sm` operator or method `from`,
+ *  which perform all the steps in the chain.  The library's author mostly uses
+ *  operator `sm`, and mostly falls back to `.from` when needing to parse
+ *  strings dynamically instead of from template literals.
+ *
+ *  Operator {@link sm}:
+ *
+ *  ```typescript
+ *  import { sm } from 'jssm';
+ *
+ *  const lswitch = sm`on <=> off;`;
+ *  ```
+ *
+ *  Method {@link from}:
+ *
+ *  ```typescript
+ *  import * as jssm from 'jssm';
+ *
+ *  const toggle = jssm.from('up <=> down;');
+ *  ```
+ *
+ *  @typeparam mDT The type of the machine data member; usually omitted
+ *
+ *  @param tree The parse tree to be boiled down into a machine config
+ *
+ */
+declare function compile(tree: JssmParseTree): JssmGenericConfig;
+/*********
+ *
+ *  An internal convenience wrapper for parsing then compiling a machine string.
+ *  Not generally meant for external use.  Please see {@link compile} or
+ *  {@link sm}.
+ *
+ *  @typeparam mDT The type of the machine data member; usually omitted
+ *
+ *  @param plan The FSL code to be evaluated and built into a machine config
+ *
+ */
+declare function make(plan: string): JssmGenericConfig;
+export { compile, make, makeTransition, wrap_parse };
diff --git a/jssm_constants.d.ts b/jssm_constants.d.ts
index 004efca5..ac7ea7bd 100644
--- a/jssm_constants.d.ts
+++ b/jssm_constants.d.ts
@@ -1,4 +1,5 @@
+export declare const NegInfinity: number, PosInfinity: number, Epsilon: number, Pi: number, E: number, Root2: number, RootHalf: number, Ln2: number, Ln10: number, Log2E: number, Log10E: number, MaxSafeInt: number, MinSafeInt: number, MaxPosNum: number, MinPosNum: number, Phi = 1.618033988749895, EulerC = 0.5772156649015329;
 declare const gviz_shapes: string[];
 declare const shapes: string[];
 declare const named_colors: string[];
-export { gviz_shapes, shapes, named_colors };
+export { gviz_shapes, shapes, named_colors, };
diff --git a/jssm_theme.d.ts b/jssm_theme.d.ts
new file mode 100644
index 00000000..d5713932
--- /dev/null
+++ b/jssm_theme.d.ts
@@ -0,0 +1,4 @@
+import { FslTheme, JssmBaseTheme } from './jssm_types';
+import { base_theme } from './themes/jssm_base_stylesheet';
+declare const theme_mapping: Map;
+export { theme_mapping, base_theme };
diff --git a/jssm_types.d.ts b/jssm_types.d.ts
index 6c07c3a1..f43315df 100644
--- a/jssm_types.d.ts
+++ b/jssm_types.d.ts
@@ -1,3 +1,4 @@
+import { circular_buffer } from 'circular_buffer_js';
 declare type StateType = string;
 declare type JssmSuccess = {
     success: true;
@@ -23,14 +24,31 @@ declare type JssmArrowKind = 'none' | 'legal' | 'main' | 'forced';
 declare type JssmLayout = 'dot' | 'circo' | 'twopi' | 'fdp';
 declare type JssmCorner = 'regular' | 'rounded' | 'lined';
 declare type JssmLineStyle = 'solid' | 'dashed' | 'dotted';
-declare type FslDirection = 'up' | 'right' | 'down' | 'left';
-declare type FslTheme = 'default' | 'ocean' | 'modern' | 'none';
+declare type JssmAllowsOverride = true | false | undefined;
+declare const FslDirections: readonly ["up", "right", "down", "left"];
+declare type FslDirection = typeof FslDirections[number];
+declare const FslThemes: readonly ["default", "ocean", "modern", "plain", "bold"];
+declare type FslTheme = typeof FslThemes[number];
+declare type JssmSerialization = {
+    jssm_version: string;
+    timestamp: number;
+    comment?: string | undefined;
+    state: StateType;
+    history: [string, DataType][];
+    history_capacity: number;
+    data: DataType;
+};
+declare type JssmPropertyDefinition = {
+    name: string;
+    default_value?: any;
+    required?: boolean;
+};
 declare type JssmTransitionPermitter = (OldState: StateType, NewState: StateType, OldData: DataType, NewData: DataType) => boolean;
 declare type JssmTransitionPermitterMaybeArray = JssmTransitionPermitter | Array>;
-declare type JssmTransition = {
+declare type JssmTransition = {
     from: StateType;
     to: StateType;
-    name?: string;
+    name?: StateType;
     action?: StateType;
     check?: JssmTransitionPermitterMaybeArray;
     probability?: number;
@@ -38,7 +56,7 @@ declare type JssmTransition = {
     forced_only: boolean;
     main_path: boolean;
 };
-declare type JssmTransitions = Array>;
+declare type JssmTransitions = JssmTransition[];
 declare type JssmTransitionList = {
     entrances: Array;
     exits: Array;
@@ -62,7 +80,7 @@ declare type JssmMachineInternalState = {
     edge_map: Map>;
     actions: Map>;
     reverse_actions: Map>;
-    edges: Array>;
+    edges: Array>;
 };
 declare type JssmStatePermitter = (OldState: StateType, NewState: StateType, OldData: DataType, NewData: DataType) => boolean;
 declare type JssmStatePermitterMaybeArray = JssmStatePermitter | Array>;
@@ -71,7 +89,7 @@ declare type JssmGenericMachine = {
     state: StateType;
     data?: DataType;
     nodes?: Array;
-    transitions: JssmTransitions;
+    transitions: JssmTransitions;
     check?: JssmStatePermitterMaybeArray;
     min_transitions?: number;
     max_transitions?: number;
@@ -83,23 +101,84 @@ declare type JssmGenericMachine = {
 declare type JssmStateDeclarationRule = {
     key: string;
     value: any;
+    name?: string;
 };
 declare type JssmStateDeclaration = {
     declarations: Array;
     shape?: JssmShape;
     color?: JssmColor;
     corners?: JssmCorner;
-    linestyle?: JssmLineStyle;
+    lineStyle?: JssmLineStyle;
+    stateLabel?: string;
     textColor?: JssmColor;
     backgroundColor?: JssmColor;
     borderColor?: JssmColor;
     state: StateType;
-};
-declare type JssmGenericConfig = {
+    property?: {
+        name: string;
+        value: unknown;
+    };
+};
+declare type JssmStateConfig = Partial;
+declare type JssmStateStyleShape = {
+    key: 'shape';
+    value: JssmShape;
+};
+declare type JssmStateStyleColor = {
+    key: 'color';
+    value: JssmColor;
+};
+declare type JssmStateStyleTextColor = {
+    key: 'text-color';
+    value: JssmColor;
+};
+declare type JssmStateStyleCorners = {
+    key: 'corners';
+    value: JssmCorner;
+};
+declare type JssmStateStyleLineStyle = {
+    key: 'line-style';
+    value: JssmLineStyle;
+};
+declare type JssmStateStyleStateLabel = {
+    key: 'state-label';
+    value: string;
+};
+declare type JssmStateStyleBackgroundColor = {
+    key: 'background-color';
+    value: JssmColor;
+};
+declare type JssmStateStyleBorderColor = {
+    key: 'border-color';
+    value: JssmColor;
+};
+declare type JssmStateStyleKey = JssmStateStyleShape | JssmStateStyleColor | JssmStateStyleTextColor | JssmStateStyleCorners | JssmStateStyleLineStyle | JssmStateStyleBackgroundColor | JssmStateStyleStateLabel | JssmStateStyleBorderColor;
+declare type JssmStateStyleKeyList = JssmStateStyleKey[];
+declare type JssmBaseTheme = {
+    name: string;
+    state: JssmStateConfig;
+    hooked: JssmStateConfig;
+    start: JssmStateConfig;
+    end: JssmStateConfig;
+    terminal: JssmStateConfig;
+    active: JssmStateConfig;
+    active_hooked: JssmStateConfig;
+    active_start: JssmStateConfig;
+    active_end: JssmStateConfig;
+    active_terminal: JssmStateConfig;
+    graph: undefined;
+    legal: undefined;
+    main: undefined;
+    forced: undefined;
+    action: undefined;
+    title: undefined;
+};
+declare type JssmTheme = Partial;
+declare type JssmGenericConfig = {
     graph_layout?: JssmLayout;
     complete?: Array;
-    transitions: JssmTransitions;
-    theme?: FslTheme;
+    transitions: JssmTransitions;
+    theme?: FslTheme[];
     flow?: FslDirection;
     name?: string;
     data?: DataType;
@@ -112,10 +191,14 @@ declare type JssmGenericConfig = {
     allow_force?: false;
     actions?: JssmPermittedOpt;
     simplify_bidi?: boolean;
+    allows_override?: JssmAllowsOverride;
+    config_allows_override?: JssmAllowsOverride;
     dot_preamble?: string;
     start_states: Array;
     end_states?: Array;
-    state_declaration?: Array;
+    state_declaration?: Object[];
+    property_definition?: JssmPropertyDefinition[];
+    state_property?: JssmPropertyDefinition[];
     arrange_declaration?: Array>;
     arrange_start_declaration?: Array>;
     arrange_end_declaration?: Array>;
@@ -130,29 +213,38 @@ declare type JssmGenericConfig = {
     fsl_version?: string;
     auto_api?: boolean | string;
     instance_name?: string | undefined;
-};
-declare type JssmCompileRule = {
+    default_state_config?: JssmStateStyleKeyList;
+    default_start_state_config?: JssmStateStyleKeyList;
+    default_end_state_config?: JssmStateStyleKeyList;
+    default_hooked_state_config?: JssmStateStyleKeyList;
+    default_terminal_state_config?: JssmStateStyleKeyList;
+    default_active_state_config?: JssmStateStyleKeyList;
+};
+declare type JssmCompileRule = {
     agg_as: string;
     val: any;
 };
-declare type JssmCompileSe = {
+declare type JssmCompileSe = {
     to: StateType;
-    se: JssmCompileSe;
+    se: JssmCompileSe;
     kind: JssmArrow;
     l_action?: StateType;
     r_action?: StateType;
     l_probability: number;
     r_probability: number;
 };
-declare type JssmCompileSeStart = {
-    from: DataType;
-    se: JssmCompileSe;
+declare type JssmCompileSeStart = {
+    from: StateType;
+    se: JssmCompileSe;
     key: string;
     value?: string | number;
     name?: string;
+    state?: string;
+    default_value?: any;
+    required?: boolean;
 };
-declare type JssmParseTree = Array>;
-declare type JssmParseFunctionType = (string: any) => JssmParseTree;
+declare type JssmParseTree = Array>;
+declare type JssmParseFunctionType = (string: any) => JssmParseTree;
 declare type BasicHookDescription = {
     kind: 'hook';
     from: string;
@@ -254,14 +346,17 @@ declare type HookComplexResult = {
     pass: boolean;
     state?: StateType;
     data?: mDT;
+    next_data?: mDT;
 };
 declare type HookResult = true | false | undefined | void | HookComplexResult; /** Documents whether a hook succeeded, either with a primitive or a reference to the hook complex object */
 declare type HookContext = {
     data: mDT;
+    next_data: mDT;
 };
 declare type HookHandler = (hook_context: HookContext) => HookResult;
 declare type PostHookHandler = (hook_context: HookContext) => void;
 declare type JssmErrorExtendedInfo = {
     requested_state?: StateType | undefined;
 };
-export { JssmColor, JssmShape, JssmTransition, JssmTransitions, JssmTransitionList, JssmTransitionRule, JssmArrow, JssmArrowKind, JssmArrowDirection, JssmGenericConfig, JssmGenericState, JssmGenericMachine, JssmParseTree, JssmCompileSe, JssmCompileSeStart, JssmCompileRule, JssmPermitted, JssmPermittedOpt, JssmResult, JssmStateDeclaration, JssmStateDeclarationRule, JssmLayout, JssmParseFunctionType, JssmMachineInternalState, JssmErrorExtendedInfo, FslDirection, FslTheme, HookDescription, HookHandler, HookContext, HookResult, HookComplexResult };
+declare type JssmHistory = circular_buffer<[StateType, mDT]>;
+export { JssmColor, JssmShape, JssmTransition, JssmTransitions, JssmTransitionList, JssmTransitionRule, JssmArrow, JssmArrowKind, JssmArrowDirection, JssmGenericConfig, JssmGenericState, JssmGenericMachine, JssmParseTree, JssmCompileSe, JssmCompileSeStart, JssmCompileRule, JssmPermitted, JssmPermittedOpt, JssmResult, JssmStateDeclaration, JssmStateDeclarationRule, JssmStateConfig, JssmStateStyleKey, JssmStateStyleKeyList, JssmBaseTheme, JssmTheme, JssmLayout, JssmHistory, JssmSerialization, JssmPropertyDefinition, JssmAllowsOverride, JssmParseFunctionType, JssmMachineInternalState, JssmErrorExtendedInfo, FslDirections, FslDirection, FslThemes, FslTheme, HookDescription, HookHandler, HookContext, HookResult, HookComplexResult };
diff --git a/jssm_util.d.ts b/jssm_util.d.ts
index ee6e1a31..7f3b82bd 100644
--- a/jssm_util.d.ts
+++ b/jssm_util.d.ts
@@ -35,6 +35,13 @@ declare function seq(n: number): number[];
 declare const histograph: Function;
 declare const weighted_sample_select: Function;
 declare const weighted_histo_key: Function;
+/*******
+ *
+ *  Internal method generating names for edges for the hook lookup map.  Not
+ *  meant for external use.
+ *
+ */
+declare function name_bind_prop_and_state(prop: string, state: string): string;
 /*******
  *
  *  Internal method generating names for edges for the hook lookup map.  Not
@@ -57,4 +64,40 @@ declare const named_hook_name: (from: string, to: string, action: string) => str
  *
  */
 declare const make_mulberry_rand: (a?: number | undefined) => () => number;
-export { seq, arr_uniq_p, histograph, weighted_histo_key, weighted_rand_select, weighted_sample_select, array_box_if_string, hook_name, named_hook_name, make_mulberry_rand };
+/*******
+ *
+ *  Reduces an array to its unique contents.  Compares with `===` and makes no
+ *  effort to deep-compare contents; two matching arrays or objects contained
+ *  will be treated as distinct, according to javascript rules.  This also means
+ *  that `NaNs` will be ***dropped***, because they do not self-compare.
+ *
+ *  ```typescript
+ *  unique( [] );                     // []
+ *  unique( [0,0] );                  // [0]
+ *  unique( [0,1,2, 0,1,2, 0,1,2] );  // [0,1,2]
+ *  unique( [ [1], [1] ] );           // [ [1], [1] ] because arrays don't match
+ *  unique( [0,NaN,2] );              // [0,2]
+ *  ```
+ *
+ */
+declare const unique: (arr?: T[]) => T[];
+/*******
+ *
+ *  Lists all repeated items in an array along with their counts.  Subject to
+ *  matching rules of Map.  `NaN` is manually removed because of conflict rules
+ *  around {@link unique}.  Because these are compared with `===` and because
+ *  arrays and objects never match that way unless they're the same object,
+ *  arrays and objects are never considered repeats.
+ *
+ *  ```typescript
+ *  find_repeated([ ]);                     // []
+ *  find_repeated([ "one" ]);               // []
+ *  find_repeated([ "one", "two" ]);        // []
+ *  find_repeated([ "one", "one" ]);        // [ ["one", 2] ]
+ *  find_repeated([ "one", "two", "one" ]); // [ ["one", 2] ]
+ *  find_repeated([ 0, NaN, 0, NaN ]);      // [ [0,     2] ]
+ *  ```
+ *
+ */
+declare function find_repeated(arr: T[]): [T, number][];
+export { seq, unique, find_repeated, arr_uniq_p, histograph, weighted_histo_key, weighted_rand_select, weighted_sample_select, array_box_if_string, name_bind_prop_and_state, hook_name, named_hook_name, make_mulberry_rand };
diff --git a/notes/README.md b/notes/README.md
new file mode 100644
index 00000000..b27172b9
--- /dev/null
+++ b/notes/README.md
@@ -0,0 +1,8 @@
+# jssm
+
+Easy.  Small.  Fast.  TS, es6, es5.  Node, Browser.  100% coverage.  Property
+tests.  Fuzz tests.  Language tests for a dozen languages and emoji.  Easy to
+share online.  Easy to embed.
+
+
+
diff --git a/package-lock.json b/package-lock.json
index 6a9443f8..21c3a53a 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,17 +1,16 @@
 {
   "name": "jssm",
-  "version": "5.76.0",
+  "version": "5.85.2",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
-      "version": "5.76.0",
+      "version": "5.85.2",
       "license": "MIT",
       "dependencies": {
         "better_git_changelog": "^1.6.1",
         "circular_buffer_js": "^1.10.0",
-        "reduce-to-639-1": "^1.0.4",
-        "typedoc-plugin-missing-exports": "^0.23.0"
+        "reduce-to-639-1": "^1.1.0"
       },
       "devDependencies": {
         "@knodes/typedoc-plugin-pages": "^0.22.5",
@@ -22,6 +21,7 @@
         "@typescript-eslint/eslint-plugin": "^5.30.4",
         "@typescript-eslint/parser": "^5.30.4",
         "benny": "^3.7.1",
+        "chalk": "^4.1.2",
         "cloc": "^2.10.0",
         "coveralls": "^3.0.11",
         "eslint": "^7.32.0",
@@ -37,10 +37,12 @@
         "pegjs": "^0.10.0",
         "rollup": "^2.72.1",
         "semver": "^5.7.1",
-        "terser": "^5.13.1",
+        "terser": "^5.14.2",
         "text_audit": "^0.9.3",
         "ts-jest": "^27.0.7",
+        "twitter-api-client": "^1.6.0",
         "typedoc": "^0.22.18",
+        "typedoc-plugin-missing-exports": "^0.23.0",
         "typescript": "^4.7.4",
         "xml2js": "^0.4.23"
       },
@@ -113,30 +115,30 @@
       }
     },
     "node_modules/@babel/compat-data": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.18.6.tgz",
-      "integrity": "sha512-tzulrgDT0QD6U7BJ4TKVk2SDDg7wlP39P9yAx1RfLy7vP/7rsDRlWVfbWxElslu56+r7QOhB2NSDsabYYruoZQ==",
+      "version": "7.18.13",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.18.13.tgz",
+      "integrity": "sha512-5yUzC5LqyTFp2HLmDoxGQelcdYgSpP9xsnMWBphAscOdFrHSAVbLNzWiy32sVNDqJRDiJK6klfDnAgu6PAGSHw==",
       "dev": true,
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/core": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.18.6.tgz",
-      "integrity": "sha512-cQbWBpxcbbs/IUredIPkHiAGULLV8iwgNRMFzvbhEXISp4f3rUUXE5+TIw6KwUWUR3DwyI6gmBRnmAtYaWehwQ==",
+      "version": "7.18.13",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.18.13.tgz",
+      "integrity": "sha512-ZisbOvRRusFktksHSG6pjj1CSvkPkcZq/KHD45LAkVP/oiHJkNBZWfpvlLmX8OtHDG8IuzsFlVRWo08w7Qxn0A==",
       "dev": true,
       "dependencies": {
         "@ampproject/remapping": "^2.1.0",
         "@babel/code-frame": "^7.18.6",
-        "@babel/generator": "^7.18.6",
-        "@babel/helper-compilation-targets": "^7.18.6",
-        "@babel/helper-module-transforms": "^7.18.6",
-        "@babel/helpers": "^7.18.6",
-        "@babel/parser": "^7.18.6",
-        "@babel/template": "^7.18.6",
-        "@babel/traverse": "^7.18.6",
-        "@babel/types": "^7.18.6",
+        "@babel/generator": "^7.18.13",
+        "@babel/helper-compilation-targets": "^7.18.9",
+        "@babel/helper-module-transforms": "^7.18.9",
+        "@babel/helpers": "^7.18.9",
+        "@babel/parser": "^7.18.13",
+        "@babel/template": "^7.18.10",
+        "@babel/traverse": "^7.18.13",
+        "@babel/types": "^7.18.13",
         "convert-source-map": "^1.7.0",
         "debug": "^4.1.0",
         "gensync": "^1.0.0-beta.2",
@@ -173,9 +175,9 @@
       }
     },
     "node_modules/@babel/eslint-parser": {
-      "version": "7.18.2",
-      "resolved": "https://registry.npmjs.org/@babel/eslint-parser/-/eslint-parser-7.18.2.tgz",
-      "integrity": "sha512-oFQYkE8SuH14+uR51JVAmdqwKYXGRjEXx7s+WiagVjqQ+HPE+nnwyF2qlVG8evUsUHmPcA+6YXMEDbIhEyQc5A==",
+      "version": "7.18.9",
+      "resolved": "https://registry.npmjs.org/@babel/eslint-parser/-/eslint-parser-7.18.9.tgz",
+      "integrity": "sha512-KzSGpMBggz4fKbRbWLNyPVTuQr6cmCcBhOyXTw/fieOVaw5oYAwcAj4a7UKcDYCPxQq+CG1NCDZH9e2JTXquiQ==",
       "dev": true,
       "dependencies": {
         "eslint-scope": "^5.1.1",
@@ -190,6 +192,15 @@
         "eslint": "^7.5.0 || ^8.0.0"
       }
     },
+    "node_modules/@babel/eslint-parser/node_modules/eslint-visitor-keys": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz",
+      "integrity": "sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==",
+      "dev": true,
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/@babel/eslint-parser/node_modules/semver": {
       "version": "6.3.0",
       "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz",
@@ -200,12 +211,12 @@
       }
     },
     "node_modules/@babel/generator": {
-      "version": "7.18.7",
-      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.18.7.tgz",
-      "integrity": "sha512-shck+7VLlY72a2w9c3zYWuE1pwOKEiQHV7GTUbSnhyl5eu3i04t30tBY82ZRWrDfo3gkakCFtevExnxbkf2a3A==",
+      "version": "7.18.13",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.18.13.tgz",
+      "integrity": "sha512-CkPg8ySSPuHTYPJYo7IRALdqyjM9HCbt/3uOBEFbzyGVP6Mn8bwFPB0jX6982JVNBlYzM1nnPkfjuXSOPtQeEQ==",
       "dev": true,
       "dependencies": {
-        "@babel/types": "^7.18.7",
+        "@babel/types": "^7.18.13",
         "@jridgewell/gen-mapping": "^0.3.2",
         "jsesc": "^2.5.1"
       },
@@ -228,12 +239,12 @@
       }
     },
     "node_modules/@babel/helper-compilation-targets": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.18.6.tgz",
-      "integrity": "sha512-vFjbfhNCzqdeAtZflUFrG5YIFqGTqsctrtkZ1D/NB0mDW9TwW3GmmUepYY4G9wCET5rY5ugz4OGTcLd614IzQg==",
+      "version": "7.18.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.18.9.tgz",
+      "integrity": "sha512-tzLCyVmqUiFlcFoAPLA/gL9TeYrF61VLNtb+hvkuVaB5SUjW7jcfrglBIX1vUIoT7CLP3bBlIMeyEsIl2eFQNg==",
       "dev": true,
       "dependencies": {
-        "@babel/compat-data": "^7.18.6",
+        "@babel/compat-data": "^7.18.8",
         "@babel/helper-validator-option": "^7.18.6",
         "browserslist": "^4.20.2",
         "semver": "^6.3.0"
@@ -255,22 +266,22 @@
       }
     },
     "node_modules/@babel/helper-environment-visitor": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.18.6.tgz",
-      "integrity": "sha512-8n6gSfn2baOY+qlp+VSzsosjCVGFqWKmDF0cCWOybh52Dw3SEyoWR1KrhMJASjLwIEkkAufZ0xvr+SxLHSpy2Q==",
+      "version": "7.18.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.18.9.tgz",
+      "integrity": "sha512-3r/aACDJ3fhQ/EVgFy0hpj8oHyHpQc+LPtJoY9SzTThAsStm4Ptegq92vqKoE3vD706ZVFWITnMnxucw+S9Ipg==",
       "dev": true,
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-function-name": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.18.6.tgz",
-      "integrity": "sha512-0mWMxV1aC97dhjCah5U5Ua7668r5ZmSC2DLfH2EZnf9c3/dHZKiFa5pRLMH5tjSl471tY6496ZWk/kjNONBxhw==",
+      "version": "7.18.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.18.9.tgz",
+      "integrity": "sha512-fJgWlZt7nxGksJS9a0XdSaI4XvpExnNIgRP+rVefWh5U7BL8pPuir6SJUmFKRfjWQ51OtWSzwOxhaH/EBWWc0A==",
       "dev": true,
       "dependencies": {
         "@babel/template": "^7.18.6",
-        "@babel/types": "^7.18.6"
+        "@babel/types": "^7.18.9"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -301,28 +312,28 @@
       }
     },
     "node_modules/@babel/helper-module-transforms": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.18.6.tgz",
-      "integrity": "sha512-L//phhB4al5uucwzlimruukHB3jRd5JGClwRMD/ROrVjXfLqovYnvQrK/JK36WYyVwGGO7OD3kMyVTjx+WVPhw==",
+      "version": "7.18.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.18.9.tgz",
+      "integrity": "sha512-KYNqY0ICwfv19b31XzvmI/mfcylOzbLtowkw+mfvGPAQ3kfCnMLYbED3YecL5tPd8nAYFQFAd6JHp2LxZk/J1g==",
       "dev": true,
       "dependencies": {
-        "@babel/helper-environment-visitor": "^7.18.6",
+        "@babel/helper-environment-visitor": "^7.18.9",
         "@babel/helper-module-imports": "^7.18.6",
         "@babel/helper-simple-access": "^7.18.6",
         "@babel/helper-split-export-declaration": "^7.18.6",
         "@babel/helper-validator-identifier": "^7.18.6",
         "@babel/template": "^7.18.6",
-        "@babel/traverse": "^7.18.6",
-        "@babel/types": "^7.18.6"
+        "@babel/traverse": "^7.18.9",
+        "@babel/types": "^7.18.9"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-plugin-utils": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.18.6.tgz",
-      "integrity": "sha512-gvZnm1YAAxh13eJdkb9EWHBnF3eAub3XTLCZEehHT2kWxiKVRL64+ae5Y6Ivne0mVHmMYKT+xWgZO+gQhuLUBg==",
+      "version": "7.18.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.18.9.tgz",
+      "integrity": "sha512-aBXPT3bmtLryXaoJLyYPXPlSD4p1ld9aYeR+sJNOZjJJGiOpb+fKfh3NkcCu7J54nUJwCERPBExCCpyCOHnu/w==",
       "dev": true,
       "engines": {
         "node": ">=6.9.0"
@@ -352,6 +363,15 @@
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.18.10",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.18.10.tgz",
+      "integrity": "sha512-XtIfWmeNY3i4t7t4D2t02q50HvqHybPqW2ki1kosnvWCwuCMeo81Jf0gwr85jy/neUdg5XDdeFE/80DXiO+njw==",
+      "dev": true,
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
     "node_modules/@babel/helper-validator-identifier": {
       "version": "7.18.6",
       "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.18.6.tgz",
@@ -371,14 +391,14 @@
       }
     },
     "node_modules/@babel/helpers": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.18.6.tgz",
-      "integrity": "sha512-vzSiiqbQOghPngUYt/zWGvK3LAsPhz55vc9XNN0xAl2gV4ieShI2OQli5duxWHD+72PZPTKAcfcZDE1Cwc5zsQ==",
+      "version": "7.18.9",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.18.9.tgz",
+      "integrity": "sha512-Jf5a+rbrLoR4eNdUmnFu8cN5eNJT6qdTdOg5IHIzq87WwyRw9PwguLFOWYgktN/60IP4fgDUawJvs7PjQIzELQ==",
       "dev": true,
       "dependencies": {
         "@babel/template": "^7.18.6",
-        "@babel/traverse": "^7.18.6",
-        "@babel/types": "^7.18.6"
+        "@babel/traverse": "^7.18.9",
+        "@babel/types": "^7.18.9"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -470,9 +490,9 @@
       }
     },
     "node_modules/@babel/parser": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.18.6.tgz",
-      "integrity": "sha512-uQVSa9jJUe/G/304lXspfWVpKpK4euFLgGiMQFOCpM/bgcAdeoHwi/OQz23O9GK2osz26ZiXRRV9aV+Yl1O8tw==",
+      "version": "7.18.13",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.18.13.tgz",
+      "integrity": "sha512-dgXcIfMuQ0kgzLB2b9tRZs7TTFFaGM2AbtA4fJgUUYukzGH4jwsS7hzQHEGs67jdehpm22vkgKwvbU+aEflgwg==",
       "dev": true,
       "bin": {
         "parser": "bin/babel-parser.js"
@@ -644,14 +664,14 @@
       }
     },
     "node_modules/@babel/template": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.18.6.tgz",
-      "integrity": "sha512-JoDWzPe+wgBsTTgdnIma3iHNFC7YVJoPssVBDjiHfNlyt4YcunDtcDOUmfVDfCK5MfdsaIoX9PkijPhjH3nYUw==",
+      "version": "7.18.10",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.18.10.tgz",
+      "integrity": "sha512-TI+rCtooWHr3QJ27kJxfjutghu44DLnasDMwpDqCXVTal9RLp3RSYNh4NdBrRP2cQAoG9A8juOQl6P6oZG4JxA==",
       "dev": true,
       "dependencies": {
         "@babel/code-frame": "^7.18.6",
-        "@babel/parser": "^7.18.6",
-        "@babel/types": "^7.18.6"
+        "@babel/parser": "^7.18.10",
+        "@babel/types": "^7.18.10"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -670,19 +690,19 @@
       }
     },
     "node_modules/@babel/traverse": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.18.6.tgz",
-      "integrity": "sha512-zS/OKyqmD7lslOtFqbscH6gMLFYOfG1YPqCKfAW5KrTeolKqvB8UelR49Fpr6y93kYkW2Ik00mT1LOGiAGvizw==",
+      "version": "7.18.13",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.18.13.tgz",
+      "integrity": "sha512-N6kt9X1jRMLPxxxPYWi7tgvJRH/rtoU+dbKAPDM44RFHiMH8igdsaSBgFeskhSl/kLWLDUvIh1RXCrTmg0/zvA==",
       "dev": true,
       "dependencies": {
         "@babel/code-frame": "^7.18.6",
-        "@babel/generator": "^7.18.6",
-        "@babel/helper-environment-visitor": "^7.18.6",
-        "@babel/helper-function-name": "^7.18.6",
+        "@babel/generator": "^7.18.13",
+        "@babel/helper-environment-visitor": "^7.18.9",
+        "@babel/helper-function-name": "^7.18.9",
         "@babel/helper-hoist-variables": "^7.18.6",
         "@babel/helper-split-export-declaration": "^7.18.6",
-        "@babel/parser": "^7.18.6",
-        "@babel/types": "^7.18.6",
+        "@babel/parser": "^7.18.13",
+        "@babel/types": "^7.18.13",
         "debug": "^4.1.0",
         "globals": "^11.1.0"
       },
@@ -712,11 +732,12 @@
       }
     },
     "node_modules/@babel/types": {
-      "version": "7.18.7",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.18.7.tgz",
-      "integrity": "sha512-QG3yxTcTIBoAcQmkCs+wAPYZhu7Dk9rXKacINfNbdJDNERTbLQbHGyVG8q/YGMPeCJRIhSY0+fTc5+xuh6WPSQ==",
+      "version": "7.18.13",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.18.13.tgz",
+      "integrity": "sha512-ePqfTihzW0W6XAU+aMw2ykilisStJfDnsejDCXRchCcMJ4O0+8DhPXf2YUbZ6wjBlsEmZwLK/sPweWtu8hcJYQ==",
       "dev": true,
       "dependencies": {
+        "@babel/helper-string-parser": "^7.18.10",
         "@babel/helper-validator-identifier": "^7.18.6",
         "to-fast-properties": "^2.0.0"
       },
@@ -1067,9 +1088,9 @@
       }
     },
     "node_modules/@jridgewell/resolve-uri": {
-      "version": "3.0.8",
-      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.0.8.tgz",
-      "integrity": "sha512-YK5G9LaddzGbcucK4c8h5tWFmMPBvRZ/uyWmN1/SbBdIvqGUdWGkJ5BAaccgs6XbzVLsqbPJrBSFwKv3kT9i7w==",
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz",
+      "integrity": "sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==",
       "dev": true,
       "engines": {
         "node": ">=6.0.0"
@@ -1115,9 +1136,9 @@
       "dev": true
     },
     "node_modules/@jridgewell/trace-mapping": {
-      "version": "0.3.14",
-      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.14.tgz",
-      "integrity": "sha512-bJWEfQ9lPTvm3SneWwRFVLzrh6nhjwqw7TUFFBEMzwvg7t7PCDenf2lDwqo4NQXzdpgBXyFgDWnQA+2vkruksQ==",
+      "version": "0.3.15",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.15.tgz",
+      "integrity": "sha512-oWZNOULl+UbhsgB51uuZzglikfIKSUBO/M9W2OfEjn7cmqoAiCgmv9lyACTUacZwBz0ITnJ2NqjU8Tx0DHL88g==",
       "dev": true,
       "dependencies": {
         "@jridgewell/resolve-uri": "^3.0.3",
@@ -1203,9 +1224,9 @@
       }
     },
     "node_modules/@rollup/plugin-commonjs": {
-      "version": "22.0.1",
-      "resolved": "https://registry.npmjs.org/@rollup/plugin-commonjs/-/plugin-commonjs-22.0.1.tgz",
-      "integrity": "sha512-dGfEZvdjDHObBiP5IvwTKMVeq/tBZGMBHZFMdIV1ClMM/YoWS34xrHFGfag9SN2ZtMgNZRFruqvxZQEa70O6nQ==",
+      "version": "22.0.2",
+      "resolved": "https://registry.npmjs.org/@rollup/plugin-commonjs/-/plugin-commonjs-22.0.2.tgz",
+      "integrity": "sha512-//NdP6iIwPbMTcazYsiBMbJW7gfmpHom33u1beiIoHDEM0Q9clvtQB1T0efvMqHeKsGohiHo97BCPCkBXdscwg==",
       "dev": true,
       "dependencies": {
         "@rollup/pluginutils": "^3.1.0",
@@ -1339,9 +1360,9 @@
       }
     },
     "node_modules/@types/babel__traverse": {
-      "version": "7.17.1",
-      "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.17.1.tgz",
-      "integrity": "sha512-kVzjari1s2YVi77D3w1yuvohV2idweYXMCDzqBiVNN63TcDWrIlTVOYpqVrvbbyOE/IyzBoTKF0fdnLPEORFxA==",
+      "version": "7.18.1",
+      "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.18.1.tgz",
+      "integrity": "sha512-FSdLaZh2UxaMuLp9lixWaHq/golWTRWOnRsAXzDTDSDOQLuZb1nsdCt6pJSPWSEQt2eFZ2YVk3oYhn+1kLMeMA==",
       "dev": true,
       "dependencies": {
         "@babel/types": "^7.3.0"
@@ -1403,9 +1424,9 @@
       "dev": true
     },
     "node_modules/@types/node": {
-      "version": "18.0.1",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.0.1.tgz",
-      "integrity": "sha512-CmR8+Tsy95hhwtZBKJBs0/FFq4XX7sDZHlGGf+0q+BRZfMbOTkzkj0AFAuTyXbObDIoanaBBW0+KEW+m3N16Wg==",
+      "version": "18.7.14",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.7.14.tgz",
+      "integrity": "sha512-6bbDaETVi8oyIARulOE9qF1/Qdi/23z6emrUh0fNJRUmjznqrixD4MpGDdgOFk5Xb0m2H6Xu42JGdvAxaJR/wA==",
       "dev": true
     },
     "node_modules/@types/normalize-package-data": {
@@ -1415,9 +1436,9 @@
       "dev": true
     },
     "node_modules/@types/prettier": {
-      "version": "2.6.3",
-      "resolved": "https://registry.npmjs.org/@types/prettier/-/prettier-2.6.3.tgz",
-      "integrity": "sha512-ymZk3LEC/fsut+/Q5qejp6R9O1rMxz3XaRHDV6kX8MrGAhOSPqVARbDi+EZvInBpw+BnCX3TD240byVkOfQsHg==",
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/@types/prettier/-/prettier-2.7.0.tgz",
+      "integrity": "sha512-RI1L7N4JnW5gQw2spvL7Sllfuf1SaHdrZpCHiBlCXjIlufi1SMNnbu2teze3/QE67Fg2tBlH7W+mi4hVNk4p0A==",
       "dev": true
     },
     "node_modules/@types/resolve": {
@@ -1451,14 +1472,14 @@
       "dev": true
     },
     "node_modules/@typescript-eslint/eslint-plugin": {
-      "version": "5.30.4",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.30.4.tgz",
-      "integrity": "sha512-xjujQISAIa4HAaos8fcMZXmqkuZqMx6icdxkI88jMM/eNe4J8AuTLYnLK+zdm0mBYLyctdFf//UE4/xFCcQzYQ==",
+      "version": "5.36.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.36.1.tgz",
+      "integrity": "sha512-iC40UK8q1tMepSDwiLbTbMXKDxzNy+4TfPWgIL661Ym0sD42vRcQU93IsZIrmi+x292DBr60UI/gSwfdVYexCA==",
       "dev": true,
       "dependencies": {
-        "@typescript-eslint/scope-manager": "5.30.4",
-        "@typescript-eslint/type-utils": "5.30.4",
-        "@typescript-eslint/utils": "5.30.4",
+        "@typescript-eslint/scope-manager": "5.36.1",
+        "@typescript-eslint/type-utils": "5.36.1",
+        "@typescript-eslint/utils": "5.36.1",
         "debug": "^4.3.4",
         "functional-red-black-tree": "^1.0.1",
         "ignore": "^5.2.0",
@@ -1499,14 +1520,14 @@
       }
     },
     "node_modules/@typescript-eslint/parser": {
-      "version": "5.30.4",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.30.4.tgz",
-      "integrity": "sha512-/ge1HtU63wVoED4VnlU2o+FPFmi017bPYpeSrCmd8Ycsti4VSxXrmcpXXm7JpI4GT0Aa7qviabv1PEp6L5bboQ==",
+      "version": "5.36.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.36.1.tgz",
+      "integrity": "sha512-/IsgNGOkBi7CuDfUbwt1eOqUXF9WGVBW9dwEe1pi+L32XrTsZIgmDFIi2RxjzsvB/8i+MIf5JIoTEH8LOZ368A==",
       "dev": true,
       "dependencies": {
-        "@typescript-eslint/scope-manager": "5.30.4",
-        "@typescript-eslint/types": "5.30.4",
-        "@typescript-eslint/typescript-estree": "5.30.4",
+        "@typescript-eslint/scope-manager": "5.36.1",
+        "@typescript-eslint/types": "5.36.1",
+        "@typescript-eslint/typescript-estree": "5.36.1",
         "debug": "^4.3.4"
       },
       "engines": {
@@ -1526,13 +1547,13 @@
       }
     },
     "node_modules/@typescript-eslint/scope-manager": {
-      "version": "5.30.4",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.30.4.tgz",
-      "integrity": "sha512-DNzlQwGSiGefz71JwaHrpcaAX3zYkEcy8uVuan3YMKOa6qeW/y+7SaD8KIsIAruASwq6P+U4BjWBWtM2O+mwBQ==",
+      "version": "5.36.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.36.1.tgz",
+      "integrity": "sha512-pGC2SH3/tXdu9IH3ItoqciD3f3RRGCh7hb9zPdN2Drsr341zgd6VbhP5OHQO/reUqihNltfPpMpTNihFMarP2w==",
       "dev": true,
       "dependencies": {
-        "@typescript-eslint/types": "5.30.4",
-        "@typescript-eslint/visitor-keys": "5.30.4"
+        "@typescript-eslint/types": "5.36.1",
+        "@typescript-eslint/visitor-keys": "5.36.1"
       },
       "engines": {
         "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
@@ -1543,12 +1564,13 @@
       }
     },
     "node_modules/@typescript-eslint/type-utils": {
-      "version": "5.30.4",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-5.30.4.tgz",
-      "integrity": "sha512-55cf1dZviwwv+unDB+mF8vZkfta5muTK6bppPvenWWCD7slZZ0DEsXUjZerqy7Rq8s3J4SXdg4rMIY8ngCtTmA==",
+      "version": "5.36.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-5.36.1.tgz",
+      "integrity": "sha512-xfZhfmoQT6m3lmlqDvDzv9TiCYdw22cdj06xY0obSznBsT///GK5IEZQdGliXpAOaRL34o8phEvXzEo/VJx13Q==",
       "dev": true,
       "dependencies": {
-        "@typescript-eslint/utils": "5.30.4",
+        "@typescript-eslint/typescript-estree": "5.36.1",
+        "@typescript-eslint/utils": "5.36.1",
         "debug": "^4.3.4",
         "tsutils": "^3.21.0"
       },
@@ -1569,9 +1591,9 @@
       }
     },
     "node_modules/@typescript-eslint/types": {
-      "version": "5.30.4",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.30.4.tgz",
-      "integrity": "sha512-NTEvqc+Vvu8Q6JeAKryHk2eqLKqsr2St3xhIjhOjQv5wQUBhaTuix4WOSacqj0ONWfKVU12Eug3LEAB95GBkMA==",
+      "version": "5.36.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.36.1.tgz",
+      "integrity": "sha512-jd93ShpsIk1KgBTx9E+hCSEuLCUFwi9V/urhjOWnOaksGZFbTOxAT47OH2d4NLJnLhkVD+wDbB48BuaycZPLBg==",
       "dev": true,
       "engines": {
         "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
@@ -1582,13 +1604,13 @@
       }
     },
     "node_modules/@typescript-eslint/typescript-estree": {
-      "version": "5.30.4",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-5.30.4.tgz",
-      "integrity": "sha512-V4VnEs6/J9/nNizaA12IeU4SAeEYaiKr7XndLNfV5+3zZSB4hIu6EhHJixTKhvIqA+EEHgBl6re8pivBMLLO1w==",
+      "version": "5.36.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-5.36.1.tgz",
+      "integrity": "sha512-ih7V52zvHdiX6WcPjsOdmADhYMDN15SylWRZrT2OMy80wzKbc79n8wFW0xpWpU0x3VpBz/oDgTm2xwDAnFTl+g==",
       "dev": true,
       "dependencies": {
-        "@typescript-eslint/types": "5.30.4",
-        "@typescript-eslint/visitor-keys": "5.30.4",
+        "@typescript-eslint/types": "5.36.1",
+        "@typescript-eslint/visitor-keys": "5.36.1",
         "debug": "^4.3.4",
         "globby": "^11.1.0",
         "is-glob": "^4.0.3",
@@ -1624,15 +1646,15 @@
       }
     },
     "node_modules/@typescript-eslint/utils": {
-      "version": "5.30.4",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-5.30.4.tgz",
-      "integrity": "sha512-a+GQrJzOUhn4WT1mUumXDyam+22Oo4c5K/jnZ+6r/4WTQF3q8e4CsC9PLHb4SnOClzOqo/5GLZWvkE1aa5UGKQ==",
+      "version": "5.36.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-5.36.1.tgz",
+      "integrity": "sha512-lNj4FtTiXm5c+u0pUehozaUWhh7UYKnwryku0nxJlYUEWetyG92uw2pr+2Iy4M/u0ONMKzfrx7AsGBTCzORmIg==",
       "dev": true,
       "dependencies": {
         "@types/json-schema": "^7.0.9",
-        "@typescript-eslint/scope-manager": "5.30.4",
-        "@typescript-eslint/types": "5.30.4",
-        "@typescript-eslint/typescript-estree": "5.30.4",
+        "@typescript-eslint/scope-manager": "5.36.1",
+        "@typescript-eslint/types": "5.36.1",
+        "@typescript-eslint/typescript-estree": "5.36.1",
         "eslint-scope": "^5.1.1",
         "eslint-utils": "^3.0.0"
       },
@@ -1648,12 +1670,12 @@
       }
     },
     "node_modules/@typescript-eslint/visitor-keys": {
-      "version": "5.30.4",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.30.4.tgz",
-      "integrity": "sha512-ulKGse3mruSc8x6l8ORSc6+1ORyJzKmZeIaRTu/WpaF/jx3vHvEn5XZUKF9XaVg2710mFmTAUlLcLYLPp/Zf/Q==",
+      "version": "5.36.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.36.1.tgz",
+      "integrity": "sha512-ojB9aRyRFzVMN3b5joSYni6FAS10BBSCAfKJhjJAV08t/a95aM6tAhz+O1jF+EtgxktuSO3wJysp2R+Def/IWQ==",
       "dev": true,
       "dependencies": {
-        "@typescript-eslint/types": "5.30.4",
+        "@typescript-eslint/types": "5.36.1",
         "eslint-visitor-keys": "^3.3.0"
       },
       "engines": {
@@ -1664,15 +1686,6 @@
         "url": "https://opencollective.com/typescript-eslint"
       }
     },
-    "node_modules/@typescript-eslint/visitor-keys/node_modules/eslint-visitor-keys": {
-      "version": "3.3.0",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.3.0.tgz",
-      "integrity": "sha512-mQ+suqKJVyeuwGYHAdjMFqjCyfl8+Ldnxuyp3ldiMBFKkvytrXUZWaiPCEav8qDHKty44bD+qV1IP4T+w+xXRA==",
-      "dev": true,
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      }
-    },
     "node_modules/abab": {
       "version": "2.0.6",
       "resolved": "https://registry.npmjs.org/abab/-/abab-2.0.6.tgz",
@@ -2038,7 +2051,28 @@
     "node_modules/balanced-match": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
-      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true
+    },
+    "node_modules/base64-js": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
+      "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ]
     },
     "node_modules/bcrypt-pbkdf": {
       "version": "1.0.2",
@@ -2135,9 +2169,9 @@
       "dev": true
     },
     "node_modules/browserslist": {
-      "version": "4.21.1",
-      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.21.1.tgz",
-      "integrity": "sha512-Nq8MFCSrnJXSc88yliwlzQe3qNe3VntIjhsArW9IJOEPSHNx23FalwApUVbzAWABLhYJJ7y8AynWI/XM8OdfjQ==",
+      "version": "4.21.3",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.21.3.tgz",
+      "integrity": "sha512-898rgRXLAyRkM1GryrrBHGkqA5hlpkV5MhtZwg9QXeiyLUYs2k00Un05aX5l2/yJIOObYKOpS2JNo8nJDE7fWQ==",
       "dev": true,
       "funding": [
         {
@@ -2150,10 +2184,10 @@
         }
       ],
       "dependencies": {
-        "caniuse-lite": "^1.0.30001359",
-        "electron-to-chromium": "^1.4.172",
-        "node-releases": "^2.0.5",
-        "update-browserslist-db": "^1.0.4"
+        "caniuse-lite": "^1.0.30001370",
+        "electron-to-chromium": "^1.4.202",
+        "node-releases": "^2.0.6",
+        "update-browserslist-db": "^1.0.5"
       },
       "bin": {
         "browserslist": "cli.js"
@@ -2183,6 +2217,30 @@
         "node-int64": "^0.4.0"
       }
     },
+    "node_modules/buffer": {
+      "version": "5.7.1",
+      "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz",
+      "integrity": "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "dependencies": {
+        "base64-js": "^1.3.1",
+        "ieee754": "^1.1.13"
+      }
+    },
     "node_modules/buffer-from": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
@@ -2233,9 +2291,9 @@
       }
     },
     "node_modules/caniuse-lite": {
-      "version": "1.0.30001362",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001362.tgz",
-      "integrity": "sha512-PFykHuC7BQTzCGQFaV6wD8IDRM3HpI83BXr99nNJhoOyDufgSuKlt0QVlWYt5ZJtEYFeuNVF5QY3kJcu8hVFjQ==",
+      "version": "1.0.30001387",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001387.tgz",
+      "integrity": "sha512-fKDH0F1KOJvR+mWSOvhj8lVRr/Q/mc5u5nabU2vi1/sgvlSqEsE8dOq0Hy/BqVbDkCYQPRRHB1WRjW6PGB/7PA==",
       "dev": true,
       "funding": [
         {
@@ -2450,9 +2508,9 @@
       }
     },
     "node_modules/commander": {
-      "version": "9.3.0",
-      "resolved": "https://registry.npmjs.org/commander/-/commander-9.3.0.tgz",
-      "integrity": "sha512-hv95iU5uXPbK83mjrJKuZyFM/LBAoCV/XhVGkS5Je6tl7sxr6A0ITMw5WoRV46/UaJ46Nllm3Xt7IaJhXTIkzw==",
+      "version": "9.4.0",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-9.4.0.tgz",
+      "integrity": "sha512-sRPT+umqkz90UA8M1yqYfnHlZA7fF6nSphDtxeywPZ49ysjxDQybzk13CL+mXekDRG92skbcqCLVovuCusNmFw==",
       "engines": {
         "node": "^12.20.0 || >=14"
       }
@@ -2616,9 +2674,9 @@
       }
     },
     "node_modules/decimal.js": {
-      "version": "10.3.1",
-      "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.3.1.tgz",
-      "integrity": "sha512-V0pfhfr8suzyPGOx3nmq4aHqabehUZn6Ch9kyFpV79TGDTWFmHqUqXdabR7QHqxzrYolF4+tVmJhUG4OURg5dQ==",
+      "version": "10.4.0",
+      "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.4.0.tgz",
+      "integrity": "sha512-Nv6ENEzyPQ6AItkGwLE2PGKinZZ9g59vSh2BeH6NqPu0OTKZ5ruJsVqh/orbAnqXc9pBbgXAIrc2EyaCj8NpGg==",
       "dev": true
     },
     "node_modules/dedent": {
@@ -2741,9 +2799,9 @@
       }
     },
     "node_modules/electron-to-chromium": {
-      "version": "1.4.177",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.177.tgz",
-      "integrity": "sha512-FYPir3NSBEGexSZUEeht81oVhHfLFl6mhUKSkjHN/iB/TwEIt/WHQrqVGfTLN5gQxwJCQkIJBe05eOXjI7omgg==",
+      "version": "1.4.240",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.240.tgz",
+      "integrity": "sha512-r20dUOtZ4vUPTqAajDGonIM1uas5tf85Up+wPdtNBNvBSqGCfkpvMVvQ1T8YJzPV9/Y9g3FbUDcXb94Rafycow==",
       "dev": true
     },
     "node_modules/emittery": {
@@ -2786,16 +2844,16 @@
       }
     },
     "node_modules/es-abstract": {
-      "version": "1.20.1",
-      "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.20.1.tgz",
-      "integrity": "sha512-WEm2oBhfoI2sImeM4OF2zE2V3BYdSF+KnSi9Sidz51fQHd7+JuF8Xgcj9/0o+OWeIeIS/MiuNnlruQrJf16GQA==",
+      "version": "1.20.2",
+      "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.20.2.tgz",
+      "integrity": "sha512-XxXQuVNrySBNlEkTYJoDNFe5+s2yIOpzq80sUHEdPdQr0S5nTLz4ZPPPswNIpKseDDUS5yghX1gfLIHQZ1iNuQ==",
       "dev": true,
       "dependencies": {
         "call-bind": "^1.0.2",
         "es-to-primitive": "^1.2.1",
         "function-bind": "^1.1.1",
         "function.prototype.name": "^1.1.5",
-        "get-intrinsic": "^1.1.1",
+        "get-intrinsic": "^1.1.2",
         "get-symbol-description": "^1.0.0",
         "has": "^1.0.3",
         "has-property-descriptors": "^1.0.0",
@@ -2807,9 +2865,9 @@
         "is-shared-array-buffer": "^1.0.2",
         "is-string": "^1.0.7",
         "is-weakref": "^1.0.2",
-        "object-inspect": "^1.12.0",
+        "object-inspect": "^1.12.2",
         "object-keys": "^1.1.1",
-        "object.assign": "^4.1.2",
+        "object.assign": "^4.1.4",
         "regexp.prototype.flags": "^1.4.3",
         "string.prototype.trimend": "^1.0.5",
         "string.prototype.trimstart": "^1.0.5",
@@ -2849,9 +2907,9 @@
       }
     },
     "node_modules/es5-ext": {
-      "version": "0.10.61",
-      "resolved": "https://registry.npmjs.org/es5-ext/-/es5-ext-0.10.61.tgz",
-      "integrity": "sha512-yFhIqQAzu2Ca2I4SE2Au3rxVfmohU9Y7wqGR+s7+H7krk26NXhIRAZDgqd6xqjCEFUomDEA3/Bo/7fKmIkW1kA==",
+      "version": "0.10.62",
+      "resolved": "https://registry.npmjs.org/es5-ext/-/es5-ext-0.10.62.tgz",
+      "integrity": "sha512-BHLqn0klhEpnOKSrzn/Xsz2UIW8j+cGmo9JLzr8BiUapV8hPL9+FliFqjwr9ngW7jWdnxv6eO+/LqyhJVqgrjA==",
       "dev": true,
       "hasInstallScript": true,
       "dependencies": {
@@ -3100,9 +3158,9 @@
       }
     },
     "node_modules/eslint-plugin-react": {
-      "version": "7.30.1",
-      "resolved": "https://registry.npmjs.org/eslint-plugin-react/-/eslint-plugin-react-7.30.1.tgz",
-      "integrity": "sha512-NbEvI9jtqO46yJA3wcRF9Mo0lF9T/jhdHqhCHXiXtD+Zcb98812wvokjWpU7Q4QH5edo6dmqrukxVvWWXHlsUg==",
+      "version": "7.31.1",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-react/-/eslint-plugin-react-7.31.1.tgz",
+      "integrity": "sha512-j4/2xWqt/R7AZzG8CakGHA6Xa/u7iR8Q3xCxY+AUghdT92bnIDOBEefV456OeH0QvBcroVc0eyvrrLSyQGYIfg==",
       "dev": true,
       "dependencies": {
         "array-includes": "^3.1.5",
@@ -3250,6 +3308,15 @@
         "eslint": ">=7.0.0"
       }
     },
+    "node_modules/eslint-template-visitor/node_modules/eslint-visitor-keys": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz",
+      "integrity": "sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==",
+      "dev": true,
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/eslint-utils": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/eslint-utils/-/eslint-utils-3.0.0.tgz",
@@ -3268,7 +3335,7 @@
         "eslint": ">=5"
       }
     },
-    "node_modules/eslint-visitor-keys": {
+    "node_modules/eslint-utils/node_modules/eslint-visitor-keys": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz",
       "integrity": "sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==",
@@ -3277,6 +3344,15 @@
         "node": ">=10"
       }
     },
+    "node_modules/eslint-visitor-keys": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.3.0.tgz",
+      "integrity": "sha512-mQ+suqKJVyeuwGYHAdjMFqjCyfl8+Ldnxuyp3ldiMBFKkvytrXUZWaiPCEav8qDHKty44bD+qV1IP4T+w+xXRA==",
+      "dev": true,
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      }
+    },
     "node_modules/eslint/node_modules/eslint-utils": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/eslint-utils/-/eslint-utils-2.1.0.tgz",
@@ -3301,6 +3377,15 @@
         "node": ">=4"
       }
     },
+    "node_modules/eslint/node_modules/eslint-visitor-keys": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz",
+      "integrity": "sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==",
+      "dev": true,
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/eslint/node_modules/ignore": {
       "version": "4.0.6",
       "resolved": "https://registry.npmjs.org/ignore/-/ignore-4.0.6.tgz",
@@ -3467,18 +3552,18 @@
       }
     },
     "node_modules/ext": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/ext/-/ext-1.6.0.tgz",
-      "integrity": "sha512-sdBImtzkq2HpkdRLtlLWDa6w4DX22ijZLKx8BMPUuKe1c5lbN6xwQDQCxSfxBQnHZ13ls/FH0MQZx/q/gr6FQg==",
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/ext/-/ext-1.7.0.tgz",
+      "integrity": "sha512-6hxeJYaL110a9b5TEJSj0gojyHQAmA2ch5Os+ySCiA1QGdS697XWY1pzsrSjqA9LDEEgdB/KypIlR59RcLuHYw==",
       "dev": true,
       "dependencies": {
-        "type": "^2.5.0"
+        "type": "^2.7.2"
       }
     },
     "node_modules/ext/node_modules/type": {
-      "version": "2.6.0",
-      "resolved": "https://registry.npmjs.org/type/-/type-2.6.0.tgz",
-      "integrity": "sha512-eiDBDOmkih5pMbo9OqsqPRGMljLodLcwd5XD5JbtNB0o89xZAwynY9EdCDsJU7LtcVCClu9DvM7/0Ep1hYX3EQ==",
+      "version": "2.7.2",
+      "resolved": "https://registry.npmjs.org/type/-/type-2.7.2.tgz",
+      "integrity": "sha512-dzlvlNlt6AXU7EBSfpAscydQ7gXB+pPGsPnfJnZpiNJBDj7IaJzQlBZYGdEi4R9HmPdBv2XmWJ6YUtoTa7lmCw==",
       "dev": true
     },
     "node_modules/extend": {
@@ -3640,9 +3725,9 @@
       }
     },
     "node_modules/flatted": {
-      "version": "3.2.6",
-      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.2.6.tgz",
-      "integrity": "sha512-0sQoMh9s0BYsm+12Huy/rkKxVu4R1+r96YX5cG44rHV0pQ6iC3Q+mkoMFaGWObMFYQxCVT+ssG1ksneA2MI9KQ==",
+      "version": "3.2.7",
+      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.2.7.tgz",
+      "integrity": "sha512-5nqDSxl8nn5BSNxyR3n4I6eDmbolI6WT+QqR547RwxQapgjQBmtktdP+HTBb/a/zLsbzERTONyUB5pefh5TtjQ==",
       "dev": true
     },
     "node_modules/forever-agent": {
@@ -3685,7 +3770,8 @@
     "node_modules/fs.realpath": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
-      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw=="
+      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
+      "dev": true
     },
     "node_modules/fsevents": {
       "version": "2.3.2",
@@ -3851,9 +3937,9 @@
       }
     },
     "node_modules/globals": {
-      "version": "13.15.0",
-      "resolved": "https://registry.npmjs.org/globals/-/globals-13.15.0.tgz",
-      "integrity": "sha512-bpzcOlgDhMG070Av0Vy5Owklpv1I6+j96GhUI7Rh7IzDCKLzboflLrrfqMu8NquDbiR4EOQk7XzJwqVJxicxog==",
+      "version": "13.17.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-13.17.0.tgz",
+      "integrity": "sha512-1C+6nQRb1GwGMKm2dH/E7enFAMxGTmGI7/dEdhy/DNelv85w9B72t3uc5frtMNXIbzrarJJ/lTCjcaZwbLJmyw==",
       "dev": true,
       "dependencies": {
         "type-fest": "^0.20.2"
@@ -4070,6 +4156,26 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/ieee754": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
+      "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ]
+    },
     "node_modules/ignore": {
       "version": "5.2.0",
       "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.2.0.tgz",
@@ -4136,6 +4242,7 @@
       "version": "1.0.6",
       "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
       "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
+      "dev": true,
       "dependencies": {
         "once": "^1.3.0",
         "wrappy": "1"
@@ -4144,7 +4251,8 @@
     "node_modules/inherits": {
       "version": "2.0.4",
       "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
-      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "dev": true
     },
     "node_modules/internal-slot": {
       "version": "1.0.3",
@@ -4195,15 +4303,18 @@
       }
     },
     "node_modules/is-builtin-module": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/is-builtin-module/-/is-builtin-module-3.1.0.tgz",
-      "integrity": "sha512-OV7JjAgOTfAFJmHZLvpSTb4qi0nIILDV1gWPYDnDJUTNFM5aGlRAhk4QcT8i7TuAleeEV5Fdkqn3t4mS+Q11fg==",
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/is-builtin-module/-/is-builtin-module-3.2.0.tgz",
+      "integrity": "sha512-phDA4oSGt7vl1n5tJvTWooWWAsXLY+2xCnxNqvKhGEzujg+A43wPlPOyDg3C8XQHN+6k/JTQWJ/j0dQh/qr+Hw==",
       "dev": true,
       "dependencies": {
-        "builtin-modules": "^3.0.0"
+        "builtin-modules": "^3.3.0"
       },
       "engines": {
         "node": ">=6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/is-callable": {
@@ -4219,9 +4330,9 @@
       }
     },
     "node_modules/is-core-module": {
-      "version": "2.9.0",
-      "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.9.0.tgz",
-      "integrity": "sha512-+5FPy5PnwmO3lvfMb0AsoPaBG+5KHUI0wYFXOtYPnVVVspTFUuMZNfNaNVRt3FZadstu2c8x23vykRW/NBoU6A==",
+      "version": "2.10.0",
+      "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.10.0.tgz",
+      "integrity": "sha512-Erxj2n/LDAZ7H8WNJXd9tw38GYM3dv8rk8Zcs+jJuxYTW7sozH+SS8NtrSjVL1/vpLvWi1hxy96IzjJ3EHTJJg==",
       "dev": true,
       "dependencies": {
         "has": "^1.0.3"
@@ -4510,9 +4621,9 @@
       }
     },
     "node_modules/istanbul-reports": {
-      "version": "3.1.4",
-      "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.1.4.tgz",
-      "integrity": "sha512-r1/DshN4KSE7xWEknZLLLLDn5CJybV3nw01VTkp6D5jzLuELlcbudfj/eSQFvrKsJuTVCGnePO7ho82Nw9zzfw==",
+      "version": "3.1.5",
+      "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.1.5.tgz",
+      "integrity": "sha512-nUsEMa9pBt/NOHqbcbeJEgqIlY/K7rVWUX6Lql2orY5e9roQOthbR3vtY4zzf2orPELg80fnxxk9zUyPlgwD1w==",
       "dev": true,
       "dependencies": {
         "html-escaper": "^2.0.0",
@@ -5246,9 +5357,9 @@
       }
     },
     "node_modules/jsdom/node_modules/acorn": {
-      "version": "8.7.1",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.7.1.tgz",
-      "integrity": "sha512-Xx54uLJQZ19lKygFXOWsscKUbsBZW0CPykPhVQdhIeIwrbPmJzqeASDInc8nKBnp/JT6igTs82qPXz069H8I/A==",
+      "version": "8.8.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.8.0.tgz",
+      "integrity": "sha512-QOxyigPVrpZ2GXT+PFyZTl6TtOFc5egxHIP9IlQ+RbupQuX4RkT/Bee4/kQuC02Xkzg84JcT7oLYtDIQxp+v7w==",
       "dev": true,
       "bin": {
         "acorn": "bin/acorn"
@@ -5339,9 +5450,10 @@
       }
     },
     "node_modules/jsonc-parser": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-3.0.0.tgz",
-      "integrity": "sha512-fQzRfAbIBnR0IQvftw9FJveWiHp72Fg20giDrHz6TdfB12UH/uue0D3hm57UB5KgAVuniLMCaS8P1IMj9NR7cA=="
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-3.2.0.tgz",
+      "integrity": "sha512-gfFQZrcTc8CnKXp6Y4/CBT3fTc0OVuDofpre4aEeEpSBPV5X5v4+Vmx+8snU7RLPrNHPKSgLxGo9YuQzz20o+w==",
+      "dev": true
     },
     "node_modules/jsonfile": {
       "version": "6.1.0",
@@ -5380,13 +5492,13 @@
       }
     },
     "node_modules/jsx-ast-utils": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/jsx-ast-utils/-/jsx-ast-utils-3.3.1.tgz",
-      "integrity": "sha512-pxrjmNpeRw5wwVeWyEAk7QJu2GnBO3uzPFmHCKJJFPKK2Cy0cWL23krGtLdnMmbIi6/FjlrQpPyfQI19ByPOhQ==",
+      "version": "3.3.3",
+      "resolved": "https://registry.npmjs.org/jsx-ast-utils/-/jsx-ast-utils-3.3.3.tgz",
+      "integrity": "sha512-fYQHZTZ8jSfmWZ0iyzfwiU4WDX4HpHbMCZ3gPlWYiCl3BoeOTsqKBqnTVfH2rYT7eP5c3sVbeSPHnnJOaTrWiw==",
       "dev": true,
       "dependencies": {
         "array-includes": "^3.1.5",
-        "object.assign": "^4.1.2"
+        "object.assign": "^4.1.3"
       },
       "engines": {
         "node": ">=4.0"
@@ -5548,7 +5660,8 @@
     "node_modules/lunr": {
       "version": "2.3.9",
       "resolved": "https://registry.npmjs.org/lunr/-/lunr-2.3.9.tgz",
-      "integrity": "sha512-zTU3DaZaF3Rt9rhN3uBMGQD3dD2/vFQqnvZCDv4dl5iOzq2IZQqTxu90r4E5J+nP70J3ilqVCrbho2eWaeW8Ow=="
+      "integrity": "sha512-zTU3DaZaF3Rt9rhN3uBMGQD3dD2/vFQqnvZCDv4dl5iOzq2IZQqTxu90r4E5J+nP70J3ilqVCrbho2eWaeW8Ow==",
+      "dev": true
     },
     "node_modules/magic-string": {
       "version": "0.25.9",
@@ -5599,9 +5712,10 @@
       }
     },
     "node_modules/marked": {
-      "version": "4.0.17",
-      "resolved": "https://registry.npmjs.org/marked/-/marked-4.0.17.tgz",
-      "integrity": "sha512-Wfk0ATOK5iPxM4ptrORkFemqroz0ZDxp5MWfYA7H/F+wO17NRWV5Ypxi6p3g2Xmw2bKeiYOl6oVnLHKxBA0VhA==",
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/marked/-/marked-4.1.0.tgz",
+      "integrity": "sha512-+Z6KDjSPa6/723PQYyc1axYZpYYpDnECDaU6hkaf5gqBieBkMKYReL5hteF2QizhlMbgbo8umXl/clZ67+GlsA==",
+      "dev": true,
       "bin": {
         "marked": "bin/marked.js"
       },
@@ -5753,9 +5867,9 @@
       "dev": true
     },
     "node_modules/node-releases": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.5.tgz",
-      "integrity": "sha512-U9h1NLROZTq9uE1SNffn6WuPDg8icmi3ns4rEl/oTfIle4iLjTliCzgTsbaIFMq/Xn078/lfY/BL0GWZ+psK4Q==",
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.6.tgz",
+      "integrity": "sha512-PiVXnNuFm5+iYkLBNeq5211hvO38y63T0i2KKh2KnUs3RpzJ+JtODFjkD8yjLwnDkTYF1eKXheUwdssR+NRZdg==",
       "dev": true
     },
     "node_modules/normalize-package-data": {
@@ -5797,6 +5911,12 @@
       "integrity": "sha512-JYOWTeFoS0Z93587vRJgASD5Ut11fYl5NyihP3KrYBvMe1FRRs6RN7m20SA/16GM4P6hTnZjT+UmDOt38UeXNg==",
       "dev": true
     },
+    "node_modules/oauth": {
+      "version": "0.9.15",
+      "resolved": "https://registry.npmjs.org/oauth/-/oauth-0.9.15.tgz",
+      "integrity": "sha512-a5ERWK1kh38ExDEfoO6qUHJb32rd7aYmPHuyCu3Fta/cnICvYmgd2uhuKXvPD+PXB+gCEYYEaQdIRAjCOwAKNA==",
+      "dev": true
+    },
     "node_modules/oauth-sign": {
       "version": "0.9.0",
       "resolved": "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.9.0.tgz",
@@ -5833,15 +5953,24 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/object-sizeof": {
+      "version": "1.6.3",
+      "resolved": "https://registry.npmjs.org/object-sizeof/-/object-sizeof-1.6.3.tgz",
+      "integrity": "sha512-LGtilAKuDGKCcvu1Xg3UvAhAeJJlFmblo3faltmOQ80xrGwAHxnauIXucalKdTEksHp/Pq9tZGz1hfyEmjFJPQ==",
+      "dev": true,
+      "dependencies": {
+        "buffer": "^5.6.0"
+      }
+    },
     "node_modules/object.assign": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.2.tgz",
-      "integrity": "sha512-ixT2L5THXsApyiUPYKmW+2EHpXXe5Ii3M+f4e+aJFAHao5amFRW6J0OO6c/LU8Be47utCx2GL89hxGB6XSmKuQ==",
+      "version": "4.1.4",
+      "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.4.tgz",
+      "integrity": "sha512-1mxKf0e58bvyjSCtKYY4sRe9itRk3PJpquJOjeIkz885CczcI4IvJJDLPS72oowuSh+pBxUFROpX+TU++hxhZQ==",
       "dev": true,
       "dependencies": {
-        "call-bind": "^1.0.0",
-        "define-properties": "^1.1.3",
-        "has-symbols": "^1.0.1",
+        "call-bind": "^1.0.2",
+        "define-properties": "^1.1.4",
+        "has-symbols": "^1.0.3",
         "object-keys": "^1.1.1"
       },
       "engines": {
@@ -5916,6 +6045,7 @@
       "version": "1.4.0",
       "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
       "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+      "dev": true,
       "dependencies": {
         "wrappy": "1"
       }
@@ -6280,9 +6410,9 @@
       "dev": true
     },
     "node_modules/psl": {
-      "version": "1.8.0",
-      "resolved": "https://registry.npmjs.org/psl/-/psl-1.8.0.tgz",
-      "integrity": "sha512-RIdOzyoavK+hA18OGGWDqUTsCLhtA7IcZ/6NCs4fFJaHBDab+pDDmDIByWFRQJq2Cd7r1OoQxBGKOaztq+hjIQ==",
+      "version": "1.9.0",
+      "resolved": "https://registry.npmjs.org/psl/-/psl-1.9.0.tgz",
+      "integrity": "sha512-E/ZsdU4HLs/68gYzgGTkMicWTLPdAftJLfJFlLUAAKZGkStNU72sZjT66SnMDVOfOWY/YAoiD7Jxa9iHvngcag==",
       "dev": true
     },
     "node_modules/punycode": {
@@ -6313,6 +6443,12 @@
         "node": ">=0.6"
       }
     },
+    "node_modules/querystringify": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/querystringify/-/querystringify-2.2.0.tgz",
+      "integrity": "sha512-FIqgj2EUvTa7R50u0rGsyTftzjYmv/a3hO345bZNrqabNqjtgiDMgmo4mkUjd+nzU5oF3dClKqFIPUKybUyqoQ==",
+      "dev": true
+    },
     "node_modules/queue-microtask": {
       "version": "1.2.3",
       "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
@@ -6390,9 +6526,9 @@
       }
     },
     "node_modules/reduce-to-639-1": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/reduce-to-639-1/-/reduce-to-639-1-1.0.4.tgz",
-      "integrity": "sha512-cJjvufESvm1bzAvlLYsNPBz/ukcE5ydvrd4L17W3fcJUzveX7HzUwiM8ce33Ae8zsZVjj7ErUIw2oAAnvQJzZw=="
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/reduce-to-639-1/-/reduce-to-639-1-1.1.0.tgz",
+      "integrity": "sha512-9yy/xgTE8qPlZKQrQmyCU1Y1ZSnnOCP4K0Oe1YrBtteUmVXk0AgyINp0NS5kHGzZfpvjgHr6ygFZc9fpqf7moQ=="
     },
     "node_modules/regexp-tree": {
       "version": "0.1.24",
@@ -6518,6 +6654,12 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/requires-port": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/requires-port/-/requires-port-1.0.0.tgz",
+      "integrity": "sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==",
+      "dev": true
+    },
     "node_modules/resolve": {
       "version": "1.22.1",
       "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.1.tgz",
@@ -6613,9 +6755,9 @@
       }
     },
     "node_modules/rollup": {
-      "version": "2.75.7",
-      "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.75.7.tgz",
-      "integrity": "sha512-VSE1iy0eaAYNCxEXaleThdFXqZJ42qDBatAwrfnPlENEZ8erQ+0LYX4JXOLPceWfZpV1VtZwZ3dFCuOZiSyFtQ==",
+      "version": "2.79.0",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.79.0.tgz",
+      "integrity": "sha512-x4KsrCgwQ7ZJPcFA/SUu6QVcYlO7uRLfLAy0DSA4NS2eG8japdbpM50ToH7z4iObodRYOJ0soneF0iaQRJ6zhA==",
       "dev": true,
       "bin": {
         "rollup": "dist/bin/rollup"
@@ -6723,6 +6865,7 @@
       "version": "0.10.1",
       "resolved": "https://registry.npmjs.org/shiki/-/shiki-0.10.1.tgz",
       "integrity": "sha512-VsY7QJVzU51j5o1+DguUd+6vmCmZ5v/6gYu4vyYAhzjuNQU6P/vmSy4uQaOhvje031qQMiW0d2BwgMH52vqMng==",
+      "dev": true,
       "dependencies": {
         "jsonc-parser": "^3.0.0",
         "vscode-oniguruma": "^1.6.1",
@@ -6833,9 +6976,9 @@
       }
     },
     "node_modules/spdx-license-ids": {
-      "version": "3.0.11",
-      "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.11.tgz",
-      "integrity": "sha512-Ctl2BrFiM0X3MANYgj3CkygxhRmr9mi6xhejbdO960nF6EDJApTYpn0BQnDKlnNBULKiCN1n3w9EBkHK8ZWg+g==",
+      "version": "3.0.12",
+      "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.12.tgz",
+      "integrity": "sha512-rr+VVSXtRhO4OHbXUiAF7xW3Bo9DuuF6C5jH+q/x15j2jniycgKbxU09Hr0WqlSLUs4i4ltHGXqTe7VHclYWyA==",
       "dev": true
     },
     "node_modules/sprintf-js": {
@@ -7116,9 +7259,9 @@
       }
     },
     "node_modules/terser": {
-      "version": "5.14.1",
-      "resolved": "https://registry.npmjs.org/terser/-/terser-5.14.1.tgz",
-      "integrity": "sha512-+ahUAE+iheqBTDxXhTisdA8hgvbEG1hHOQ9xmNjeUJSoi6DU/gMrKNcfZjHkyY6Alnuyc+ikYJaxxfHkT3+WuQ==",
+      "version": "5.15.0",
+      "resolved": "https://registry.npmjs.org/terser/-/terser-5.15.0.tgz",
+      "integrity": "sha512-L1BJiXVmheAQQy+as0oF3Pwtlo4s3Wi1X2zNZ2NxOB4wx9bdS9Vk67XQENLFdLYGCK/Z2di53mTj/hBafR+dTA==",
       "dev": true,
       "dependencies": {
         "@jridgewell/source-map": "^0.3.2",
@@ -7134,9 +7277,9 @@
       }
     },
     "node_modules/terser/node_modules/acorn": {
-      "version": "8.7.1",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.7.1.tgz",
-      "integrity": "sha512-Xx54uLJQZ19lKygFXOWsscKUbsBZW0CPykPhVQdhIeIwrbPmJzqeASDInc8nKBnp/JT6igTs82qPXz069H8I/A==",
+      "version": "8.8.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.8.0.tgz",
+      "integrity": "sha512-QOxyigPVrpZ2GXT+PFyZTl6TtOFc5egxHIP9IlQ+RbupQuX4RkT/Bee4/kQuC02Xkzg84JcT7oLYtDIQxp+v7w==",
       "dev": true,
       "bin": {
         "acorn": "bin/acorn"
@@ -7255,23 +7398,24 @@
       }
     },
     "node_modules/tough-cookie": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-4.0.0.tgz",
-      "integrity": "sha512-tHdtEpQCMrc1YLrMaqXXcj6AxhYi/xgit6mZu1+EDWUn+qhUf8wMQoFIy9NXuq23zAwtcB0t/MjACGR18pcRbg==",
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-4.1.2.tgz",
+      "integrity": "sha512-G9fqXWoYFZgTc2z8Q5zaHy/vJMjm+WV0AkAeHxVCQiEB1b+dGvWzFW6QV07cY5jQ5gRkeid2qIkzkxUnmoQZUQ==",
       "dev": true,
       "dependencies": {
         "psl": "^1.1.33",
         "punycode": "^2.1.1",
-        "universalify": "^0.1.2"
+        "universalify": "^0.2.0",
+        "url-parse": "^1.5.3"
       },
       "engines": {
         "node": ">=6"
       }
     },
     "node_modules/tough-cookie/node_modules/universalify": {
-      "version": "0.1.2",
-      "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz",
-      "integrity": "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==",
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.2.0.tgz",
+      "integrity": "sha512-CJ1QgKmNg3CwvAv/kOFmtnEN05f0D/cn9QntgNOQlQF9dgvVTHj3t+8JPdjqawCHk7V/KA+fbUqzZ9XWhcqPUg==",
       "dev": true,
       "engines": {
         "node": ">= 4.0.0"
@@ -7386,6 +7530,16 @@
       "integrity": "sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA==",
       "dev": true
     },
+    "node_modules/twitter-api-client": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/twitter-api-client/-/twitter-api-client-1.6.1.tgz",
+      "integrity": "sha512-VkVDJzX0i6FC7CyZeeJluU1+bQ+8o5pwawgEjm7N5byaXF/cD9T4fzSzYX8y3ZhbwmkeUslYHQkquzQ2vigTmw==",
+      "dev": true,
+      "dependencies": {
+        "oauth": "^0.9.15",
+        "object-sizeof": "^1.6.1"
+      }
+    },
     "node_modules/txt_tocfill": {
       "version": "0.5.1",
       "resolved": "https://registry.npmjs.org/txt_tocfill/-/txt_tocfill-0.5.1.tgz",
@@ -7444,6 +7598,7 @@
       "version": "0.22.18",
       "resolved": "https://registry.npmjs.org/typedoc/-/typedoc-0.22.18.tgz",
       "integrity": "sha512-NK9RlLhRUGMvc6Rw5USEYgT4DVAUFk7IF7Q6MYfpJ88KnTZP7EneEa4RcP+tX1auAcz7QT1Iy0bUSZBYYHdoyA==",
+      "dev": true,
       "dependencies": {
         "glob": "^8.0.3",
         "lunr": "^2.3.9",
@@ -7465,6 +7620,7 @@
       "version": "0.23.0",
       "resolved": "https://registry.npmjs.org/typedoc-plugin-missing-exports/-/typedoc-plugin-missing-exports-0.23.0.tgz",
       "integrity": "sha512-9smahDSsFRno9ZwoEshQDuIYMHWGB1E6LUud5qMxR2wNZ0T4DlZz0QjoK3HzXtX34mUpTH0dYtt7NQUK4D6B6Q==",
+      "dev": true,
       "peerDependencies": {
         "typedoc": "0.22.x || 0.23.x"
       }
@@ -7473,6 +7629,7 @@
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
       "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
+      "dev": true,
       "dependencies": {
         "balanced-match": "^1.0.0"
       }
@@ -7481,6 +7638,7 @@
       "version": "8.0.3",
       "resolved": "https://registry.npmjs.org/glob/-/glob-8.0.3.tgz",
       "integrity": "sha512-ull455NHSHI/Y1FqGaaYFaLGkNMMJbavMrEGFXG/PGrg6y7sutWHUHrz6gy6WEBH6akM1M414dWKCNs+IhKdiQ==",
+      "dev": true,
       "dependencies": {
         "fs.realpath": "^1.0.0",
         "inflight": "^1.0.4",
@@ -7499,6 +7657,7 @@
       "version": "5.1.0",
       "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.0.tgz",
       "integrity": "sha512-9TPBGGak4nHfGZsPBohm9AWg6NoT7QTCehS3BIJABslyZbzxfV78QM2Y6+i741OPZIafFAaiiEMh5OyIrJPgtg==",
+      "dev": true,
       "dependencies": {
         "brace-expansion": "^2.0.1"
       },
@@ -7510,6 +7669,7 @@
       "version": "4.7.4",
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.7.4.tgz",
       "integrity": "sha512-C0WQT0gezHuw6AdY1M2jxUO83Rjf0HP7Sk1DtXj6j1EwkQNZrHAg2XPWlq62oqEhYvONq5pkC2Y9oPljWToLmQ==",
+      "dev": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -7549,9 +7709,9 @@
       }
     },
     "node_modules/update-browserslist-db": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.4.tgz",
-      "integrity": "sha512-jnmO2BEGUjsMOe/Fg9u0oczOe/ppIDZPebzccl1yDWGLFP16Pa1/RM5wEoKYPG2zstNcDuAStejyxsOuKINdGA==",
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.6.tgz",
+      "integrity": "sha512-We7BqM9XFlcW94Op93uW8+2LXvGezs7QA0WY+f1H7RR1q46B06W6hZF6LbmOlpCS1HU22q/6NOGTGW5sCm7NJQ==",
       "dev": true,
       "funding": [
         {
@@ -7583,6 +7743,16 @@
         "punycode": "^2.1.0"
       }
     },
+    "node_modules/url-parse": {
+      "version": "1.5.10",
+      "resolved": "https://registry.npmjs.org/url-parse/-/url-parse-1.5.10.tgz",
+      "integrity": "sha512-WypcfiRhfeUP9vvF0j6rw0J3hrWrw6iZv3+22h6iRMJ/8z1Tj6XfLP4DsUix5MhMPnXpiHDoKyoZ/bdCkwBCiQ==",
+      "dev": true,
+      "dependencies": {
+        "querystringify": "^2.1.1",
+        "requires-port": "^1.0.0"
+      }
+    },
     "node_modules/uuid": {
       "version": "3.4.0",
       "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.4.0.tgz",
@@ -7649,12 +7819,14 @@
     "node_modules/vscode-oniguruma": {
       "version": "1.6.2",
       "resolved": "https://registry.npmjs.org/vscode-oniguruma/-/vscode-oniguruma-1.6.2.tgz",
-      "integrity": "sha512-KH8+KKov5eS/9WhofZR8M8dMHWN2gTxjMsG4jd04YhpbPR91fUj7rYQ2/XjeHCJWbg7X++ApRIU9NUwM2vTvLA=="
+      "integrity": "sha512-KH8+KKov5eS/9WhofZR8M8dMHWN2gTxjMsG4jd04YhpbPR91fUj7rYQ2/XjeHCJWbg7X++ApRIU9NUwM2vTvLA==",
+      "dev": true
     },
     "node_modules/vscode-textmate": {
       "version": "5.2.0",
       "resolved": "https://registry.npmjs.org/vscode-textmate/-/vscode-textmate-5.2.0.tgz",
-      "integrity": "sha512-Uw5ooOQxRASHgu6C7GVvUxisKXfSgW4oFlO+aa+PAkgmH89O3CXxEEzNRNtHSqtXFTl0nAC1uYj0GMSH27uwtQ=="
+      "integrity": "sha512-Uw5ooOQxRASHgu6C7GVvUxisKXfSgW4oFlO+aa+PAkgmH89O3CXxEEzNRNtHSqtXFTl0nAC1uYj0GMSH27uwtQ==",
+      "dev": true
     },
     "node_modules/w3c-hr-time": {
       "version": "1.0.2",
@@ -7781,7 +7953,8 @@
     "node_modules/wrappy": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
-      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="
+      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
+      "dev": true
     },
     "node_modules/write-file-atomic": {
       "version": "3.0.3",
@@ -7796,9 +7969,9 @@
       }
     },
     "node_modules/ws": {
-      "version": "7.5.8",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-7.5.8.tgz",
-      "integrity": "sha512-ri1Id1WinAX5Jqn9HejiGb8crfRio0Qgu8+MtL36rlTA6RLsMdWt1Az/19A2Qij6uSHUMphEFaTKa4WG+UNHNw==",
+      "version": "7.5.9",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-7.5.9.tgz",
+      "integrity": "sha512-F+P9Jil7UiSKSkppIiD94dN07AwvFixvLIj1Og1Rl9GGMuNipJnV9JzjD6XuqmAeiswGvUmNLjr5cFuXwNS77Q==",
       "dev": true,
       "engines": {
         "node": ">=8.3.0"
@@ -7955,27 +8128,27 @@
       }
     },
     "@babel/compat-data": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.18.6.tgz",
-      "integrity": "sha512-tzulrgDT0QD6U7BJ4TKVk2SDDg7wlP39P9yAx1RfLy7vP/7rsDRlWVfbWxElslu56+r7QOhB2NSDsabYYruoZQ==",
+      "version": "7.18.13",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.18.13.tgz",
+      "integrity": "sha512-5yUzC5LqyTFp2HLmDoxGQelcdYgSpP9xsnMWBphAscOdFrHSAVbLNzWiy32sVNDqJRDiJK6klfDnAgu6PAGSHw==",
       "dev": true
     },
     "@babel/core": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.18.6.tgz",
-      "integrity": "sha512-cQbWBpxcbbs/IUredIPkHiAGULLV8iwgNRMFzvbhEXISp4f3rUUXE5+TIw6KwUWUR3DwyI6gmBRnmAtYaWehwQ==",
+      "version": "7.18.13",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.18.13.tgz",
+      "integrity": "sha512-ZisbOvRRusFktksHSG6pjj1CSvkPkcZq/KHD45LAkVP/oiHJkNBZWfpvlLmX8OtHDG8IuzsFlVRWo08w7Qxn0A==",
       "dev": true,
       "requires": {
         "@ampproject/remapping": "^2.1.0",
         "@babel/code-frame": "^7.18.6",
-        "@babel/generator": "^7.18.6",
-        "@babel/helper-compilation-targets": "^7.18.6",
-        "@babel/helper-module-transforms": "^7.18.6",
-        "@babel/helpers": "^7.18.6",
-        "@babel/parser": "^7.18.6",
-        "@babel/template": "^7.18.6",
-        "@babel/traverse": "^7.18.6",
-        "@babel/types": "^7.18.6",
+        "@babel/generator": "^7.18.13",
+        "@babel/helper-compilation-targets": "^7.18.9",
+        "@babel/helper-module-transforms": "^7.18.9",
+        "@babel/helpers": "^7.18.9",
+        "@babel/parser": "^7.18.13",
+        "@babel/template": "^7.18.10",
+        "@babel/traverse": "^7.18.13",
+        "@babel/types": "^7.18.13",
         "convert-source-map": "^1.7.0",
         "debug": "^4.1.0",
         "gensync": "^1.0.0-beta.2",
@@ -8001,9 +8174,9 @@
       }
     },
     "@babel/eslint-parser": {
-      "version": "7.18.2",
-      "resolved": "https://registry.npmjs.org/@babel/eslint-parser/-/eslint-parser-7.18.2.tgz",
-      "integrity": "sha512-oFQYkE8SuH14+uR51JVAmdqwKYXGRjEXx7s+WiagVjqQ+HPE+nnwyF2qlVG8evUsUHmPcA+6YXMEDbIhEyQc5A==",
+      "version": "7.18.9",
+      "resolved": "https://registry.npmjs.org/@babel/eslint-parser/-/eslint-parser-7.18.9.tgz",
+      "integrity": "sha512-KzSGpMBggz4fKbRbWLNyPVTuQr6cmCcBhOyXTw/fieOVaw5oYAwcAj4a7UKcDYCPxQq+CG1NCDZH9e2JTXquiQ==",
       "dev": true,
       "requires": {
         "eslint-scope": "^5.1.1",
@@ -8011,6 +8184,12 @@
         "semver": "^6.3.0"
       },
       "dependencies": {
+        "eslint-visitor-keys": {
+          "version": "2.1.0",
+          "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz",
+          "integrity": "sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==",
+          "dev": true
+        },
         "semver": {
           "version": "6.3.0",
           "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz",
@@ -8020,12 +8199,12 @@
       }
     },
     "@babel/generator": {
-      "version": "7.18.7",
-      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.18.7.tgz",
-      "integrity": "sha512-shck+7VLlY72a2w9c3zYWuE1pwOKEiQHV7GTUbSnhyl5eu3i04t30tBY82ZRWrDfo3gkakCFtevExnxbkf2a3A==",
+      "version": "7.18.13",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.18.13.tgz",
+      "integrity": "sha512-CkPg8ySSPuHTYPJYo7IRALdqyjM9HCbt/3uOBEFbzyGVP6Mn8bwFPB0jX6982JVNBlYzM1nnPkfjuXSOPtQeEQ==",
       "dev": true,
       "requires": {
-        "@babel/types": "^7.18.7",
+        "@babel/types": "^7.18.13",
         "@jridgewell/gen-mapping": "^0.3.2",
         "jsesc": "^2.5.1"
       },
@@ -8044,12 +8223,12 @@
       }
     },
     "@babel/helper-compilation-targets": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.18.6.tgz",
-      "integrity": "sha512-vFjbfhNCzqdeAtZflUFrG5YIFqGTqsctrtkZ1D/NB0mDW9TwW3GmmUepYY4G9wCET5rY5ugz4OGTcLd614IzQg==",
+      "version": "7.18.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.18.9.tgz",
+      "integrity": "sha512-tzLCyVmqUiFlcFoAPLA/gL9TeYrF61VLNtb+hvkuVaB5SUjW7jcfrglBIX1vUIoT7CLP3bBlIMeyEsIl2eFQNg==",
       "dev": true,
       "requires": {
-        "@babel/compat-data": "^7.18.6",
+        "@babel/compat-data": "^7.18.8",
         "@babel/helper-validator-option": "^7.18.6",
         "browserslist": "^4.20.2",
         "semver": "^6.3.0"
@@ -8064,19 +8243,19 @@
       }
     },
     "@babel/helper-environment-visitor": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.18.6.tgz",
-      "integrity": "sha512-8n6gSfn2baOY+qlp+VSzsosjCVGFqWKmDF0cCWOybh52Dw3SEyoWR1KrhMJASjLwIEkkAufZ0xvr+SxLHSpy2Q==",
+      "version": "7.18.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.18.9.tgz",
+      "integrity": "sha512-3r/aACDJ3fhQ/EVgFy0hpj8oHyHpQc+LPtJoY9SzTThAsStm4Ptegq92vqKoE3vD706ZVFWITnMnxucw+S9Ipg==",
       "dev": true
     },
     "@babel/helper-function-name": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.18.6.tgz",
-      "integrity": "sha512-0mWMxV1aC97dhjCah5U5Ua7668r5ZmSC2DLfH2EZnf9c3/dHZKiFa5pRLMH5tjSl471tY6496ZWk/kjNONBxhw==",
+      "version": "7.18.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.18.9.tgz",
+      "integrity": "sha512-fJgWlZt7nxGksJS9a0XdSaI4XvpExnNIgRP+rVefWh5U7BL8pPuir6SJUmFKRfjWQ51OtWSzwOxhaH/EBWWc0A==",
       "dev": true,
       "requires": {
         "@babel/template": "^7.18.6",
-        "@babel/types": "^7.18.6"
+        "@babel/types": "^7.18.9"
       }
     },
     "@babel/helper-hoist-variables": {
@@ -8098,25 +8277,25 @@
       }
     },
     "@babel/helper-module-transforms": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.18.6.tgz",
-      "integrity": "sha512-L//phhB4al5uucwzlimruukHB3jRd5JGClwRMD/ROrVjXfLqovYnvQrK/JK36WYyVwGGO7OD3kMyVTjx+WVPhw==",
+      "version": "7.18.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.18.9.tgz",
+      "integrity": "sha512-KYNqY0ICwfv19b31XzvmI/mfcylOzbLtowkw+mfvGPAQ3kfCnMLYbED3YecL5tPd8nAYFQFAd6JHp2LxZk/J1g==",
       "dev": true,
       "requires": {
-        "@babel/helper-environment-visitor": "^7.18.6",
+        "@babel/helper-environment-visitor": "^7.18.9",
         "@babel/helper-module-imports": "^7.18.6",
         "@babel/helper-simple-access": "^7.18.6",
         "@babel/helper-split-export-declaration": "^7.18.6",
         "@babel/helper-validator-identifier": "^7.18.6",
         "@babel/template": "^7.18.6",
-        "@babel/traverse": "^7.18.6",
-        "@babel/types": "^7.18.6"
+        "@babel/traverse": "^7.18.9",
+        "@babel/types": "^7.18.9"
       }
     },
     "@babel/helper-plugin-utils": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.18.6.tgz",
-      "integrity": "sha512-gvZnm1YAAxh13eJdkb9EWHBnF3eAub3XTLCZEehHT2kWxiKVRL64+ae5Y6Ivne0mVHmMYKT+xWgZO+gQhuLUBg==",
+      "version": "7.18.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.18.9.tgz",
+      "integrity": "sha512-aBXPT3bmtLryXaoJLyYPXPlSD4p1ld9aYeR+sJNOZjJJGiOpb+fKfh3NkcCu7J54nUJwCERPBExCCpyCOHnu/w==",
       "dev": true
     },
     "@babel/helper-simple-access": {
@@ -8137,6 +8316,12 @@
         "@babel/types": "^7.18.6"
       }
     },
+    "@babel/helper-string-parser": {
+      "version": "7.18.10",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.18.10.tgz",
+      "integrity": "sha512-XtIfWmeNY3i4t7t4D2t02q50HvqHybPqW2ki1kosnvWCwuCMeo81Jf0gwr85jy/neUdg5XDdeFE/80DXiO+njw==",
+      "dev": true
+    },
     "@babel/helper-validator-identifier": {
       "version": "7.18.6",
       "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.18.6.tgz",
@@ -8150,14 +8335,14 @@
       "dev": true
     },
     "@babel/helpers": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.18.6.tgz",
-      "integrity": "sha512-vzSiiqbQOghPngUYt/zWGvK3LAsPhz55vc9XNN0xAl2gV4ieShI2OQli5duxWHD+72PZPTKAcfcZDE1Cwc5zsQ==",
+      "version": "7.18.9",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.18.9.tgz",
+      "integrity": "sha512-Jf5a+rbrLoR4eNdUmnFu8cN5eNJT6qdTdOg5IHIzq87WwyRw9PwguLFOWYgktN/60IP4fgDUawJvs7PjQIzELQ==",
       "dev": true,
       "requires": {
         "@babel/template": "^7.18.6",
-        "@babel/traverse": "^7.18.6",
-        "@babel/types": "^7.18.6"
+        "@babel/traverse": "^7.18.9",
+        "@babel/types": "^7.18.9"
       }
     },
     "@babel/highlight": {
@@ -8230,9 +8415,9 @@
       }
     },
     "@babel/parser": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.18.6.tgz",
-      "integrity": "sha512-uQVSa9jJUe/G/304lXspfWVpKpK4euFLgGiMQFOCpM/bgcAdeoHwi/OQz23O9GK2osz26ZiXRRV9aV+Yl1O8tw==",
+      "version": "7.18.13",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.18.13.tgz",
+      "integrity": "sha512-dgXcIfMuQ0kgzLB2b9tRZs7TTFFaGM2AbtA4fJgUUYukzGH4jwsS7hzQHEGs67jdehpm22vkgKwvbU+aEflgwg==",
       "dev": true
     },
     "@babel/plugin-syntax-async-generators": {
@@ -8353,14 +8538,14 @@
       }
     },
     "@babel/template": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.18.6.tgz",
-      "integrity": "sha512-JoDWzPe+wgBsTTgdnIma3iHNFC7YVJoPssVBDjiHfNlyt4YcunDtcDOUmfVDfCK5MfdsaIoX9PkijPhjH3nYUw==",
+      "version": "7.18.10",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.18.10.tgz",
+      "integrity": "sha512-TI+rCtooWHr3QJ27kJxfjutghu44DLnasDMwpDqCXVTal9RLp3RSYNh4NdBrRP2cQAoG9A8juOQl6P6oZG4JxA==",
       "dev": true,
       "requires": {
         "@babel/code-frame": "^7.18.6",
-        "@babel/parser": "^7.18.6",
-        "@babel/types": "^7.18.6"
+        "@babel/parser": "^7.18.10",
+        "@babel/types": "^7.18.10"
       },
       "dependencies": {
         "@babel/code-frame": {
@@ -8375,19 +8560,19 @@
       }
     },
     "@babel/traverse": {
-      "version": "7.18.6",
-      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.18.6.tgz",
-      "integrity": "sha512-zS/OKyqmD7lslOtFqbscH6gMLFYOfG1YPqCKfAW5KrTeolKqvB8UelR49Fpr6y93kYkW2Ik00mT1LOGiAGvizw==",
+      "version": "7.18.13",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.18.13.tgz",
+      "integrity": "sha512-N6kt9X1jRMLPxxxPYWi7tgvJRH/rtoU+dbKAPDM44RFHiMH8igdsaSBgFeskhSl/kLWLDUvIh1RXCrTmg0/zvA==",
       "dev": true,
       "requires": {
         "@babel/code-frame": "^7.18.6",
-        "@babel/generator": "^7.18.6",
-        "@babel/helper-environment-visitor": "^7.18.6",
-        "@babel/helper-function-name": "^7.18.6",
+        "@babel/generator": "^7.18.13",
+        "@babel/helper-environment-visitor": "^7.18.9",
+        "@babel/helper-function-name": "^7.18.9",
         "@babel/helper-hoist-variables": "^7.18.6",
         "@babel/helper-split-export-declaration": "^7.18.6",
-        "@babel/parser": "^7.18.6",
-        "@babel/types": "^7.18.6",
+        "@babel/parser": "^7.18.13",
+        "@babel/types": "^7.18.13",
         "debug": "^4.1.0",
         "globals": "^11.1.0"
       },
@@ -8410,11 +8595,12 @@
       }
     },
     "@babel/types": {
-      "version": "7.18.7",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.18.7.tgz",
-      "integrity": "sha512-QG3yxTcTIBoAcQmkCs+wAPYZhu7Dk9rXKacINfNbdJDNERTbLQbHGyVG8q/YGMPeCJRIhSY0+fTc5+xuh6WPSQ==",
+      "version": "7.18.13",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.18.13.tgz",
+      "integrity": "sha512-ePqfTihzW0W6XAU+aMw2ykilisStJfDnsejDCXRchCcMJ4O0+8DhPXf2YUbZ6wjBlsEmZwLK/sPweWtu8hcJYQ==",
       "dev": true,
       "requires": {
+        "@babel/helper-string-parser": "^7.18.10",
         "@babel/helper-validator-identifier": "^7.18.6",
         "to-fast-properties": "^2.0.0"
       }
@@ -8696,9 +8882,9 @@
       }
     },
     "@jridgewell/resolve-uri": {
-      "version": "3.0.8",
-      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.0.8.tgz",
-      "integrity": "sha512-YK5G9LaddzGbcucK4c8h5tWFmMPBvRZ/uyWmN1/SbBdIvqGUdWGkJ5BAaccgs6XbzVLsqbPJrBSFwKv3kT9i7w==",
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz",
+      "integrity": "sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==",
       "dev": true
     },
     "@jridgewell/set-array": {
@@ -8737,9 +8923,9 @@
       "dev": true
     },
     "@jridgewell/trace-mapping": {
-      "version": "0.3.14",
-      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.14.tgz",
-      "integrity": "sha512-bJWEfQ9lPTvm3SneWwRFVLzrh6nhjwqw7TUFFBEMzwvg7t7PCDenf2lDwqo4NQXzdpgBXyFgDWnQA+2vkruksQ==",
+      "version": "0.3.15",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.15.tgz",
+      "integrity": "sha512-oWZNOULl+UbhsgB51uuZzglikfIKSUBO/M9W2OfEjn7cmqoAiCgmv9lyACTUacZwBz0ITnJ2NqjU8Tx0DHL88g==",
       "dev": true,
       "requires": {
         "@jridgewell/resolve-uri": "^3.0.3",
@@ -8805,9 +8991,9 @@
       }
     },
     "@rollup/plugin-commonjs": {
-      "version": "22.0.1",
-      "resolved": "https://registry.npmjs.org/@rollup/plugin-commonjs/-/plugin-commonjs-22.0.1.tgz",
-      "integrity": "sha512-dGfEZvdjDHObBiP5IvwTKMVeq/tBZGMBHZFMdIV1ClMM/YoWS34xrHFGfag9SN2ZtMgNZRFruqvxZQEa70O6nQ==",
+      "version": "22.0.2",
+      "resolved": "https://registry.npmjs.org/@rollup/plugin-commonjs/-/plugin-commonjs-22.0.2.tgz",
+      "integrity": "sha512-//NdP6iIwPbMTcazYsiBMbJW7gfmpHom33u1beiIoHDEM0Q9clvtQB1T0efvMqHeKsGohiHo97BCPCkBXdscwg==",
       "dev": true,
       "requires": {
         "@rollup/pluginutils": "^3.1.0",
@@ -8919,9 +9105,9 @@
       }
     },
     "@types/babel__traverse": {
-      "version": "7.17.1",
-      "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.17.1.tgz",
-      "integrity": "sha512-kVzjari1s2YVi77D3w1yuvohV2idweYXMCDzqBiVNN63TcDWrIlTVOYpqVrvbbyOE/IyzBoTKF0fdnLPEORFxA==",
+      "version": "7.18.1",
+      "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.18.1.tgz",
+      "integrity": "sha512-FSdLaZh2UxaMuLp9lixWaHq/golWTRWOnRsAXzDTDSDOQLuZb1nsdCt6pJSPWSEQt2eFZ2YVk3oYhn+1kLMeMA==",
       "dev": true,
       "requires": {
         "@babel/types": "^7.3.0"
@@ -8983,9 +9169,9 @@
       "dev": true
     },
     "@types/node": {
-      "version": "18.0.1",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.0.1.tgz",
-      "integrity": "sha512-CmR8+Tsy95hhwtZBKJBs0/FFq4XX7sDZHlGGf+0q+BRZfMbOTkzkj0AFAuTyXbObDIoanaBBW0+KEW+m3N16Wg==",
+      "version": "18.7.14",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.7.14.tgz",
+      "integrity": "sha512-6bbDaETVi8oyIARulOE9qF1/Qdi/23z6emrUh0fNJRUmjznqrixD4MpGDdgOFk5Xb0m2H6Xu42JGdvAxaJR/wA==",
       "dev": true
     },
     "@types/normalize-package-data": {
@@ -8995,9 +9181,9 @@
       "dev": true
     },
     "@types/prettier": {
-      "version": "2.6.3",
-      "resolved": "https://registry.npmjs.org/@types/prettier/-/prettier-2.6.3.tgz",
-      "integrity": "sha512-ymZk3LEC/fsut+/Q5qejp6R9O1rMxz3XaRHDV6kX8MrGAhOSPqVARbDi+EZvInBpw+BnCX3TD240byVkOfQsHg==",
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/@types/prettier/-/prettier-2.7.0.tgz",
+      "integrity": "sha512-RI1L7N4JnW5gQw2spvL7Sllfuf1SaHdrZpCHiBlCXjIlufi1SMNnbu2teze3/QE67Fg2tBlH7W+mi4hVNk4p0A==",
       "dev": true
     },
     "@types/resolve": {
@@ -9031,14 +9217,14 @@
       "dev": true
     },
     "@typescript-eslint/eslint-plugin": {
-      "version": "5.30.4",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.30.4.tgz",
-      "integrity": "sha512-xjujQISAIa4HAaos8fcMZXmqkuZqMx6icdxkI88jMM/eNe4J8AuTLYnLK+zdm0mBYLyctdFf//UE4/xFCcQzYQ==",
+      "version": "5.36.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.36.1.tgz",
+      "integrity": "sha512-iC40UK8q1tMepSDwiLbTbMXKDxzNy+4TfPWgIL661Ym0sD42vRcQU93IsZIrmi+x292DBr60UI/gSwfdVYexCA==",
       "dev": true,
       "requires": {
-        "@typescript-eslint/scope-manager": "5.30.4",
-        "@typescript-eslint/type-utils": "5.30.4",
-        "@typescript-eslint/utils": "5.30.4",
+        "@typescript-eslint/scope-manager": "5.36.1",
+        "@typescript-eslint/type-utils": "5.36.1",
+        "@typescript-eslint/utils": "5.36.1",
         "debug": "^4.3.4",
         "functional-red-black-tree": "^1.0.1",
         "ignore": "^5.2.0",
@@ -9059,52 +9245,53 @@
       }
     },
     "@typescript-eslint/parser": {
-      "version": "5.30.4",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.30.4.tgz",
-      "integrity": "sha512-/ge1HtU63wVoED4VnlU2o+FPFmi017bPYpeSrCmd8Ycsti4VSxXrmcpXXm7JpI4GT0Aa7qviabv1PEp6L5bboQ==",
+      "version": "5.36.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.36.1.tgz",
+      "integrity": "sha512-/IsgNGOkBi7CuDfUbwt1eOqUXF9WGVBW9dwEe1pi+L32XrTsZIgmDFIi2RxjzsvB/8i+MIf5JIoTEH8LOZ368A==",
       "dev": true,
       "requires": {
-        "@typescript-eslint/scope-manager": "5.30.4",
-        "@typescript-eslint/types": "5.30.4",
-        "@typescript-eslint/typescript-estree": "5.30.4",
+        "@typescript-eslint/scope-manager": "5.36.1",
+        "@typescript-eslint/types": "5.36.1",
+        "@typescript-eslint/typescript-estree": "5.36.1",
         "debug": "^4.3.4"
       }
     },
     "@typescript-eslint/scope-manager": {
-      "version": "5.30.4",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.30.4.tgz",
-      "integrity": "sha512-DNzlQwGSiGefz71JwaHrpcaAX3zYkEcy8uVuan3YMKOa6qeW/y+7SaD8KIsIAruASwq6P+U4BjWBWtM2O+mwBQ==",
+      "version": "5.36.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.36.1.tgz",
+      "integrity": "sha512-pGC2SH3/tXdu9IH3ItoqciD3f3RRGCh7hb9zPdN2Drsr341zgd6VbhP5OHQO/reUqihNltfPpMpTNihFMarP2w==",
       "dev": true,
       "requires": {
-        "@typescript-eslint/types": "5.30.4",
-        "@typescript-eslint/visitor-keys": "5.30.4"
+        "@typescript-eslint/types": "5.36.1",
+        "@typescript-eslint/visitor-keys": "5.36.1"
       }
     },
     "@typescript-eslint/type-utils": {
-      "version": "5.30.4",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-5.30.4.tgz",
-      "integrity": "sha512-55cf1dZviwwv+unDB+mF8vZkfta5muTK6bppPvenWWCD7slZZ0DEsXUjZerqy7Rq8s3J4SXdg4rMIY8ngCtTmA==",
+      "version": "5.36.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-5.36.1.tgz",
+      "integrity": "sha512-xfZhfmoQT6m3lmlqDvDzv9TiCYdw22cdj06xY0obSznBsT///GK5IEZQdGliXpAOaRL34o8phEvXzEo/VJx13Q==",
       "dev": true,
       "requires": {
-        "@typescript-eslint/utils": "5.30.4",
+        "@typescript-eslint/typescript-estree": "5.36.1",
+        "@typescript-eslint/utils": "5.36.1",
         "debug": "^4.3.4",
         "tsutils": "^3.21.0"
       }
     },
     "@typescript-eslint/types": {
-      "version": "5.30.4",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.30.4.tgz",
-      "integrity": "sha512-NTEvqc+Vvu8Q6JeAKryHk2eqLKqsr2St3xhIjhOjQv5wQUBhaTuix4WOSacqj0ONWfKVU12Eug3LEAB95GBkMA==",
+      "version": "5.36.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.36.1.tgz",
+      "integrity": "sha512-jd93ShpsIk1KgBTx9E+hCSEuLCUFwi9V/urhjOWnOaksGZFbTOxAT47OH2d4NLJnLhkVD+wDbB48BuaycZPLBg==",
       "dev": true
     },
     "@typescript-eslint/typescript-estree": {
-      "version": "5.30.4",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-5.30.4.tgz",
-      "integrity": "sha512-V4VnEs6/J9/nNizaA12IeU4SAeEYaiKr7XndLNfV5+3zZSB4hIu6EhHJixTKhvIqA+EEHgBl6re8pivBMLLO1w==",
+      "version": "5.36.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-5.36.1.tgz",
+      "integrity": "sha512-ih7V52zvHdiX6WcPjsOdmADhYMDN15SylWRZrT2OMy80wzKbc79n8wFW0xpWpU0x3VpBz/oDgTm2xwDAnFTl+g==",
       "dev": true,
       "requires": {
-        "@typescript-eslint/types": "5.30.4",
-        "@typescript-eslint/visitor-keys": "5.30.4",
+        "@typescript-eslint/types": "5.36.1",
+        "@typescript-eslint/visitor-keys": "5.36.1",
         "debug": "^4.3.4",
         "globby": "^11.1.0",
         "is-glob": "^4.0.3",
@@ -9124,35 +9311,27 @@
       }
     },
     "@typescript-eslint/utils": {
-      "version": "5.30.4",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-5.30.4.tgz",
-      "integrity": "sha512-a+GQrJzOUhn4WT1mUumXDyam+22Oo4c5K/jnZ+6r/4WTQF3q8e4CsC9PLHb4SnOClzOqo/5GLZWvkE1aa5UGKQ==",
+      "version": "5.36.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-5.36.1.tgz",
+      "integrity": "sha512-lNj4FtTiXm5c+u0pUehozaUWhh7UYKnwryku0nxJlYUEWetyG92uw2pr+2Iy4M/u0ONMKzfrx7AsGBTCzORmIg==",
       "dev": true,
       "requires": {
         "@types/json-schema": "^7.0.9",
-        "@typescript-eslint/scope-manager": "5.30.4",
-        "@typescript-eslint/types": "5.30.4",
-        "@typescript-eslint/typescript-estree": "5.30.4",
+        "@typescript-eslint/scope-manager": "5.36.1",
+        "@typescript-eslint/types": "5.36.1",
+        "@typescript-eslint/typescript-estree": "5.36.1",
         "eslint-scope": "^5.1.1",
         "eslint-utils": "^3.0.0"
       }
     },
     "@typescript-eslint/visitor-keys": {
-      "version": "5.30.4",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.30.4.tgz",
-      "integrity": "sha512-ulKGse3mruSc8x6l8ORSc6+1ORyJzKmZeIaRTu/WpaF/jx3vHvEn5XZUKF9XaVg2710mFmTAUlLcLYLPp/Zf/Q==",
+      "version": "5.36.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.36.1.tgz",
+      "integrity": "sha512-ojB9aRyRFzVMN3b5joSYni6FAS10BBSCAfKJhjJAV08t/a95aM6tAhz+O1jF+EtgxktuSO3wJysp2R+Def/IWQ==",
       "dev": true,
       "requires": {
-        "@typescript-eslint/types": "5.30.4",
+        "@typescript-eslint/types": "5.36.1",
         "eslint-visitor-keys": "^3.3.0"
-      },
-      "dependencies": {
-        "eslint-visitor-keys": {
-          "version": "3.3.0",
-          "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.3.0.tgz",
-          "integrity": "sha512-mQ+suqKJVyeuwGYHAdjMFqjCyfl8+Ldnxuyp3ldiMBFKkvytrXUZWaiPCEav8qDHKty44bD+qV1IP4T+w+xXRA==",
-          "dev": true
-        }
       }
     },
     "abab": {
@@ -9426,7 +9605,14 @@
     "balanced-match": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
-      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true
+    },
+    "base64-js": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
+      "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
+      "dev": true
     },
     "bcrypt-pbkdf": {
       "version": "1.0.2",
@@ -9510,15 +9696,15 @@
       "dev": true
     },
     "browserslist": {
-      "version": "4.21.1",
-      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.21.1.tgz",
-      "integrity": "sha512-Nq8MFCSrnJXSc88yliwlzQe3qNe3VntIjhsArW9IJOEPSHNx23FalwApUVbzAWABLhYJJ7y8AynWI/XM8OdfjQ==",
+      "version": "4.21.3",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.21.3.tgz",
+      "integrity": "sha512-898rgRXLAyRkM1GryrrBHGkqA5hlpkV5MhtZwg9QXeiyLUYs2k00Un05aX5l2/yJIOObYKOpS2JNo8nJDE7fWQ==",
       "dev": true,
       "requires": {
-        "caniuse-lite": "^1.0.30001359",
-        "electron-to-chromium": "^1.4.172",
-        "node-releases": "^2.0.5",
-        "update-browserslist-db": "^1.0.4"
+        "caniuse-lite": "^1.0.30001370",
+        "electron-to-chromium": "^1.4.202",
+        "node-releases": "^2.0.6",
+        "update-browserslist-db": "^1.0.5"
       }
     },
     "bs-logger": {
@@ -9539,6 +9725,16 @@
         "node-int64": "^0.4.0"
       }
     },
+    "buffer": {
+      "version": "5.7.1",
+      "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz",
+      "integrity": "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==",
+      "dev": true,
+      "requires": {
+        "base64-js": "^1.3.1",
+        "ieee754": "^1.1.13"
+      }
+    },
     "buffer-from": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
@@ -9574,9 +9770,9 @@
       "dev": true
     },
     "caniuse-lite": {
-      "version": "1.0.30001362",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001362.tgz",
-      "integrity": "sha512-PFykHuC7BQTzCGQFaV6wD8IDRM3HpI83BXr99nNJhoOyDufgSuKlt0QVlWYt5ZJtEYFeuNVF5QY3kJcu8hVFjQ==",
+      "version": "1.0.30001387",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001387.tgz",
+      "integrity": "sha512-fKDH0F1KOJvR+mWSOvhj8lVRr/Q/mc5u5nabU2vi1/sgvlSqEsE8dOq0Hy/BqVbDkCYQPRRHB1WRjW6PGB/7PA==",
       "dev": true
     },
     "caseless": {
@@ -9744,9 +9940,9 @@
       }
     },
     "commander": {
-      "version": "9.3.0",
-      "resolved": "https://registry.npmjs.org/commander/-/commander-9.3.0.tgz",
-      "integrity": "sha512-hv95iU5uXPbK83mjrJKuZyFM/LBAoCV/XhVGkS5Je6tl7sxr6A0ITMw5WoRV46/UaJ46Nllm3Xt7IaJhXTIkzw=="
+      "version": "9.4.0",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-9.4.0.tgz",
+      "integrity": "sha512-sRPT+umqkz90UA8M1yqYfnHlZA7fF6nSphDtxeywPZ49ysjxDQybzk13CL+mXekDRG92skbcqCLVovuCusNmFw=="
     },
     "common-tags": {
       "version": "1.8.2",
@@ -9877,9 +10073,9 @@
       }
     },
     "decimal.js": {
-      "version": "10.3.1",
-      "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.3.1.tgz",
-      "integrity": "sha512-V0pfhfr8suzyPGOx3nmq4aHqabehUZn6Ch9kyFpV79TGDTWFmHqUqXdabR7QHqxzrYolF4+tVmJhUG4OURg5dQ==",
+      "version": "10.4.0",
+      "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.4.0.tgz",
+      "integrity": "sha512-Nv6ENEzyPQ6AItkGwLE2PGKinZZ9g59vSh2BeH6NqPu0OTKZ5ruJsVqh/orbAnqXc9pBbgXAIrc2EyaCj8NpGg==",
       "dev": true
     },
     "dedent": {
@@ -9974,9 +10170,9 @@
       }
     },
     "electron-to-chromium": {
-      "version": "1.4.177",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.177.tgz",
-      "integrity": "sha512-FYPir3NSBEGexSZUEeht81oVhHfLFl6mhUKSkjHN/iB/TwEIt/WHQrqVGfTLN5gQxwJCQkIJBe05eOXjI7omgg==",
+      "version": "1.4.240",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.240.tgz",
+      "integrity": "sha512-r20dUOtZ4vUPTqAajDGonIM1uas5tf85Up+wPdtNBNvBSqGCfkpvMVvQ1T8YJzPV9/Y9g3FbUDcXb94Rafycow==",
       "dev": true
     },
     "emittery": {
@@ -10010,16 +10206,16 @@
       }
     },
     "es-abstract": {
-      "version": "1.20.1",
-      "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.20.1.tgz",
-      "integrity": "sha512-WEm2oBhfoI2sImeM4OF2zE2V3BYdSF+KnSi9Sidz51fQHd7+JuF8Xgcj9/0o+OWeIeIS/MiuNnlruQrJf16GQA==",
+      "version": "1.20.2",
+      "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.20.2.tgz",
+      "integrity": "sha512-XxXQuVNrySBNlEkTYJoDNFe5+s2yIOpzq80sUHEdPdQr0S5nTLz4ZPPPswNIpKseDDUS5yghX1gfLIHQZ1iNuQ==",
       "dev": true,
       "requires": {
         "call-bind": "^1.0.2",
         "es-to-primitive": "^1.2.1",
         "function-bind": "^1.1.1",
         "function.prototype.name": "^1.1.5",
-        "get-intrinsic": "^1.1.1",
+        "get-intrinsic": "^1.1.2",
         "get-symbol-description": "^1.0.0",
         "has": "^1.0.3",
         "has-property-descriptors": "^1.0.0",
@@ -10031,9 +10227,9 @@
         "is-shared-array-buffer": "^1.0.2",
         "is-string": "^1.0.7",
         "is-weakref": "^1.0.2",
-        "object-inspect": "^1.12.0",
+        "object-inspect": "^1.12.2",
         "object-keys": "^1.1.1",
-        "object.assign": "^4.1.2",
+        "object.assign": "^4.1.4",
         "regexp.prototype.flags": "^1.4.3",
         "string.prototype.trimend": "^1.0.5",
         "string.prototype.trimstart": "^1.0.5",
@@ -10061,9 +10257,9 @@
       }
     },
     "es5-ext": {
-      "version": "0.10.61",
-      "resolved": "https://registry.npmjs.org/es5-ext/-/es5-ext-0.10.61.tgz",
-      "integrity": "sha512-yFhIqQAzu2Ca2I4SE2Au3rxVfmohU9Y7wqGR+s7+H7krk26NXhIRAZDgqd6xqjCEFUomDEA3/Bo/7fKmIkW1kA==",
+      "version": "0.10.62",
+      "resolved": "https://registry.npmjs.org/es5-ext/-/es5-ext-0.10.62.tgz",
+      "integrity": "sha512-BHLqn0klhEpnOKSrzn/Xsz2UIW8j+cGmo9JLzr8BiUapV8hPL9+FliFqjwr9ngW7jWdnxv6eO+/LqyhJVqgrjA==",
       "dev": true,
       "requires": {
         "es6-iterator": "^2.0.3",
@@ -10235,6 +10431,12 @@
             }
           }
         },
+        "eslint-visitor-keys": {
+          "version": "2.1.0",
+          "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz",
+          "integrity": "sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==",
+          "dev": true
+        },
         "ignore": {
           "version": "4.0.6",
           "resolved": "https://registry.npmjs.org/ignore/-/ignore-4.0.6.tgz",
@@ -10289,9 +10491,9 @@
       "requires": {}
     },
     "eslint-plugin-react": {
-      "version": "7.30.1",
-      "resolved": "https://registry.npmjs.org/eslint-plugin-react/-/eslint-plugin-react-7.30.1.tgz",
-      "integrity": "sha512-NbEvI9jtqO46yJA3wcRF9Mo0lF9T/jhdHqhCHXiXtD+Zcb98812wvokjWpU7Q4QH5edo6dmqrukxVvWWXHlsUg==",
+      "version": "7.31.1",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-react/-/eslint-plugin-react-7.31.1.tgz",
+      "integrity": "sha512-j4/2xWqt/R7AZzG8CakGHA6Xa/u7iR8Q3xCxY+AUghdT92bnIDOBEefV456OeH0QvBcroVc0eyvrrLSyQGYIfg==",
       "dev": true,
       "requires": {
         "array-includes": "^3.1.5",
@@ -10401,6 +10603,14 @@
         "eslint-visitor-keys": "^2.0.0",
         "esquery": "^1.3.1",
         "multimap": "^1.1.0"
+      },
+      "dependencies": {
+        "eslint-visitor-keys": {
+          "version": "2.1.0",
+          "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz",
+          "integrity": "sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==",
+          "dev": true
+        }
       }
     },
     "eslint-utils": {
@@ -10410,12 +10620,20 @@
       "dev": true,
       "requires": {
         "eslint-visitor-keys": "^2.0.0"
+      },
+      "dependencies": {
+        "eslint-visitor-keys": {
+          "version": "2.1.0",
+          "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz",
+          "integrity": "sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==",
+          "dev": true
+        }
       }
     },
     "eslint-visitor-keys": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz",
-      "integrity": "sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==",
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.3.0.tgz",
+      "integrity": "sha512-mQ+suqKJVyeuwGYHAdjMFqjCyfl8+Ldnxuyp3ldiMBFKkvytrXUZWaiPCEav8qDHKty44bD+qV1IP4T+w+xXRA==",
       "dev": true
     },
     "espree": {
@@ -10525,18 +10743,18 @@
       }
     },
     "ext": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/ext/-/ext-1.6.0.tgz",
-      "integrity": "sha512-sdBImtzkq2HpkdRLtlLWDa6w4DX22ijZLKx8BMPUuKe1c5lbN6xwQDQCxSfxBQnHZ13ls/FH0MQZx/q/gr6FQg==",
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/ext/-/ext-1.7.0.tgz",
+      "integrity": "sha512-6hxeJYaL110a9b5TEJSj0gojyHQAmA2ch5Os+ySCiA1QGdS697XWY1pzsrSjqA9LDEEgdB/KypIlR59RcLuHYw==",
       "dev": true,
       "requires": {
-        "type": "^2.5.0"
+        "type": "^2.7.2"
       },
       "dependencies": {
         "type": {
-          "version": "2.6.0",
-          "resolved": "https://registry.npmjs.org/type/-/type-2.6.0.tgz",
-          "integrity": "sha512-eiDBDOmkih5pMbo9OqsqPRGMljLodLcwd5XD5JbtNB0o89xZAwynY9EdCDsJU7LtcVCClu9DvM7/0Ep1hYX3EQ==",
+          "version": "2.7.2",
+          "resolved": "https://registry.npmjs.org/type/-/type-2.7.2.tgz",
+          "integrity": "sha512-dzlvlNlt6AXU7EBSfpAscydQ7gXB+pPGsPnfJnZpiNJBDj7IaJzQlBZYGdEi4R9HmPdBv2XmWJ6YUtoTa7lmCw==",
           "dev": true
         }
       }
@@ -10671,9 +10889,9 @@
       }
     },
     "flatted": {
-      "version": "3.2.6",
-      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.2.6.tgz",
-      "integrity": "sha512-0sQoMh9s0BYsm+12Huy/rkKxVu4R1+r96YX5cG44rHV0pQ6iC3Q+mkoMFaGWObMFYQxCVT+ssG1ksneA2MI9KQ==",
+      "version": "3.2.7",
+      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.2.7.tgz",
+      "integrity": "sha512-5nqDSxl8nn5BSNxyR3n4I6eDmbolI6WT+QqR547RwxQapgjQBmtktdP+HTBb/a/zLsbzERTONyUB5pefh5TtjQ==",
       "dev": true
     },
     "forever-agent": {
@@ -10707,7 +10925,8 @@
     "fs.realpath": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
-      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw=="
+      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
+      "dev": true
     },
     "fsevents": {
       "version": "2.3.2",
@@ -10824,9 +11043,9 @@
       }
     },
     "globals": {
-      "version": "13.15.0",
-      "resolved": "https://registry.npmjs.org/globals/-/globals-13.15.0.tgz",
-      "integrity": "sha512-bpzcOlgDhMG070Av0Vy5Owklpv1I6+j96GhUI7Rh7IzDCKLzboflLrrfqMu8NquDbiR4EOQk7XzJwqVJxicxog==",
+      "version": "13.17.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-13.17.0.tgz",
+      "integrity": "sha512-1C+6nQRb1GwGMKm2dH/E7enFAMxGTmGI7/dEdhy/DNelv85w9B72t3uc5frtMNXIbzrarJJ/lTCjcaZwbLJmyw==",
       "dev": true,
       "requires": {
         "type-fest": "^0.20.2"
@@ -10981,6 +11200,12 @@
         "safer-buffer": ">= 2.1.2 < 3"
       }
     },
+    "ieee754": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
+      "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",
+      "dev": true
+    },
     "ignore": {
       "version": "5.2.0",
       "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.2.0.tgz",
@@ -11023,6 +11248,7 @@
       "version": "1.0.6",
       "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
       "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
+      "dev": true,
       "requires": {
         "once": "^1.3.0",
         "wrappy": "1"
@@ -11031,7 +11257,8 @@
     "inherits": {
       "version": "2.0.4",
       "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
-      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "dev": true
     },
     "internal-slot": {
       "version": "1.0.3",
@@ -11070,12 +11297,12 @@
       }
     },
     "is-builtin-module": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/is-builtin-module/-/is-builtin-module-3.1.0.tgz",
-      "integrity": "sha512-OV7JjAgOTfAFJmHZLvpSTb4qi0nIILDV1gWPYDnDJUTNFM5aGlRAhk4QcT8i7TuAleeEV5Fdkqn3t4mS+Q11fg==",
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/is-builtin-module/-/is-builtin-module-3.2.0.tgz",
+      "integrity": "sha512-phDA4oSGt7vl1n5tJvTWooWWAsXLY+2xCnxNqvKhGEzujg+A43wPlPOyDg3C8XQHN+6k/JTQWJ/j0dQh/qr+Hw==",
       "dev": true,
       "requires": {
-        "builtin-modules": "^3.0.0"
+        "builtin-modules": "^3.3.0"
       }
     },
     "is-callable": {
@@ -11085,9 +11312,9 @@
       "dev": true
     },
     "is-core-module": {
-      "version": "2.9.0",
-      "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.9.0.tgz",
-      "integrity": "sha512-+5FPy5PnwmO3lvfMb0AsoPaBG+5KHUI0wYFXOtYPnVVVspTFUuMZNfNaNVRt3FZadstu2c8x23vykRW/NBoU6A==",
+      "version": "2.10.0",
+      "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.10.0.tgz",
+      "integrity": "sha512-Erxj2n/LDAZ7H8WNJXd9tw38GYM3dv8rk8Zcs+jJuxYTW7sozH+SS8NtrSjVL1/vpLvWi1hxy96IzjJ3EHTJJg==",
       "dev": true,
       "requires": {
         "has": "^1.0.3"
@@ -11297,9 +11524,9 @@
       }
     },
     "istanbul-reports": {
-      "version": "3.1.4",
-      "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.1.4.tgz",
-      "integrity": "sha512-r1/DshN4KSE7xWEknZLLLLDn5CJybV3nw01VTkp6D5jzLuELlcbudfj/eSQFvrKsJuTVCGnePO7ho82Nw9zzfw==",
+      "version": "3.1.5",
+      "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.1.5.tgz",
+      "integrity": "sha512-nUsEMa9pBt/NOHqbcbeJEgqIlY/K7rVWUX6Lql2orY5e9roQOthbR3vtY4zzf2orPELg80fnxxk9zUyPlgwD1w==",
       "dev": true,
       "requires": {
         "html-escaper": "^2.0.0",
@@ -11874,9 +12101,9 @@
       },
       "dependencies": {
         "acorn": {
-          "version": "8.7.1",
-          "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.7.1.tgz",
-          "integrity": "sha512-Xx54uLJQZ19lKygFXOWsscKUbsBZW0CPykPhVQdhIeIwrbPmJzqeASDInc8nKBnp/JT6igTs82qPXz069H8I/A==",
+          "version": "8.8.0",
+          "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.8.0.tgz",
+          "integrity": "sha512-QOxyigPVrpZ2GXT+PFyZTl6TtOFc5egxHIP9IlQ+RbupQuX4RkT/Bee4/kQuC02Xkzg84JcT7oLYtDIQxp+v7w==",
           "dev": true
         }
       }
@@ -11943,9 +12170,10 @@
       "dev": true
     },
     "jsonc-parser": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-3.0.0.tgz",
-      "integrity": "sha512-fQzRfAbIBnR0IQvftw9FJveWiHp72Fg20giDrHz6TdfB12UH/uue0D3hm57UB5KgAVuniLMCaS8P1IMj9NR7cA=="
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-3.2.0.tgz",
+      "integrity": "sha512-gfFQZrcTc8CnKXp6Y4/CBT3fTc0OVuDofpre4aEeEpSBPV5X5v4+Vmx+8snU7RLPrNHPKSgLxGo9YuQzz20o+w==",
+      "dev": true
     },
     "jsonfile": {
       "version": "6.1.0",
@@ -11976,13 +12204,13 @@
       }
     },
     "jsx-ast-utils": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/jsx-ast-utils/-/jsx-ast-utils-3.3.1.tgz",
-      "integrity": "sha512-pxrjmNpeRw5wwVeWyEAk7QJu2GnBO3uzPFmHCKJJFPKK2Cy0cWL23krGtLdnMmbIi6/FjlrQpPyfQI19ByPOhQ==",
+      "version": "3.3.3",
+      "resolved": "https://registry.npmjs.org/jsx-ast-utils/-/jsx-ast-utils-3.3.3.tgz",
+      "integrity": "sha512-fYQHZTZ8jSfmWZ0iyzfwiU4WDX4HpHbMCZ3gPlWYiCl3BoeOTsqKBqnTVfH2rYT7eP5c3sVbeSPHnnJOaTrWiw==",
       "dev": true,
       "requires": {
         "array-includes": "^3.1.5",
-        "object.assign": "^4.1.2"
+        "object.assign": "^4.1.3"
       }
     },
     "kleur": {
@@ -12111,7 +12339,8 @@
     "lunr": {
       "version": "2.3.9",
       "resolved": "https://registry.npmjs.org/lunr/-/lunr-2.3.9.tgz",
-      "integrity": "sha512-zTU3DaZaF3Rt9rhN3uBMGQD3dD2/vFQqnvZCDv4dl5iOzq2IZQqTxu90r4E5J+nP70J3ilqVCrbho2eWaeW8Ow=="
+      "integrity": "sha512-zTU3DaZaF3Rt9rhN3uBMGQD3dD2/vFQqnvZCDv4dl5iOzq2IZQqTxu90r4E5J+nP70J3ilqVCrbho2eWaeW8Ow==",
+      "dev": true
     },
     "magic-string": {
       "version": "0.25.9",
@@ -12155,9 +12384,10 @@
       }
     },
     "marked": {
-      "version": "4.0.17",
-      "resolved": "https://registry.npmjs.org/marked/-/marked-4.0.17.tgz",
-      "integrity": "sha512-Wfk0ATOK5iPxM4ptrORkFemqroz0ZDxp5MWfYA7H/F+wO17NRWV5Ypxi6p3g2Xmw2bKeiYOl6oVnLHKxBA0VhA=="
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/marked/-/marked-4.1.0.tgz",
+      "integrity": "sha512-+Z6KDjSPa6/723PQYyc1axYZpYYpDnECDaU6hkaf5gqBieBkMKYReL5hteF2QizhlMbgbo8umXl/clZ67+GlsA==",
+      "dev": true
     },
     "memoizee": {
       "version": "0.4.15",
@@ -12279,9 +12509,9 @@
       "dev": true
     },
     "node-releases": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.5.tgz",
-      "integrity": "sha512-U9h1NLROZTq9uE1SNffn6WuPDg8icmi3ns4rEl/oTfIle4iLjTliCzgTsbaIFMq/Xn078/lfY/BL0GWZ+psK4Q==",
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.6.tgz",
+      "integrity": "sha512-PiVXnNuFm5+iYkLBNeq5211hvO38y63T0i2KKh2KnUs3RpzJ+JtODFjkD8yjLwnDkTYF1eKXheUwdssR+NRZdg==",
       "dev": true
     },
     "normalize-package-data": {
@@ -12317,6 +12547,12 @@
       "integrity": "sha512-JYOWTeFoS0Z93587vRJgASD5Ut11fYl5NyihP3KrYBvMe1FRRs6RN7m20SA/16GM4P6hTnZjT+UmDOt38UeXNg==",
       "dev": true
     },
+    "oauth": {
+      "version": "0.9.15",
+      "resolved": "https://registry.npmjs.org/oauth/-/oauth-0.9.15.tgz",
+      "integrity": "sha512-a5ERWK1kh38ExDEfoO6qUHJb32rd7aYmPHuyCu3Fta/cnICvYmgd2uhuKXvPD+PXB+gCEYYEaQdIRAjCOwAKNA==",
+      "dev": true
+    },
     "oauth-sign": {
       "version": "0.9.0",
       "resolved": "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.9.0.tgz",
@@ -12341,15 +12577,24 @@
       "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
       "dev": true
     },
+    "object-sizeof": {
+      "version": "1.6.3",
+      "resolved": "https://registry.npmjs.org/object-sizeof/-/object-sizeof-1.6.3.tgz",
+      "integrity": "sha512-LGtilAKuDGKCcvu1Xg3UvAhAeJJlFmblo3faltmOQ80xrGwAHxnauIXucalKdTEksHp/Pq9tZGz1hfyEmjFJPQ==",
+      "dev": true,
+      "requires": {
+        "buffer": "^5.6.0"
+      }
+    },
     "object.assign": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.2.tgz",
-      "integrity": "sha512-ixT2L5THXsApyiUPYKmW+2EHpXXe5Ii3M+f4e+aJFAHao5amFRW6J0OO6c/LU8Be47utCx2GL89hxGB6XSmKuQ==",
+      "version": "4.1.4",
+      "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.4.tgz",
+      "integrity": "sha512-1mxKf0e58bvyjSCtKYY4sRe9itRk3PJpquJOjeIkz885CczcI4IvJJDLPS72oowuSh+pBxUFROpX+TU++hxhZQ==",
       "dev": true,
       "requires": {
-        "call-bind": "^1.0.0",
-        "define-properties": "^1.1.3",
-        "has-symbols": "^1.0.1",
+        "call-bind": "^1.0.2",
+        "define-properties": "^1.1.4",
+        "has-symbols": "^1.0.3",
         "object-keys": "^1.1.1"
       }
     },
@@ -12400,6 +12645,7 @@
       "version": "1.4.0",
       "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
       "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+      "dev": true,
       "requires": {
         "wrappy": "1"
       }
@@ -12673,9 +12919,9 @@
       }
     },
     "psl": {
-      "version": "1.8.0",
-      "resolved": "https://registry.npmjs.org/psl/-/psl-1.8.0.tgz",
-      "integrity": "sha512-RIdOzyoavK+hA18OGGWDqUTsCLhtA7IcZ/6NCs4fFJaHBDab+pDDmDIByWFRQJq2Cd7r1OoQxBGKOaztq+hjIQ==",
+      "version": "1.9.0",
+      "resolved": "https://registry.npmjs.org/psl/-/psl-1.9.0.tgz",
+      "integrity": "sha512-E/ZsdU4HLs/68gYzgGTkMicWTLPdAftJLfJFlLUAAKZGkStNU72sZjT66SnMDVOfOWY/YAoiD7Jxa9iHvngcag==",
       "dev": true
     },
     "punycode": {
@@ -12696,6 +12942,12 @@
       "integrity": "sha512-qxXIEh4pCGfHICj1mAJQ2/2XVZkjCDTcEgfoSQxc/fYivUZxTkk7L3bDBJSoNrEzXI17oUO5Dp07ktqE5KzczA==",
       "dev": true
     },
+    "querystringify": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/querystringify/-/querystringify-2.2.0.tgz",
+      "integrity": "sha512-FIqgj2EUvTa7R50u0rGsyTftzjYmv/a3hO345bZNrqabNqjtgiDMgmo4mkUjd+nzU5oF3dClKqFIPUKybUyqoQ==",
+      "dev": true
+    },
     "queue-microtask": {
       "version": "1.2.3",
       "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
@@ -12748,9 +13000,9 @@
       }
     },
     "reduce-to-639-1": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/reduce-to-639-1/-/reduce-to-639-1-1.0.4.tgz",
-      "integrity": "sha512-cJjvufESvm1bzAvlLYsNPBz/ukcE5ydvrd4L17W3fcJUzveX7HzUwiM8ce33Ae8zsZVjj7ErUIw2oAAnvQJzZw=="
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/reduce-to-639-1/-/reduce-to-639-1-1.1.0.tgz",
+      "integrity": "sha512-9yy/xgTE8qPlZKQrQmyCU1Y1ZSnnOCP4K0Oe1YrBtteUmVXk0AgyINp0NS5kHGzZfpvjgHr6ygFZc9fpqf7moQ=="
     },
     "regexp-tree": {
       "version": "0.1.24",
@@ -12844,6 +13096,12 @@
       "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
       "dev": true
     },
+    "requires-port": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/requires-port/-/requires-port-1.0.0.tgz",
+      "integrity": "sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==",
+      "dev": true
+    },
     "resolve": {
       "version": "1.22.1",
       "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.1.tgz",
@@ -12910,9 +13168,9 @@
       }
     },
     "rollup": {
-      "version": "2.75.7",
-      "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.75.7.tgz",
-      "integrity": "sha512-VSE1iy0eaAYNCxEXaleThdFXqZJ42qDBatAwrfnPlENEZ8erQ+0LYX4JXOLPceWfZpV1VtZwZ3dFCuOZiSyFtQ==",
+      "version": "2.79.0",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.79.0.tgz",
+      "integrity": "sha512-x4KsrCgwQ7ZJPcFA/SUu6QVcYlO7uRLfLAy0DSA4NS2eG8japdbpM50ToH7z4iObodRYOJ0soneF0iaQRJ6zhA==",
       "dev": true,
       "requires": {
         "fsevents": "~2.3.2"
@@ -12988,6 +13246,7 @@
       "version": "0.10.1",
       "resolved": "https://registry.npmjs.org/shiki/-/shiki-0.10.1.tgz",
       "integrity": "sha512-VsY7QJVzU51j5o1+DguUd+6vmCmZ5v/6gYu4vyYAhzjuNQU6P/vmSy4uQaOhvje031qQMiW0d2BwgMH52vqMng==",
+      "dev": true,
       "requires": {
         "jsonc-parser": "^3.0.0",
         "vscode-oniguruma": "^1.6.1",
@@ -13083,9 +13342,9 @@
       }
     },
     "spdx-license-ids": {
-      "version": "3.0.11",
-      "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.11.tgz",
-      "integrity": "sha512-Ctl2BrFiM0X3MANYgj3CkygxhRmr9mi6xhejbdO960nF6EDJApTYpn0BQnDKlnNBULKiCN1n3w9EBkHK8ZWg+g==",
+      "version": "3.0.12",
+      "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.12.tgz",
+      "integrity": "sha512-rr+VVSXtRhO4OHbXUiAF7xW3Bo9DuuF6C5jH+q/x15j2jniycgKbxU09Hr0WqlSLUs4i4ltHGXqTe7VHclYWyA==",
       "dev": true
     },
     "sprintf-js": {
@@ -13298,9 +13557,9 @@
       }
     },
     "terser": {
-      "version": "5.14.1",
-      "resolved": "https://registry.npmjs.org/terser/-/terser-5.14.1.tgz",
-      "integrity": "sha512-+ahUAE+iheqBTDxXhTisdA8hgvbEG1hHOQ9xmNjeUJSoi6DU/gMrKNcfZjHkyY6Alnuyc+ikYJaxxfHkT3+WuQ==",
+      "version": "5.15.0",
+      "resolved": "https://registry.npmjs.org/terser/-/terser-5.15.0.tgz",
+      "integrity": "sha512-L1BJiXVmheAQQy+as0oF3Pwtlo4s3Wi1X2zNZ2NxOB4wx9bdS9Vk67XQENLFdLYGCK/Z2di53mTj/hBafR+dTA==",
       "dev": true,
       "requires": {
         "@jridgewell/source-map": "^0.3.2",
@@ -13310,9 +13569,9 @@
       },
       "dependencies": {
         "acorn": {
-          "version": "8.7.1",
-          "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.7.1.tgz",
-          "integrity": "sha512-Xx54uLJQZ19lKygFXOWsscKUbsBZW0CPykPhVQdhIeIwrbPmJzqeASDInc8nKBnp/JT6igTs82qPXz069H8I/A==",
+          "version": "8.8.0",
+          "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.8.0.tgz",
+          "integrity": "sha512-QOxyigPVrpZ2GXT+PFyZTl6TtOFc5egxHIP9IlQ+RbupQuX4RkT/Bee4/kQuC02Xkzg84JcT7oLYtDIQxp+v7w==",
           "dev": true
         },
         "commander": {
@@ -13411,20 +13670,21 @@
       }
     },
     "tough-cookie": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-4.0.0.tgz",
-      "integrity": "sha512-tHdtEpQCMrc1YLrMaqXXcj6AxhYi/xgit6mZu1+EDWUn+qhUf8wMQoFIy9NXuq23zAwtcB0t/MjACGR18pcRbg==",
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-4.1.2.tgz",
+      "integrity": "sha512-G9fqXWoYFZgTc2z8Q5zaHy/vJMjm+WV0AkAeHxVCQiEB1b+dGvWzFW6QV07cY5jQ5gRkeid2qIkzkxUnmoQZUQ==",
       "dev": true,
       "requires": {
         "psl": "^1.1.33",
         "punycode": "^2.1.1",
-        "universalify": "^0.1.2"
+        "universalify": "^0.2.0",
+        "url-parse": "^1.5.3"
       },
       "dependencies": {
         "universalify": {
-          "version": "0.1.2",
-          "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz",
-          "integrity": "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==",
+          "version": "0.2.0",
+          "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.2.0.tgz",
+          "integrity": "sha512-CJ1QgKmNg3CwvAv/kOFmtnEN05f0D/cn9QntgNOQlQF9dgvVTHj3t+8JPdjqawCHk7V/KA+fbUqzZ9XWhcqPUg==",
           "dev": true
         }
       }
@@ -13495,6 +13755,16 @@
       "integrity": "sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA==",
       "dev": true
     },
+    "twitter-api-client": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/twitter-api-client/-/twitter-api-client-1.6.1.tgz",
+      "integrity": "sha512-VkVDJzX0i6FC7CyZeeJluU1+bQ+8o5pwawgEjm7N5byaXF/cD9T4fzSzYX8y3ZhbwmkeUslYHQkquzQ2vigTmw==",
+      "dev": true,
+      "requires": {
+        "oauth": "^0.9.15",
+        "object-sizeof": "^1.6.1"
+      }
+    },
     "txt_tocfill": {
       "version": "0.5.1",
       "resolved": "https://registry.npmjs.org/txt_tocfill/-/txt_tocfill-0.5.1.tgz",
@@ -13541,6 +13811,7 @@
       "version": "0.22.18",
       "resolved": "https://registry.npmjs.org/typedoc/-/typedoc-0.22.18.tgz",
       "integrity": "sha512-NK9RlLhRUGMvc6Rw5USEYgT4DVAUFk7IF7Q6MYfpJ88KnTZP7EneEa4RcP+tX1auAcz7QT1Iy0bUSZBYYHdoyA==",
+      "dev": true,
       "requires": {
         "glob": "^8.0.3",
         "lunr": "^2.3.9",
@@ -13553,6 +13824,7 @@
           "version": "2.0.1",
           "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
           "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
+          "dev": true,
           "requires": {
             "balanced-match": "^1.0.0"
           }
@@ -13561,6 +13833,7 @@
           "version": "8.0.3",
           "resolved": "https://registry.npmjs.org/glob/-/glob-8.0.3.tgz",
           "integrity": "sha512-ull455NHSHI/Y1FqGaaYFaLGkNMMJbavMrEGFXG/PGrg6y7sutWHUHrz6gy6WEBH6akM1M414dWKCNs+IhKdiQ==",
+          "dev": true,
           "requires": {
             "fs.realpath": "^1.0.0",
             "inflight": "^1.0.4",
@@ -13573,6 +13846,7 @@
           "version": "5.1.0",
           "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.0.tgz",
           "integrity": "sha512-9TPBGGak4nHfGZsPBohm9AWg6NoT7QTCehS3BIJABslyZbzxfV78QM2Y6+i741OPZIafFAaiiEMh5OyIrJPgtg==",
+          "dev": true,
           "requires": {
             "brace-expansion": "^2.0.1"
           }
@@ -13583,12 +13857,14 @@
       "version": "0.23.0",
       "resolved": "https://registry.npmjs.org/typedoc-plugin-missing-exports/-/typedoc-plugin-missing-exports-0.23.0.tgz",
       "integrity": "sha512-9smahDSsFRno9ZwoEshQDuIYMHWGB1E6LUud5qMxR2wNZ0T4DlZz0QjoK3HzXtX34mUpTH0dYtt7NQUK4D6B6Q==",
+      "dev": true,
       "requires": {}
     },
     "typescript": {
       "version": "4.7.4",
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.7.4.tgz",
-      "integrity": "sha512-C0WQT0gezHuw6AdY1M2jxUO83Rjf0HP7Sk1DtXj6j1EwkQNZrHAg2XPWlq62oqEhYvONq5pkC2Y9oPljWToLmQ=="
+      "integrity": "sha512-C0WQT0gezHuw6AdY1M2jxUO83Rjf0HP7Sk1DtXj6j1EwkQNZrHAg2XPWlq62oqEhYvONq5pkC2Y9oPljWToLmQ==",
+      "dev": true
     },
     "typical": {
       "version": "2.6.1",
@@ -13615,9 +13891,9 @@
       "dev": true
     },
     "update-browserslist-db": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.4.tgz",
-      "integrity": "sha512-jnmO2BEGUjsMOe/Fg9u0oczOe/ppIDZPebzccl1yDWGLFP16Pa1/RM5wEoKYPG2zstNcDuAStejyxsOuKINdGA==",
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.6.tgz",
+      "integrity": "sha512-We7BqM9XFlcW94Op93uW8+2LXvGezs7QA0WY+f1H7RR1q46B06W6hZF6LbmOlpCS1HU22q/6NOGTGW5sCm7NJQ==",
       "dev": true,
       "requires": {
         "escalade": "^3.1.1",
@@ -13633,6 +13909,16 @@
         "punycode": "^2.1.0"
       }
     },
+    "url-parse": {
+      "version": "1.5.10",
+      "resolved": "https://registry.npmjs.org/url-parse/-/url-parse-1.5.10.tgz",
+      "integrity": "sha512-WypcfiRhfeUP9vvF0j6rw0J3hrWrw6iZv3+22h6iRMJ/8z1Tj6XfLP4DsUix5MhMPnXpiHDoKyoZ/bdCkwBCiQ==",
+      "dev": true,
+      "requires": {
+        "querystringify": "^2.1.1",
+        "requires-port": "^1.0.0"
+      }
+    },
     "uuid": {
       "version": "3.4.0",
       "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.4.0.tgz",
@@ -13688,12 +13974,14 @@
     "vscode-oniguruma": {
       "version": "1.6.2",
       "resolved": "https://registry.npmjs.org/vscode-oniguruma/-/vscode-oniguruma-1.6.2.tgz",
-      "integrity": "sha512-KH8+KKov5eS/9WhofZR8M8dMHWN2gTxjMsG4jd04YhpbPR91fUj7rYQ2/XjeHCJWbg7X++ApRIU9NUwM2vTvLA=="
+      "integrity": "sha512-KH8+KKov5eS/9WhofZR8M8dMHWN2gTxjMsG4jd04YhpbPR91fUj7rYQ2/XjeHCJWbg7X++ApRIU9NUwM2vTvLA==",
+      "dev": true
     },
     "vscode-textmate": {
       "version": "5.2.0",
       "resolved": "https://registry.npmjs.org/vscode-textmate/-/vscode-textmate-5.2.0.tgz",
-      "integrity": "sha512-Uw5ooOQxRASHgu6C7GVvUxisKXfSgW4oFlO+aa+PAkgmH89O3CXxEEzNRNtHSqtXFTl0nAC1uYj0GMSH27uwtQ=="
+      "integrity": "sha512-Uw5ooOQxRASHgu6C7GVvUxisKXfSgW4oFlO+aa+PAkgmH89O3CXxEEzNRNtHSqtXFTl0nAC1uYj0GMSH27uwtQ==",
+      "dev": true
     },
     "w3c-hr-time": {
       "version": "1.0.2",
@@ -13796,7 +14084,8 @@
     "wrappy": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
-      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="
+      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
+      "dev": true
     },
     "write-file-atomic": {
       "version": "3.0.3",
@@ -13811,9 +14100,9 @@
       }
     },
     "ws": {
-      "version": "7.5.8",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-7.5.8.tgz",
-      "integrity": "sha512-ri1Id1WinAX5Jqn9HejiGb8crfRio0Qgu8+MtL36rlTA6RLsMdWt1Az/19A2Qij6uSHUMphEFaTKa4WG+UNHNw==",
+      "version": "7.5.9",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-7.5.9.tgz",
+      "integrity": "sha512-F+P9Jil7UiSKSkppIiD94dN07AwvFixvLIj1Og1Rl9GGMuNipJnV9JzjD6XuqmAeiswGvUmNLjr5cFuXwNS77Q==",
       "dev": true,
       "requires": {}
     },
diff --git a/package.json b/package.json
index d4d880ea..3544fa0f 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "jssm",
-  "version": "5.77.0",
+  "version": "5.87.0",
   "engines": {
     "node": ">=10.0.0"
   },
@@ -28,13 +28,19 @@
   "browser": "dist/jssm.es5.iife.js",
   "types": "./jssm.d.ts",
   "scripts": {
+    "jest-unicode-action": "jest unicode-actions.uspec.ts -c jest-unicode.config.js --color --verbose",
+    "jest-unicode-string": "jest unicode-strings.uspec.ts -c jest-unicode.config.js --color --verbose",
+    "jest-unicode-atom": "jest unicode-atoms.uspec.ts -c jest-unicode.config.js --color --verbose",
+    "jest-unicode-string-label": "jest unicode-atoms.uspec.ts -c jest-unicode.config.js --color --verbose",
+    "jest-unicode-atom-label": "jest unicode-atoms.uspec.ts -c jest-unicode.config.js --color --verbose",
+    "jest-unicode-full-slow": "npm run jest-unicode-atom && npm run jest-unicode-string && npm run jest-unicode-atom-label && npm run jest-unicode-string-label && jest-unicode-action",
     "jest-stoch": "jest -c jest-stoch.config.js --color --verbose",
     "jest-dragon": "jest -c jest-dragon.config.js --color --verbose",
     "jest-spec": "jest -c jest-spec.config.js --color --verbose",
-    "jest": "npm run jest-spec",
+    "jest": "npm run jest-stoch && npm run jest-spec",
     "test": "npm run make && npm run jest",
-    "clean": "rm -rf dist && rm -rf docs && cd coverage && rm -rf cloc && cd .. && rm -f src/ts/jssm-dot.ts && rm -f src/ts/version.ts && rm -f *.d.ts && mkdir dist && cd dist && mkdir deno && cd .. && mkdir docs && cd coverage && mkdir cloc && cd ..",
-    "peg": "rm -f src/ts/jssm-dot.js && pegjs src/ts/jssm-dot.peg && node src/buildjs/fixparser.js && rm src/ts/jssm-dot.js",
+    "clean": "rm -rf dist && rm -rf docs && cd coverage && rm -rf cloc && cd .. && rm -f src/ts/fsl_parser.ts && rm -f src/ts/version.ts && rm -f *.d.ts && mkdir dist && mkdir docs && cd coverage && mkdir cloc && cd ..",
+    "peg": "rm -f src/ts/fsl_parser.js && pegjs src/ts/fsl_parser.peg && node src/buildjs/fixparser.js",
     "make_cjs": "rollup -c",
     "make_iife": "rollup -c rollup.config.iife.js",
     "make_deno": "rollup -c rollup.config.deno.js",
@@ -49,7 +55,7 @@
     "clean_bench": "npm run test && npm run benny",
     "qbuild": "npm run test",
     "ci_build": "npm run vet && npm run test",
-    "minify": "mv dist/es6/jssm-dot.js dist/es6/jssm-dot.nonmin.js && terser dist/es6/jssm-dot.nonmin.js > dist/es6/jssm-dot.js",
+    "minify": "mv dist/es6/fsl_parser.js dist/es6/fsl_parser.nonmin.js && terser dist/es6/fsl_parser.nonmin.js > dist/es6/fsl_parser.js",
     "min_iife": "mv dist/jssm.es5.iife.js dist/jssm.es5.iife.nonmin.js && terser dist/jssm.es5.iife.nonmin.js > dist/jssm.es5.iife.js",
     "min_cjs": "mv dist/jssm.es5.cjs.js dist/jssm.es5.cjs.nonmin.js && terser dist/jssm.es5.cjs.nonmin.js > dist/jssm.es5.cjs.js",
     "site": "cp src/site/* docs/ && cp -r src/assets docs/assets/",
@@ -109,6 +115,7 @@
     "@typescript-eslint/eslint-plugin": "^5.30.4",
     "@typescript-eslint/parser": "^5.30.4",
     "benny": "^3.7.1",
+    "chalk": "^4.1.2",
     "cloc": "^2.10.0",
     "coveralls": "^3.0.11",
     "eslint": "^7.32.0",
@@ -124,17 +131,18 @@
     "pegjs": "^0.10.0",
     "rollup": "^2.72.1",
     "semver": "^5.7.1",
-    "terser": "^5.13.1",
+    "terser": "^5.14.2",
     "text_audit": "^0.9.3",
     "ts-jest": "^27.0.7",
+    "twitter-api-client": "^1.6.0",
     "typedoc": "^0.22.18",
+    "typedoc-plugin-missing-exports": "^0.23.0",
     "typescript": "^4.7.4",
     "xml2js": "^0.4.23"
   },
   "dependencies": {
+    "reduce-to-639-1": "^1.1.0",
     "better_git_changelog": "^1.6.1",
-    "circular_buffer_js": "^1.10.0",
-    "reduce-to-639-1": "^1.0.4",
-    "typedoc-plugin-missing-exports": "^0.23.0"
+    "circular_buffer_js": "^1.10.0"
   }
 }
diff --git a/rollup.config.iife.js b/rollup.config.iife.js
index 197db84d..28c90296 100644
--- a/rollup.config.iife.js
+++ b/rollup.config.iife.js
@@ -3,7 +3,6 @@ import nodeResolve from '@rollup/plugin-node-resolve';
 import commonjs    from '@rollup/plugin-commonjs';
 import replace     from '@rollup/plugin-replace';
 
-const pkg = require('./package.json');
 
 
 
diff --git a/src/buildjs/benchmark.js b/src/buildjs/benchmark.js
index 1265a994..6b4f77de 100644
--- a/src/buildjs/benchmark.js
+++ b/src/buildjs/benchmark.js
@@ -401,6 +401,24 @@ function KitchenSink100Times() {
 
 
 
+function CompileTrivialABStringUsingSm() {
+  const ab = sm`a -> b;`;
+  if (ab === undefined) { throw 'not defined!'; }  // prevent removal through shaking
+}
+
+
+
+
+
+function CompileTrivialABStringUsingFrom() {
+  const ab = jssm.from('a -> b;');
+  if (ab === undefined) { throw 'not defined!'; }  // prevent removal through shaking
+}
+
+
+
+
+
 b.suite('General performance suite',
 
   b.add('Blind cycle a traffic light 100 times by transition',                 TransitionCycleTL100Times                       ),
@@ -424,6 +442,8 @@ b.suite('General performance suite',
   b.add('Blind cycle a main transition tl 100 times by action',                ActionCycleTLWithMTHooks100Times                ),
   b.add('Blind cycle a forced transition tl 100 times by action',              ActionCycleTLWithFTHooks100Times                ),
   b.add('Kitchen Sink 100 times',                                              KitchenSink100Times                             ),
+  b.add('Compile `a -> b;` using sm',                                          CompileTrivialABStringUsingSm                   ),
+  b.add('Compile `a -> b;` using .from',                                       CompileTrivialABStringUsingFrom                 ),
 
   b.cycle(),
   b.complete(),
diff --git a/src/buildjs/build_util.js b/src/buildjs/build_util.js
new file mode 100644
index 00000000..0460b421
--- /dev/null
+++ b/src/buildjs/build_util.js
@@ -0,0 +1,6 @@
+
+
+
+module.exports = {
+
+};
diff --git a/src/buildjs/fixparser.js b/src/buildjs/fixparser.js
index 980e44a6..56f50ee5 100644
--- a/src/buildjs/fixparser.js
+++ b/src/buildjs/fixparser.js
@@ -6,11 +6,12 @@
 // then add the es6 module one we have
 // then save under the other filename
 
-const fs = require('fs');
+const fs         = require('fs'),
+      orig_fname = './src/ts/fsl_parser.js';
 
-const orig  = fs.readFileSync('./src/ts/jssm-dot.js'),
-      lines = `${orig}`.split('\n'),
-      tail  = fs.readFileSync('src/buildjs/peg_ts_export_footer.ts');
+const orig       = fs.readFileSync(orig_fname),
+      lines      = `${orig}`.split('\n'),
+      tail       = fs.readFileSync('src/buildjs/peg_ts_export_footer.ts');
 
 lines.pop();  // shut up, it's funny
 lines.pop();
@@ -18,4 +19,5 @@ lines.pop();
 lines.pop();
 lines.pop();
 
-fs.writeFileSync('./src/ts/jssm-dot.ts', lines.join('\n') + tail);
+fs.writeFileSync('./src/ts/fsl_parser.ts', lines.join('\n') + tail);
+fs.unlinkSync(orig_fname);
diff --git a/src/buildjs/make_code_quality_report.js b/src/buildjs/make_code_quality_report.js
new file mode 100644
index 00000000..5ce3626d
--- /dev/null
+++ b/src/buildjs/make_code_quality_report.js
@@ -0,0 +1,4 @@
+
+const fs = require('fs');
+
+
diff --git a/src/buildjs/make_readme.js b/src/buildjs/make_readme.js
index 3e783cb3..ff7ef751 100644
--- a/src/buildjs/make_readme.js
+++ b/src/buildjs/make_readme.js
@@ -37,20 +37,20 @@ async function bulk() {
         run_count     = spec_metrics.tests.success + (stoch_metrics.tests.success * 100),
 
         warning       = fs.readFileSync('./src/md/generated-file-warning.txt').toString(),
-        warning_wf    = warning.replaceAll('{{real_source}}', './src/md/readme_base.md'),
-        warning_wd    = warning_wf.replaceAll('{{datetime}}', new Date().toLocaleString()),
-        warning_wv    = warning_wd.replaceAll('{{build}}', package.version),
+        warning_wf    = warning.replace(/{{real_source}}/g, './src/md/readme_base.md'),
+        warning_wd    = warning_wf.replace(/{{datetime}}/g, new Date().toLocaleString()),
+        warning_wv    = warning_wd.replace(/{{build}}/g, package.version),
 
         readme_base   = fs.readFileSync('./src/md/README_base.md').toString(),
-        readme_tests  = readme_base.replaceAll('{{test_count}}', tot_count.toLocaleString()),
-        readme_runs   = readme_tests.replaceAll('{{run_count}}', run_count.toLocaleString()),
-        readme_spec   = readme_runs.replaceAll('{{spec_count}}', spec_metrics.tests.success.toLocaleString()),
-        readme_specc  = readme_spec.replaceAll('{{spec_coverage}}', get_coverage_pct(spec_json.coverage.project[0].metrics[0]['$'])),
-        readme_stoch  = readme_specc.replaceAll('{{stoch_count}}', stoch_metrics.tests.success.toLocaleString()),
-        readme_stochc = readme_stoch.replaceAll('{{stoch_coverage}}', get_coverage_pct(stoch_json.coverage.project[0].metrics[0]['$'])),
-        readme_lines  = readme_stochc.replaceAll('{{line_count}}', lines.toLocaleString()),
-        readme_ratio  = readme_lines.replaceAll('{{line_test_ratio}}', (tot_count / lines).toFixed(1)),
-        readme_rratio = readme_ratio.replaceAll('{{line_run_ratio}}', (run_count / lines).toFixed(1));
+        readme_tests  = readme_base.replace(/{{test_count}}/g, tot_count.toLocaleString()),
+        readme_runs   = readme_tests.replace(/{{run_count}}/g, run_count.toLocaleString()),
+        readme_spec   = readme_runs.replace(/{{spec_count}}/g, spec_metrics.tests.success.toLocaleString()),
+        readme_specc  = readme_spec.replace(/{{spec_coverage}}/g, get_coverage_pct(spec_json.coverage.project[0].metrics[0]['$'])),
+        readme_stoch  = readme_specc.replace(/{{stoch_count}}/g, stoch_metrics.tests.success.toLocaleString()),
+        readme_stochc = readme_stoch.replace(/{{stoch_coverage}}/g, get_coverage_pct(stoch_json.coverage.project[0].metrics[0]['$'])),
+        readme_lines  = readme_stochc.replace(/{{line_count}}/g, lines.toLocaleString()),
+        readme_ratio  = readme_lines.replace(/{{line_test_ratio}}/g, (tot_count / lines).toFixed(1)),
+        readme_rratio = readme_ratio.replace(/{{line_run_ratio}}/g, (run_count / lines).toFixed(1));
 
   fs.writeFileSync('./README.md', warning_wv + readme_rratio);
 
diff --git a/src/buildjs/makever.js b/src/buildjs/makever.js
index 2f28c8e8..aa9b1ec0 100644
--- a/src/buildjs/makever.js
+++ b/src/buildjs/makever.js
@@ -4,6 +4,8 @@ const fs = require('fs');
 const package = JSON.parse(fs.readFileSync('package.json'));
 
 fs.writeFileSync('./src/ts/version.ts', `
-const version: string = "${package.version}";
-export { version };
+const version    : string = "${package.version}",
+      build_time : number = ${new Date().getTime()};
+
+export { version, build_time };
 `);
diff --git a/src/buildjs/tweet.js b/src/buildjs/tweet.js
new file mode 100644
index 00000000..7ed08b15
--- /dev/null
+++ b/src/buildjs/tweet.js
@@ -0,0 +1,92 @@
+
+const { spawnSync }    = require('child_process'),
+      { readFileSync } = require('fs');
+
+const chalk             = require('chalk'),
+      { TwitterClient } = require('twitter-api-client');
+
+const blue = chalk.blueBright,
+      cyan = chalk.cyanBright;
+
+const package = JSON.parse( readFileSync('./package.json') );
+
+const tag            = package.version, // spawnSync(`awk -F'"' '/"version": ".+"/{ print $4; exit; }' package.json`),
+      commit_message = handle_cmsg(process.env['TW_COMMIT_MESSAGE']);
+
+console.log('found:');
+console.log(tag);
+console.log(commit_message);
+
+
+
+
+
+// comes in as
+//   1: "Merge pull request #foo from\n\nActual text we want"
+//   2: "Merge pull request #foo from\n\nActual text we want\n\nMore stuff to ignore"
+
+function handle_cmsg(cmsg) {
+
+  const parsable = cmsg
+                     .replace('\r', '\n')
+                     .split('\n')
+                     .filter(s => s !== '');
+
+  // we almost certainly want 1, but if missing, fall back to merge notice in 0
+  return parsable[1] ?? (parsable[0] ?? '');
+
+}
+
+
+
+
+
+const tweet = async (status) => {
+
+  const twitterClient = new TwitterClient({
+    apiKey            : process.env.JSSM_TWITTER_API_KEY,
+    apiSecret         : process.env.JSSM_TWITTER_API_SECRET,
+    accessToken       : process.env.JSSM_TWITTER_API_ACCESS_TOKEN,
+    accessTokenSecret : process.env.JSSM_TWITTER_ACCESS_TOKEN_SECRET,
+  });
+
+  await twitterClient.tweets.statusesUpdate({status});
+
+};
+
+
+
+
+
+(async () => {
+
+
+  const makeTweet = fromText => {
+
+    const cap      = 280,
+          addendum = ' #fsl #fsm #jssm #state #statemachine 🤖',
+          alen     = addendum.length,
+          mlen     = cap - alen,
+          pref     = fromText.length > mlen? (fromText.substring(0, mlen-1) + '…') : fromText;
+
+    return pref + addendum;
+
+  };
+
+
+
+  const the_tweet = makeTweet(`Released ${tag} - ${commit_message}`);
+
+  try {
+
+    console.log(`${blue('Tweeting ')}${cyan(process.argv[2])}`);
+    await tweet(the_tweet);
+
+  } catch (err) {
+
+    console.error(err);
+
+  }
+
+
+})();
diff --git a/src/doc_md/CHANGELOG.long.md b/src/doc_md/CHANGELOG.long.md
index 4b158e26..83d7ebec 100644
--- a/src/doc_md/CHANGELOG.long.md
+++ b/src/doc_md/CHANGELOG.long.md
@@ -2,7 +2,7 @@
 
 All notable changes to this project will be documented in this file.
 
-961 merges; 129 releases
+1076 merges; 178 releases
 
 
 
@@ -12,7 +12,7 @@ All notable changes to this project will be documented in this file.
 
 Published tags:
 
-5.76.2, 5.76.0, 5.75.1, 5.75.0, 5.74.0, 5.73.1, 5.73.0, 5.72.5, 5.72.4, 5.72.3, 5.72.2, 5.72.1, 5.72.0, 5.71.1, 5.71.0, 5.70.36, 5.70.35, 5.70.34, 5.70.33, 5.70.32, 5.70.31, 5.70.30, 5.70.29, 5.70.28, 5.70.27, 5.70.26, 5.70.25, 5.70.24, 5.70.23, 5.70.22, 5.70.21, 5.70.20, 5.70.19, 5.70.18, 5.70.16, 5.70.15, 5.70.14, 5.70.13, 5.70.12, 5.70.11, 5.70.10, 5.70.9, 5.70.8, 5.70.7, 5.70.6, 5.70.5, 5.70.4, 5.70.3, 5.70.2, 5.70.1, 5.70.0, 5.69.4, 5.69.3, 5.69.2, 5.69.0, 5.68.0, 5.67.2, 5.67.0, 5.66.0, 5.65.14, 5.65.12, 5.65.11, 5.65.10, 5.65.9, 5.65.8, 5.65.7, 5.65.5, 5.65.4, 5.65.3, 5.65.2, 5.65.1, 5.65.0, 5.64.2, 5.64.1, 5.64.0, 5.63.0, 5.62.0, 5.61.4, 5.61.3, 5.61.2, 5.61.1, 5.60.4, 5.60.3, 5.60.0, 5.59.1, 5.59.0, 5.58.1, 5.58.0, 5.57.1, 5.57.0, 5.56.2, 5.56.1, 5.55.0, 5.54.0, 5.53.0, 5.52.0, 5.51.0, 5.50.0, 5.49.0, 5.48.0, 5.47.0, 5.46.0, 5.45.2, 5.45.0, 5.44.0, 5.43.2, v5.42.0, 5.42.0, v5.41.15, 5.41.15, v5.41.14, 5.41.14, v5.41.12, 5.41.12, v5.41.10, 5.41.10, v5.41.9, 5.41.9, v5.41.8, 5.41.8, v5.41.7, v5.41.2, v5.41.1, v5.32.14, 5.14.0, 5.12.0, 5.11.12, 5.11.1, 5.11.0
+5.87.0, 5.86.3, 5.86.2, 5.86.1, 5.86.0, 5.85.11, 5.85.10, 5.85.9, 5.85.8, 5.85.7, 5.85.6, 5.85.5, 5.85.4, 5.85.3, 5.85.2, 5.85.1, 5.85.0, 5.84.1, 5.84.0, 5.83.2, 5.83.1, 5.83.0, 5.82.5, 5.82.4, 5.82.3, 5.82.2, 5.82.1, 5.82.0, 5.81.2, 5.81.0, 5.80.1, 5.80.0, 5.79.18, 5.79.17, 5.79.16, 5.79.15, 5.79.11, 5.79.10, 5.79.9, 5.79.8, 5.79.6, 5.79.4, 5.79.3, 5.79.2, 5.79.1, 5.79.0, 5.78.0, 5.77.1, 5.77.0, 5.76.2, 5.76.0, 5.75.1, 5.75.0, 5.74.0, 5.73.1, 5.73.0, 5.72.5, 5.72.4, 5.72.3, 5.72.2, 5.72.1, 5.72.0, 5.71.1, 5.71.0, 5.70.36, 5.70.35, 5.70.34, 5.70.33, 5.70.32, 5.70.31, 5.70.30, 5.70.29, 5.70.28, 5.70.27, 5.70.26, 5.70.25, 5.70.24, 5.70.23, 5.70.22, 5.70.21, 5.70.20, 5.70.19, 5.70.18, 5.70.16, 5.70.15, 5.70.14, 5.70.13, 5.70.12, 5.70.11, 5.70.10, 5.70.9, 5.70.8, 5.70.7, 5.70.6, 5.70.5, 5.70.4, 5.70.3, 5.70.2, 5.70.1, 5.70.0, 5.69.4, 5.69.3, 5.69.2, 5.69.0, 5.68.0, 5.67.2, 5.67.0, 5.66.0, 5.65.14, 5.65.12, 5.65.11, 5.65.10, 5.65.9, 5.65.8, 5.65.7, 5.65.5, 5.65.4, 5.65.3, 5.65.2, 5.65.1, 5.65.0, 5.64.2, 5.64.1, 5.64.0, 5.63.0, 5.62.0, 5.61.4, 5.61.3, 5.61.2, 5.61.1, 5.60.4, 5.60.3, 5.60.0, 5.59.1, 5.59.0, 5.58.1, 5.58.0, 5.57.1, 5.57.0, 5.56.2, 5.56.1, 5.55.0, 5.54.0, 5.53.0, 5.52.0, 5.51.0, 5.50.0, 5.49.0, 5.48.0, 5.47.0, 5.46.0, 5.45.2, 5.45.0, 5.44.0, 5.43.2, v5.42.0, 5.42.0, v5.41.15, 5.41.15, v5.41.14, 5.41.14, v5.41.12, 5.41.12, v5.41.10, 5.41.10, v5.41.9, 5.41.9, v5.41.8, 5.41.8, v5.41.7, v5.41.2, v5.41.1, v5.32.14, 5.14.0, 5.12.0, 5.11.12, 5.11.1, 5.11.0
 
 
 
@@ -22,18 +22,2246 @@ Published tags:
 
  
 
-
+
+
+## [5.87.0] - 12/3/2022 8:18:35 PM
+
+Commit [85963d8c154225916ec9bf1f494c480ca033dec9](https://github.com/StoneCypher/jssm/commit/85963d8c154225916ec9bf1f494c480ca033dec9)
+
+Author: `John Haugeland `
+
+Merges [dbb82ae, d6f77d1]
+
+  * Merge pull request #549 from StoneCypher/next_data
+  * Next data
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 12/3/2022 7:40:06 PM
+
+Commit [d6f77d1be4cf107f2eda1cfddca81d4ebcfc7c99](https://github.com/StoneCypher/jssm/commit/d6f77d1be4cf107f2eda1cfddca81d4ebcfc7c99)
+
+Author: `John Haugeland `
+
+  * forgot version bump
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 12/3/2022 7:32:06 PM
+
+Commit [e6227e3d26828277c002ff0dd67899ab89771fc2](https://github.com/StoneCypher/jssm/commit/e6227e3d26828277c002ff0dd67899ab89771fc2)
+
+Author: `John Haugeland `
+
+  * next_data, fixes StoneCypher/fsl#1233
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 12/2/2022 10:48:55 PM
+
+Commit [5fa6e48645cb75fcd5fe38e6ff08c0d5d64a7a23](https://github.com/StoneCypher/jssm/commit/5fa6e48645cb75fcd5fe38e6ff08c0d5d64a7a23)
+
+Author: `John Haugeland `
+
+  * nextData underway
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.86.3] - 11/12/2022 6:09:16 PM
+
+Commit [dbb82aefc2744729fd17108d33d19f504dc1783e](https://github.com/StoneCypher/jssm/commit/dbb82aefc2744729fd17108d33d19f504dc1783e)
+
+Author: `John Haugeland `
+
+  * Implement override, implement in machine, allow override attribute
+  * Fixes StoneCypher/fsl#1228, fixes StoneCypher/fsl#1222, fixes StoneCypher/fsl#1232
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.86.2] - 11/12/2022 12:49:23 PM
+
+Commit [a033eb38e784cbc5c6bf15bef576b69bb935f9b2](https://github.com/StoneCypher/jssm/commit/a033eb38e784cbc5c6bf15bef576b69bb935f9b2)
+
+Author: `John Haugeland `
+
+Merges [48b4f92, 99a5fd6]
+
+  * Merge pull request #548 from StoneCypher/AllowsOverrideInCompiler
+  * allows override in compiler, constructor config to allow/disallow override, getters for override, cfg override, machine override
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 11/12/2022 12:44:20 PM
+
+Commit [99a5fd66ee5a342814cf34d89fb6dccc2f4ac7e9](https://github.com/StoneCypher/jssm/commit/99a5fd66ee5a342814cf34d89fb6dccc2f4ac7e9)
+
+Author: `John Haugeland `
+
+  * allows override in compiler, constructor config to allow/disallow override, getters for override, cfg override, machine override
+  * fixes StoneCypher/fsl#1225, fixes StoneCypher/fsl#1227, fixes StoneCypher/fsl#1229, fixes StoneCypher/fsl#1230, fixes StoneCypher/fsl#1231
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.86.1] - 11/11/2022 6:41:15 PM
+
+Commit [48b4f928eb1a4597122b64e6eea38a57c19a112f](https://github.com/StoneCypher/jssm/commit/48b4f928eb1a4597122b64e6eea38a57c19a112f)
+
+Author: `John Haugeland `
+
+  * Allow override attribute in grammar, fixes StoneCypher/fsl#1226
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.86.0] - 11/11/2022 6:22:48 PM
+
+Commit [31077c9256ee31f80398460b3af95bc65a8dbc3a](https://github.com/StoneCypher/jssm/commit/31077c9256ee31f80398460b3af95bc65a8dbc3a)
+
+Author: `John Haugeland `
+
+Merges [793f2fc, 3941c30]
+
+  * Merge pull request #547 from StoneCypher/allows_override
+  * .allows_override fixes StoneCypher/fsl#1224
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 11/11/2022 6:16:32 PM
+
+Commit [3941c3000e8544e6b674b4a060abb93a8f5c3455](https://github.com/StoneCypher/jssm/commit/3941c3000e8544e6b674b4a060abb93a8f5c3455)
+
+Author: `John Haugeland `
+
+  * .allows_override fixes StoneCypher/fsl#1224
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.85.11] - 9/16/2022 11:15:38 PM
+
+Commit [793f2fcba840f39cb7442f6be54b0c272caad6ba](https://github.com/StoneCypher/jssm/commit/793f2fcba840f39cb7442f6be54b0c272caad6ba)
+
+Author: `John Haugeland `
+
+Merges [ab43e02, 03790c9]
+
+  * Merge pull request #546 from StoneCypher/uses_forced_transitions
+  * Adds getter method uses_forced_transitions
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/16/2022 11:15:13 PM
+
+Commit [03790c9fc38db0ed5cb0ba35d50c4d5d820aafcc](https://github.com/StoneCypher/jssm/commit/03790c9fc38db0ed5cb0ba35d50c4d5d820aafcc)
+
+Author: `John Haugeland `
+
+  * Adds getter method uses_forced_transitions
+  * Fixes StoneCypher/fsl#1211
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.85.10] - 9/16/2022 5:34:40 PM
+
+Commit [ab43e02152256d19579efdb73c9fa6cb04d1b2b3](https://github.com/StoneCypher/jssm/commit/ab43e02152256d19579efdb73c9fa6cb04d1b2b3)
+
+Author: `John Haugeland `
+
+Merges [c0c574b, a6026d0]
+
+  * Merge pull request #545 from StoneCypher/PullThemesOutIntoModule
+  * Pull themes out into module
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/16/2022 5:30:09 PM
+
+Commit [a6026d0bdbec44c03303950130ed34df3a78576e](https://github.com/StoneCypher/jssm/commit/a6026d0bdbec44c03303950130ed34df3a78576e)
+
+Author: `John Haugeland `
+
+  * Pull themes out into module
+  * Fixes StoneCypher/fsl#1210
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.85.9] - 9/12/2022 9:15:59 PM
+
+Commit [c0c574b694f1d0511190be139135cdf745f476b7](https://github.com/StoneCypher/jssm/commit/c0c574b694f1d0511190be139135cdf745f476b7)
+
+Author: `John Haugeland `
+
+Merges [c047caa, 090db83]
+
+  * Merge pull request #544 from StoneCypher/PullCompilerOutIntoModule
+  * Pull compiler out into a module
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/12/2022 9:06:27 PM
+
+Commit [090db831d8df370b0937d2d37e6372b6df030481](https://github.com/StoneCypher/jssm/commit/090db831d8df370b0937d2d37e6372b6df030481)
+
+Author: `John Haugeland `
+
+  * Pull compiler out into a module
+  * Fixes StoneCypher/fsl#1207
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.85.8] - 9/12/2022 8:26:10 PM
+
+Commit [c047caac3f9d9bb24a9c0b517983088eb8ee2e4a](https://github.com/StoneCypher/jssm/commit/c047caac3f9d9bb24a9c0b517983088eb8ee2e4a)
+
+Author: `John Haugeland `
+
+Merges [581fd8d, 013999a]
+
+  * Merge pull request #543 from StoneCypher/PullArrowsOutIntoModules
+  * Pull arrows out into modules
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/12/2022 8:18:05 PM
+
+Commit [013999a77ce43ceed5eb982754ffe480fdddf159](https://github.com/StoneCypher/jssm/commit/013999a77ce43ceed5eb982754ffe480fdddf159)
+
+Author: `John Haugeland `
+
+  * Pull arrows out into modules
+  * Fixes StoneCypher/fsl#1206
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.85.7] - 9/12/2022 7:24:25 PM
+
+Commit [581fd8dc33c4eb2ce190b696d952471abec192ef](https://github.com/StoneCypher/jssm/commit/581fd8dc33c4eb2ce190b696d952471abec192ef)
+
+Author: `John Haugeland `
+
+Merges [7d741ba, 771f4c8]
+
+  * Merge pull request #542 from StoneCypher/AddUnicodeTestsForLabels
+  * Add unicode tests for labels
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/12/2022 7:19:21 PM
+
+Commit [771f4c8d67274b40451ae6dfef168fe3c15949df](https://github.com/StoneCypher/jssm/commit/771f4c8d67274b40451ae6dfef168fe3c15949df)
+
+Author: `John Haugeland `
+
+  * Add tests for unicode labels (atom and string)
+  * Fixes StoneCypher/fsl#1193, fixes StoneCypher/fsl#1194
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/12/2022 6:52:26 PM
+
+Commit [3eb246ddb992372ceca4c0adc9dc45295a0a7177](https://github.com/StoneCypher/jssm/commit/3eb246ddb992372ceca4c0adc9dc45295a0a7177)
+
+Author: `John Haugeland `
+
+  * Return twitter envvar to GHA yaml
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/12/2022 6:52:26 PM
+
+Commit [3a01b8d7ae2cee185e4f36c90a95338bf30002cb](https://github.com/StoneCypher/jssm/commit/3a01b8d7ae2cee185e4f36c90a95338bf30002cb)
+
+Author: `John Haugeland `
+
+  * that wasn't supposed to be removed...
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.85.6] - 9/12/2022 6:43:57 PM
+
+Commit [7d741ba17ccee77138537f732b833efa028dbda7](https://github.com/StoneCypher/jssm/commit/7d741ba17ccee77138537f732b833efa028dbda7)
+
+Author: `John Haugeland `
+
+Merges [4b9fefd, 37c0bdf]
+
+  * Merge pull request #541 from StoneCypher/StartStateRefining
+  * Prevent request of illegal state as start state
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/12/2022 6:39:19 PM
+
+Commit [37c0bdf33263bf4b9dd60ba329108297cf5ea68f](https://github.com/StoneCypher/jssm/commit/37c0bdf33263bf4b9dd60ba329108297cf5ea68f)
+
+Author: `John Haugeland `
+
+  * Prevent request of illegal state as start state
+  * Fixes StoneCypher/fsl#1203, fixes StoneCypher/fsl#1204, fixes StoneCypher/fsl#1205
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/12/2022 3:27:58 PM
+
+Commit [4b9fefde004f1c1ac5f36ad760105109475af95a](https://github.com/StoneCypher/jssm/commit/4b9fefde004f1c1ac5f36ad760105109475af95a)
+
+Author: `John Haugeland `
+
+  * expose build date directly on module (also -viz and -demo,) support logging in -demo
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.85.5] - 9/12/2022 3:10:10 PM
+
+Commit [35ad7228d5bb15d963a2e4d9e6e35721cce36b33](https://github.com/StoneCypher/jssm/commit/35ad7228d5bb15d963a2e4d9e6e35721cce36b33)
+
+Author: `John Haugeland `
+
+  * Add build time to module
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.85.4] - 9/12/2022 1:55:57 PM
+
+Commit [293e2cb9c07734fef562b455d786b7c63ea7647b](https://github.com/StoneCypher/jssm/commit/293e2cb9c07734fef562b455d786b7c63ea7647b)
+
+Author: `John Haugeland `
+
+  * Clean up the gh action a skosh
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.85.3] - 9/12/2022 11:25:36 AM
+
+Commit [87ec233d3511d30358660ad161f932e13eb1738e](https://github.com/StoneCypher/jssm/commit/87ec233d3511d30358660ad161f932e13eb1738e)
+
+Author: `John Haugeland `
+
+Merges [98b7b14, 6475296]
+
+  * Merge pull request #540 from StoneCypher/ReintroduceDisplayText
+  * Reintroduce display text, lost in a bad merge
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/12/2022 11:24:38 AM
+
+Commit [6475296d979dab3d227828b80319d60c4f6ab2f5](https://github.com/StoneCypher/jssm/commit/6475296d979dab3d227828b80319d60c4f6ab2f5)
+
+Author: `John Haugeland `
+
+  * Reintroduce display text, lost in a bad merge
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.85.2] - 9/12/2022 10:03:27 AM
+
+Commit [98b7b14217ea7e83550e4ed15b6b6be80799e246](https://github.com/StoneCypher/jssm/commit/98b7b14217ea7e83550e4ed15b6b6be80799e246)
+
+Author: `John Haugeland `
+
+Merges [461a287, 0f3025a]
+
+  * Merge pull request #539 from StoneCypher/TrimTweet
+  * Shorten the tweet notice
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/12/2022 9:59:52 AM
+
+Commit [0f3025ae2e484afbda57b5f39f5485c4831e7ce7](https://github.com/StoneCypher/jssm/commit/0f3025ae2e484afbda57b5f39f5485c4831e7ce7)
+
+Author: `John Haugeland `
+
+  * Shorten the tweet notice
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.85.1] - 9/12/2022 9:49:05 AM
+
+Commit [461a2874583d08da6db68e40b75047682625c73d](https://github.com/StoneCypher/jssm/commit/461a2874583d08da6db68e40b75047682625c73d)
+
+Author: `John Haugeland `
+
+Merges [2eec2c8, 76d6729]
+
+  * Merge pull request #538 from StoneCypher/RemoveYmlEcho
+  * Remove noisy echo in the YML
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/12/2022 9:35:11 AM
+
+Commit [76d6729a35a3f4eba666ff2d78cd284ed0668edd](https://github.com/StoneCypher/jssm/commit/76d6729a35a3f4eba666ff2d78cd284ed0668edd)
+
+Author: `John Haugeland `
+
+  * Remove noisy echo in the YML
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.85.0] - 9/12/2022 9:22:37 AM
+
+Commit [2eec2c8b69d3e59cb06d7b0efc34b336e9ecc29a](https://github.com/StoneCypher/jssm/commit/2eec2c8b69d3e59cb06d7b0efc34b336e9ecc29a)
+
+Author: `John Haugeland `
+
+Merges [a7b92f9, a0b9fb5]
+
+  * Merge pull request #537 from StoneCypher/DisplayText
+  * simple display text function to resolve labels and node names
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/12/2022 9:17:28 AM
+
+Commit [a0b9fb59c5dc92c94738a6d456ef5e5514a48d1f](https://github.com/StoneCypher/jssm/commit/a0b9fb59c5dc92c94738a6d456ef5e5514a48d1f)
+
+Author: `John Haugeland `
+
+  * simple display text function to resolve labels and node names
+  * fixes StoneCypher/fsl#1202
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.84.1] - 9/12/2022 8:30:09 AM
+
+Commit [a7b92f9b1e94dcab843ab588d83d0c5f8eb9ca18](https://github.com/StoneCypher/jssm/commit/a7b92f9b1e94dcab843ab588d83d0c5f8eb9ca18)
+
+Author: `John Haugeland `
+
+Merges [d4e6196, eedb4a7]
+
+  * Merge pull request #536 from StoneCypher/MoreStabsAtTweeting
+  * Working on auto-tweeter; no associated issue
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/12/2022 8:26:02 AM
+
+Commit [eedb4a7d6ea5392a252cf6dbe5bc2e6e3239591c](https://github.com/StoneCypher/jssm/commit/eedb4a7d6ea5392a252cf6dbe5bc2e6e3239591c)
+
+Author: `John Haugeland `
+
+  * Working on auto-tweeter; no associated issue
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.84.0] - 9/12/2022 7:41:49 AM
+
+Commit [d4e619611a04f24b76ad783a9b0f34393e45840a](https://github.com/StoneCypher/jssm/commit/d4e619611a04f24b76ad783a9b0f34393e45840a)
+
+Author: `John Haugeland `
+
+Merges [cdaa32e, 9193c2d]
+
+  * Merge pull request #535 from StoneCypher/RenameParserAlready
+  * Change parser name to fsl_parser, fixes StoneCypher/fsl#1201; another stab at Twitter
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/12/2022 7:35:32 AM
+
+Commit [9193c2d1f27f1c80ed4a3bfb41e586f5da24179a](https://github.com/StoneCypher/jssm/commit/9193c2d1f27f1c80ed4a3bfb41e586f5da24179a)
+
+Author: `John Haugeland `
+
+  * Change parser name to fsl_parser, fixes StoneCypher/fsl#1201; another stab at Twitter
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.83.2] - 9/11/2022 3:39:14 PM
+
+Commit [cdaa32e418ddf2f094fe5ab2adbc1a0a0b65a2d7](https://github.com/StoneCypher/jssm/commit/cdaa32e418ddf2f094fe5ab2adbc1a0a0b65a2d7)
+
+Author: `John Haugeland `
+
+  * reduce-to-639-1 needs to be a dependency for downstream builds
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.83.1] - 9/11/2022 2:24:06 PM
+
+Commit [c46d677560dc06baf33c2088205051fedaf5be04](https://github.com/StoneCypher/jssm/commit/c46d677560dc06baf33c2088205051fedaf5be04)
+
+Author: `John Haugeland `
+
+Merges [3256f05, 991d2dc]
+
+  * Merge pull request #534 from StoneCypher/BoldTheme
+  * Add a bold theme
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/11/2022 2:19:28 PM
+
+Commit [991d2dcf113bd19026f037e6eb22f46eacde57aa](https://github.com/StoneCypher/jssm/commit/991d2dcf113bd19026f037e6eb22f46eacde57aa)
+
+Author: `John Haugeland `
+
+  * Add a bold theme
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.83.0] - 9/3/2022 5:34:01 PM
+
+Commit [3256f05a4f2b5c5d6e05c2eeba091899e73ef327](https://github.com/StoneCypher/jssm/commit/3256f05a4f2b5c5d6e05c2eeba091899e73ef327)
+
+Author: `John Haugeland `
+
+Merges [51ebcfc, 216dc9c]
+
+  * Merge pull request #533 from StoneCypher/AttemptToFixAstral
+  * Attempt to fix astral
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/3/2022 5:30:23 PM
+
+Commit [216dc9cb659d634a6be9510264f48c26e8a471c0](https://github.com/StoneCypher/jssm/commit/216dc9cb659d634a6be9510264f48c26e8a471c0)
+
+Author: `John Haugeland `
+
+  * Need to make before the unicode tests
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/3/2022 5:27:18 PM
+
+Commit [7878070213ea189def19419eefa4a37ceff701c1](https://github.com/StoneCypher/jssm/commit/7878070213ea189def19419eefa4a37ceff701c1)
+
+Author: `John Haugeland `
+
+  * Get the script names right in the yaml
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/3/2022 5:25:50 PM
+
+Commit [ead26fe40eeb115a87de151b6d91fc83e9aab2b9](https://github.com/StoneCypher/jssm/commit/ead26fe40eeb115a87de151b6d91fc83e9aab2b9)
+
+Author: `John Haugeland `
+
+  * Needed a version bump
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/3/2022 5:21:12 PM
+
+Commit [4deaa1ebabb4bbc3604103a3bcdde77259247fe7](https://github.com/StoneCypher/jssm/commit/4deaa1ebabb4bbc3604103a3bcdde77259247fe7)
+
+Author: `John Haugeland `
+
+  * Unicode range tests for actions, very slow, fixes StoneCypher/fsl#1192
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/3/2022 5:16:16 PM
+
+Commit [72c4ac7e754ab32fe3ca2372fff1733ba8363b27](https://github.com/StoneCypher/jssm/commit/72c4ac7e754ab32fe3ca2372fff1733ba8363b27)
+
+Author: `John Haugeland `
+
+  * Unicode range tests for atoms and strings, very slow, fixes StoneCypher/fsl#1190, fixes StoneCypher/fsl#1191
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/3/2022 3:23:46 PM
+
+Commit [54adb9e46e56254596ca0a710492d3ecf633ea85](https://github.com/StoneCypher/jssm/commit/54adb9e46e56254596ca0a710492d3ecf633ea85)
+
+Author: `John Haugeland `
+
+  * on the way to unicode testing
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/1/2022 7:14:42 PM
+
+Commit [51ebcfc1ec163b8590d1a1a2065dcd8ad0458cc9](https://github.com/StoneCypher/jssm/commit/51ebcfc1ec163b8590d1a1a2065dcd8ad0458cc9)
+
+Author: `John Haugeland `
+
+Merges [94c4f37, 3557437]
+
+  * Merge pull request #530 from machinshin/feature/new-readme
+  * more-readable README
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/1/2022 7:13:51 PM
+
+Commit [35574377c523d8f48198b30ef77b12a5efe72b6c](https://github.com/StoneCypher/jssm/commit/35574377c523d8f48198b30ef77b12a5efe72b6c)
+
+Author: `Vat Raghavan `
+
+  * remake package-lock & upversion
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/1/2022 7:05:32 PM
+
+Commit [c7bb4b01d3b5475d9ccb91ff7999556ef39e8805](https://github.com/StoneCypher/jssm/commit/c7bb4b01d3b5475d9ccb91ff7999556ef39e8805)
+
+Author: `Vat Raghavan `
+
+  * re-build
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/1/2022 6:59:27 PM
+
+Commit [d916b2fe3b67c66ad6c47eef1df6dcfd9863d247](https://github.com/StoneCypher/jssm/commit/d916b2fe3b67c66ad6c47eef1df6dcfd9863d247)
+
+Author: `Vat Raghavan `
+
+  * update version number
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/1/2022 6:56:09 PM
+
+Commit [50b5d8b1a4efce1c7359f713a02cb0477abd7d4a](https://github.com/StoneCypher/jssm/commit/50b5d8b1a4efce1c7359f713a02cb0477abd7d4a)
+
+Author: `Vat Raghavan `
+
+Merges [9e18022, 94c4f37]
+
+  * Merge branch 'main' into feature/new-readme
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.82.5] - 9/1/2022 6:44:36 PM
+
+Commit [94c4f37805eea9179474c66011155368e6c4ed31](https://github.com/StoneCypher/jssm/commit/94c4f37805eea9179474c66011155368e6c4ed31)
+
+Author: `John Haugeland `
+
+Merges [a307163, cf1cb12]
+
+  * Merge pull request #532 from machinshin/feature/shootout/all-inline
+  * all example links are inline-d
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/1/2022 6:41:25 PM
+
+Commit [cf1cb122a9f86e943258ce58ffe490e27d401319](https://github.com/StoneCypher/jssm/commit/cf1cb122a9f86e943258ce58ffe490e27d401319)
+
+Author: `Vat Raghavan `
+
+Merges [1f69c53, a307163]
+
+  * Merge branch 'main' into feature/shootout/all-inline
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/1/2022 6:08:10 PM
+
+Commit [1f69c53f4d3851f205896c446c65e9ecdbf26bbc](https://github.com/StoneCypher/jssm/commit/1f69c53f4d3851f205896c446c65e9ecdbf26bbc)
+
+Author: `Vat Raghavan `
+
+  * all example links are inline-d
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.82.4] - 9/1/2022 6:04:35 PM
+
+Commit [a307163e979abf8af53e4936f972c017f91198ba](https://github.com/StoneCypher/jssm/commit/a307163e979abf8af53e4936f972c017f91198ba)
+
+Author: `John Haugeland `
+
+  * add spurious single type return to theme getter to agree with the setter type, fixes StoneCypher/fsl#1189
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.82.3] - 9/1/2022 5:26:59 PM
+
+Commit [58751e614c6f3f9223239af91f44079ee3a1f045](https://github.com/StoneCypher/jssm/commit/58751e614c6f3f9223239af91f44079ee3a1f045)
+
+Author: `John Haugeland `
+
+Merges [da69e65, a824b2f]
+
+  * Merge pull request #531 from machinshin/feature/shootout-inline-links
+  * relative link to code in Shootout.md
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/1/2022 5:06:20 PM
+
+Commit [a824b2fea98113f5c1ff04227ff4261a41e8634e](https://github.com/StoneCypher/jssm/commit/a824b2fea98113f5c1ff04227ff4261a41e8634e)
+
+Author: `Vat Raghavan `
+
+  * all toggle examples are inline-linked
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/1/2022 4:53:34 PM
+
+Commit [07e19355674ecf8c44ceb54f31cafebefdf08921](https://github.com/StoneCypher/jssm/commit/07e19355674ecf8c44ceb54f31cafebefdf08921)
+
+Author: `Vat Raghavan `
+
+  * relative link to code in Shootout.md
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.82.2] - 9/1/2022 4:17:04 PM
+
+Commit [da69e65ee5a1567825b011d3e17655c2dbd6261d](https://github.com/StoneCypher/jssm/commit/da69e65ee5a1567825b011d3e17655c2dbd6261d)
+
+Author: `John Haugeland `
+
+  * re-enable stoch testing, fixes StoneCypher/fsl#1187; replace .replaceAll with .replace, fixes StoneCypher/fsl#1188
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 9/1/2022 3:57:04 PM
+
+Commit [9e18022f7b474f06e30df55df254f01a0bf6ceb6](https://github.com/StoneCypher/jssm/commit/9e18022f7b474f06e30df55df254f01a0bf6ceb6)
+
+Author: `Vat Raghavan `
+
+  * more-readable README
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.82.1] - 8/20/2022 11:19:53 AM
+
+Commit [27480ec9b23dc281db0212e68f53aabcdc8b946f](https://github.com/StoneCypher/jssm/commit/27480ec9b23dc281db0212e68f53aabcdc8b946f)
+
+Author: `John Haugeland `
+
+Merges [5278df4, 03e1ad3]
+
+  * Merge pull request #529 from StoneCypher/ExposeThemesAndDirections
+  * Expose themes and directions; fixes StoneCypher/fsl#540, fixes StoneCypher/fsl#541
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 8/20/2022 11:16:34 AM
+
+Commit [03e1ad3acf5074dd570eb9a2e2001abab10fb923](https://github.com/StoneCypher/jssm/commit/03e1ad3acf5074dd570eb9a2e2001abab10fb923)
+
+Author: `John Haugeland `
+
+  * Expose themes and directions; fixes StoneCypher/fsl#540, fixes StoneCypher/fsl#541
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.82.0] - 8/19/2022 11:11:19 PM
+
+Commit [5278df4d94a347b37da6cdca2a64a6ca85665b42](https://github.com/StoneCypher/jssm/commit/5278df4d94a347b37da6cdca2a64a6ca85665b42)
+
+Author: `John Haugeland `
+
+Merges [72d6ef7, 88d7309]
+
+  * Merge pull request #528 from StoneCypher/SpinUpThemes
+  * Spin up themes
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 8/19/2022 11:04:20 PM
+
+Commit [88d7309bfd2217fe9aeae3be681ae1f520542365](https://github.com/StoneCypher/jssm/commit/88d7309bfd2217fe9aeae3be681ae1f520542365)
+
+Author: `John Haugeland `
+
+  * Multiple themes, fixes StoneCypher/fsl#128
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 8/19/2022 8:44:55 PM
+
+Commit [2cf5a3f8121a68db58bba992e85b95a8b0e6315e](https://github.com/StoneCypher/jssm/commit/2cf5a3f8121a68db58bba992e85b95a8b0e6315e)
+
+Author: `John Haugeland `
+
+  * coverage pass prior to multitheme
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 8/18/2022 10:12:07 PM
+
+Commit [2f81a2682202a239acc8acbefe0360e3481c8ca9](https://github.com/StoneCypher/jssm/commit/2f81a2682202a239acc8acbefe0360e3481c8ca9)
+
+Author: `John Haugeland `
+
+  * draft themes in place
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 8/17/2022 10:02:39 PM
+
+Commit [9209392cd7e025b365da88aa29649c63b241074d](https://github.com/StoneCypher/jssm/commit/9209392cd7e025b365da88aa29649c63b241074d)
+
+Author: `John Haugeland `
+
+  * mostly done, just have to surface the themes then do testing
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.81.2] - 8/14/2022 4:22:34 PM
+
+Commit [72d6ef77839234d9763ba3c5e667f0eb5ef43951](https://github.com/StoneCypher/jssm/commit/72d6ef77839234d9763ba3c5e667f0eb5ef43951)
+
+Author: `John Haugeland `
+
+  * Clarify composite style type before we start work on themes
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 8/11/2022 9:01:49 PM
+
+Commit [df1dd4c1d190b6571cf43637183b831229793eba](https://github.com/StoneCypher/jssm/commit/df1dd4c1d190b6571cf43637183b831229793eba)
+
+Author: `John Haugeland `
+
+  * Small type changes preparing for theme
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.81.0] - 8/10/2022 11:32:42 PM
+
+Commit [5162f2299530514aecba1bf78fbfe77910e3a417](https://github.com/StoneCypher/jssm/commit/5162f2299530514aecba1bf78fbfe77910e3a417)
+
+Author: `John Haugeland `
+
+  * Engine and parser support for label substitution (no viz yet,) fixes StoneCypher/fsl#117; fixes StoneCypher/fsl#263
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 8/10/2022 10:25:03 PM
+
+Commit [bab9f160ae1dab672a2800c175c21fed2e74f48e](https://github.com/StoneCypher/jssm/commit/bab9f160ae1dab672a2800c175c21fed2e74f48e)
+
+Author: `John Haugeland `
+
+Merges [59e95d8, c3939c3]
+
+  * Merge branch 'main' of github.com:StoneCypher/jssm
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 8/10/2022 10:24:55 PM
+
+Commit [59e95d8d4c06a63fb51b0c886d23612a4835ccfc](https://github.com/StoneCypher/jssm/commit/59e95d8d4c06a63fb51b0c886d23612a4835ccfc)
+
+Author: `John Haugeland `
+
+  * tests for property overriding from inline and for border lines
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.80.1] - 8/7/2022 11:57:01 PM
+
+Commit [c3939c3486d8ae2338385de375d753ef5a38673d](https://github.com/StoneCypher/jssm/commit/c3939c3486d8ae2338385de375d753ef5a38673d)
+
+Author: `John Haugeland `
+
+Merges [6cb2816, b59b5b5]
+
+  * Merge pull request #527 from StoneCypher/AddInlineStylesToResolver
+  * Adds inline styles to resolver, fixes StoneCypher/fsl#1160
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 8/7/2022 11:52:57 PM
+
+Commit [b59b5b530de566d82b6fa707d66f9b5ceb2037e8](https://github.com/StoneCypher/jssm/commit/b59b5b530de566d82b6fa707d66f9b5ceb2037e8)
+
+Author: `John Haugeland `
+
+  * Adds inline styles to resolver, fixes StoneCypher/fsl#1160
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.80.0] - 8/4/2022 9:37:11 PM
+
+Commit [6cb281616eaa3d70bc0ff4e14410c5caa07f70f2](https://github.com/StoneCypher/jssm/commit/6cb281616eaa3d70bc0ff4e14410c5caa07f70f2)
+
+Author: `John Haugeland `
+
+Merges [4d79b09, ed398d3]
+
+  * Merge pull request #526 from StoneCypher/SupportForStartAndEndStateStyling
+  * Support for start and end state styling
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 8/4/2022 9:29:52 PM
+
+Commit [ed398d3627e63b7b64d009acb42779b814e2f6da](https://github.com/StoneCypher/jssm/commit/ed398d3627e63b7b64d009acb42779b814e2f6da)
+
+Author: `John Haugeland `
+
+  * tests
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 8/4/2022 9:15:50 PM
+
+Commit [63304cd9d1dd4ea5801edb6437f361023e3d6c32](https://github.com/StoneCypher/jssm/commit/63304cd9d1dd4ea5801edb6437f361023e3d6c32)
+
+Author: `John Haugeland `
+
+  * Styling now works for start, end, and terminal state types too.  Fixes StoneCypher/fsl#1143, fixes StoneCypher/fsl#1141, fixes StoneCypher/fsl#1156, fixes StoneCypher/fsl#1157, fixes StoneCypher/fsl#242
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 8/4/2022 1:50:52 AM
+
+Commit [89948de7b9857909a6132c95cd6019be08e82d18](https://github.com/StoneCypher/jssm/commit/89948de7b9857909a6132c95cd6019be08e82d18)
+
+Author: `John Haugeland `
+
+  * Semi-working implementation of style condensation, fixes StoneCypher/fsl#1141; added base stylesheet, fixes StoneCypher/fsl#1142
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 8/2/2022 3:50:45 PM
+
+Commit [9001216af66f3fc719a406402d1d07f66cea465c](https://github.com/StoneCypher/jssm/commit/9001216af66f3fc719a406402d1d07f66cea465c)
+
+Author: `John Haugeland `
+
+  * Six style modalities exposed, fixes StoneCypher/fsl#1136, fixes StoneCypher/fsl#1137, fixes StoneCypher/fsl#1138, fixes StoneCypher/fsl#1139, fixes StoneCypher/fsl#1140
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 8/1/2022 12:08:55 PM
+
+Commit [1c4fcaaf1b15087b8d2aaa4fcf08ee386fb7c90c](https://github.com/StoneCypher/jssm/commit/1c4fcaaf1b15087b8d2aaa4fcf08ee386fb7c90c)
+
+Author: `John Haugeland `
+
+  * all six state styles (start end standard hooked terminal current) now make it through to the machine, fixes StoneCypher/fsl#1131, fixes StoneCypher/fsl#1132, fixes StoneCypher/fsl#1133, fixes StoneCypher/fsl#1134, fixes StoneCypher/fsl#1135
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.79.18] - 7/28/2022 11:21:27 PM
+
+Commit [4d79b09ceed3385fbfd237092c5befd0b120f589](https://github.com/StoneCypher/jssm/commit/4d79b09ceed3385fbfd237092c5befd0b120f589)
+
+Author: `John Haugeland `
+
+  * Compile benchmark, fixes StoneCypher/fsl#1130
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.79.17] - 7/28/2022 10:21:48 PM
+
+Commit [80a5f0821ce4e866bfdb6ed9123ee3e409fdfd99](https://github.com/StoneCypher/jssm/commit/80a5f0821ce4e866bfdb6ed9123ee3e409fdfd99)
+
+Author: `John Haugeland `
+
+  * Definitions for language features in feature comparison matrix
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.79.16] - 7/28/2022 7:04:27 PM
+
+Commit [a76a9d87b7f1d691e982d9b5da8a5bc0d68fc1ea](https://github.com/StoneCypher/jssm/commit/a76a9d87b7f1d691e982d9b5da8a5bc0d68fc1ea)
+
+Author: `John Haugeland `
+
+Merges [3cceb0a, 3363432]
+
+  * Merge pull request #525 from StoneCypher/FinishComparisonMatrix
+  * Adds `stent`, `fsm`, `fsm-event`, `node-state`, `state-machine`, `stately.js` to feature comparison table, fixes StoneCypher/fsl#1118, fixes StoneCypher/fsl#1119, fixes StoneCypher/fsl#1120, fixes StoneCypher/fsl#1121, fixes StoneCypher/fsl#1122, fixes StoneCypher/fsl#1123
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/28/2022 7:01:10 PM
+
+Commit [3363432b1abe446798ca41beff6ce7a9f3b6cee6](https://github.com/StoneCypher/jssm/commit/3363432b1abe446798ca41beff6ce7a9f3b6cee6)
+
+Author: `John Haugeland `
+
+  * Adds `stent`, `fsm`, `fsm-event`, `node-state`, `state-machine`, `stately.js`, `node-state` to feature comparison table, fixes StoneCypher/fsl#1118, fixes StoneCypher/fsl#1119, fixes StoneCypher/fsl#1120, fixes StoneCypher/fsl#1121, fixes StoneCypher/fsl#1122, fixes StoneCypher/fsl#1123
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.79.15] - 7/28/2022 3:47:24 PM
+
+Commit [3cceb0ab8a9d56f7f3cd79b6ff64beb882e7bc86](https://github.com/StoneCypher/jssm/commit/3cceb0ab8a9d56f7f3cd79b6ff64beb882e7bc86)
+
+Author: `John Haugeland `
+
+Merges [bc39f54, 3ace82f]
+
+  * Merge pull request #524 from StoneCypher/MoreTryingToFixTwitterTweeter
+  * More trying to fix twitter tweeter
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/28/2022 3:37:38 PM
+
+Commit [3ace82f3e03403765c72ffda4e4e8819bcd1e1ca](https://github.com/StoneCypher/jssm/commit/3ace82f3e03403765c72ffda4e4e8819bcd1e1ca)
+
+Author: `John Haugeland `
+
+  * Working on the Twitter release message
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/28/2022 3:28:23 PM
+
+Commit [bc39f54865c2eb421261ee1a6ff9e3f6cc3f0b66](https://github.com/StoneCypher/jssm/commit/bc39f54865c2eb421261ee1a6ff9e3f6cc3f0b66)
+
+Author: `John Haugeland `
+
+Merges [98eb7eb, 6324d89]
+
+  * Merge pull request #523 from StoneCypher/MoreComparisonChart
+  * More comparison chart
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/28/2022 3:25:12 PM
+
+Commit [6483abdffc869f010f866110c55295da1bee022d](https://github.com/StoneCypher/jssm/commit/6483abdffc869f010f866110c55295da1bee022d)
+
+Author: `John Haugeland `
+
+Merges [6324d89, 98eb7eb]
+
+  * Merge branch 'main' into MoreComparisonChart
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/28/2022 3:24:41 PM
+
+Commit [6324d89f41053d8129df931d56ef4a0fdf499500](https://github.com/StoneCypher/jssm/commit/6324d89f41053d8129df931d56ef4a0fdf499500)
+
+Author: `John Haugeland `
+
+  * try to fix the broken publish env
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/28/2022 3:19:37 PM
+
+Commit [915482bf57474c05cb0b8722e89d782eda4ea61c](https://github.com/StoneCypher/jssm/commit/915482bf57474c05cb0b8722e89d782eda4ea61c)
+
+Author: `John Haugeland `
+
+  * Adds `machina`, `finity`, `fsm-iterator`, `fsm-as-promised` to feature comparison table, fixes StoneCypher/fsl#1114, fixes StoneCypher/fsl#1115, fixes StoneCypher/fsl#1116, fixes StoneCypher/fsl#1117
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/28/2022 1:46:09 PM
+
+Commit [98eb7eb745ed5b8593e7695764ddee37eb8ecf9e](https://github.com/StoneCypher/jssm/commit/98eb7eb745ed5b8593e7695764ddee37eb8ecf9e)
+
+Author: `John Haugeland `
+
+Merges [66cbb1d, 16920b1]
+
+  * Merge pull request #522 from StoneCypher/MoreComparisonChart
+  * More comparison chart
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/28/2022 1:45:17 PM
+
+Commit [16920b102b96a8cc4e3db44abb5b17b716940090](https://github.com/StoneCypher/jssm/commit/16920b102b96a8cc4e3db44abb5b17b716940090)
+
+Author: `John Haugeland `
+
+  * Adds `robot3` to feature comparison table, fixes StoneCypher/fsl#1124
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/28/2022 1:02:26 PM
+
+Commit [6a7684e3a0b665e3c7b7f38e6adda08c09d18c1c](https://github.com/StoneCypher/jssm/commit/6a7684e3a0b665e3c7b7f38e6adda08c09d18c1c)
+
+Author: `John Haugeland `
+
+  * Adds `mood` to feature comparison table, fixes StoneCypher/fsl#1125
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/28/2022 12:52:20 PM
+
+Commit [b49af31975f4424923024f2cef459a975240a98e](https://github.com/StoneCypher/jssm/commit/b49af31975f4424923024f2cef459a975240a98e)
+
+Author: `John Haugeland `
+
+  * Add `grammar-graph` to comparison, fixes StoneCypher/fsl#1126
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.79.11] - 7/28/2022 8:22:55 AM
+
+Commit [66cbb1d35679c7271a08bc31ab3a7b2557a15f3e](https://github.com/StoneCypher/jssm/commit/66cbb1d35679c7271a08bc31ab3a7b2557a15f3e)
+
+Author: `John Haugeland `
+
+  * Add javascript-state-machine to feature comparison, fixes StoneCypher/fsl#1113
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.79.10] - 7/27/2022 11:44:10 PM
+
+Commit [aa5e666f5f02e5fc0c6818dd7fb84dd689dc0448](https://github.com/StoneCypher/jssm/commit/aa5e666f5f02e5fc0c6818dd7fb84dd689dc0448)
+
+Author: `John Haugeland `
+
+  * Feature comparison table, shots fired, fixes StoneCypher/fsl#839, fixes StoneCypher/fsl#643
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/27/2022 10:21:23 PM
+
+Commit [2f548fc2c2c8e02d9ac5da5279a6c8d69130316f](https://github.com/StoneCypher/jssm/commit/2f548fc2c2c8e02d9ac5da5279a6c8d69130316f)
+
+Author: `John Haugeland `
+
+  * first sketch of feature comparison
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/25/2022 11:11:11 AM
+
+Commit [d0a4b3e731b887da477f2dde109a5d57b39522b3](https://github.com/StoneCypher/jssm/commit/d0a4b3e731b887da477f2dde109a5d57b39522b3)
+
+Author: `John Haugeland `
+
+  * Delete example-machine-template.md
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/25/2022 11:09:21 AM
+
+Commit [572a8a1e14f4b29a1bb021e9b76124d74959e59b](https://github.com/StoneCypher/jssm/commit/572a8a1e14f4b29a1bb021e9b76124d74959e59b)
+
+Author: `John Haugeland `
+
+  * Delete feature-requesting-template.md
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/25/2022 11:09:07 AM
+
+Commit [7379b2324c15a44ca98311121408b771d165b68a](https://github.com/StoneCypher/jssm/commit/7379b2324c15a44ca98311121408b771d165b68a)
+
+Author: `John Haugeland `
+
+  * Delete bug-reporting-template.md
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/25/2022 11:08:28 AM
+
+Commit [412cabb32d87ffd91752ba5006c59e4b1867a469](https://github.com/StoneCypher/jssm/commit/412cabb32d87ffd91752ba5006c59e4b1867a469)
+
+Author: `John Haugeland `
+
+  * Create config.yml
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.79.9] - 7/25/2022 5:41:07 AM
+
+Commit [014cafc52c34afb19f50e8ab60741ee8585b1213](https://github.com/StoneCypher/jssm/commit/014cafc52c34afb19f50e8ab60741ee8585b1213)
+
+Author: `John Haugeland `
+
+  * centralize prior to tree tool
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.79.8] - 7/22/2022 12:23:51 AM
+
+Commit [2c1ab4f936b061a7ffe46187f45fdc3949b3eb1f](https://github.com/StoneCypher/jssm/commit/2c1ab4f936b061a7ffe46187f45fdc3949b3eb1f)
+
+Author: `John Haugeland `
+
+  * Expose a load of math constants; create a constants namespace.  Leave the old ones in both places for compat.  Fixes StoneCypher/fsl#1043, StoneCypher/fsl#1044, StoneCypher/fsl#1045, StoneCypher/fsl#1046, StoneCypher/fsl#1047, StoneCypher/fsl#1048, StoneCypher/fsl#1049, StoneCypher/fsl#1050, StoneCypher/fsl#1058, StoneCypher/fsl#1059, StoneCypher/fsl#1060, StoneCypher/fsl#1061, StoneCypher/fsl#1062, StoneCypher/fsl#1063, StoneCypher/fsl#1064, StoneCypher/fsl#1065, StoneCypher/fsl#1066
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.79.6] - 7/21/2022 11:56:00 PM
+
+Commit [e91095dc64dacebab0dafe96180219998e0d2891](https://github.com/StoneCypher/jssm/commit/e91095dc64dacebab0dafe96180219998e0d2891)
+
+Author: `John Haugeland `
+
+  * add newline in gha envvar to support twitter action
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/21/2022 11:03:43 PM
+
+Commit [a2a45dbfda6df7012651a55aa65f8e606c0a8768](https://github.com/StoneCypher/jssm/commit/a2a45dbfda6df7012651a55aa65f8e606c0a8768)
+
+Author: `John Haugeland `
+
+Merges [3bf5c1d, 277683b]
+
+  * Merge pull request #521 from StoneCypher/StartTweetingInGha
+  * improved tweet system, fixed gh action non-install
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/21/2022 10:58:51 PM
+
+Commit [277683b9ba40288005a0bf2d7044dea84696ac01](https://github.com/StoneCypher/jssm/commit/277683b9ba40288005a0bf2d7044dea84696ac01)
+
+Author: `John Haugeland `
+
+  * improved tweet system, fixed gh action non-install
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.79.4] - 7/21/2022 10:39:56 PM
+
+Commit [3bf5c1d061d67524c5f97279a854473d9989e92b](https://github.com/StoneCypher/jssm/commit/3bf5c1d061d67524c5f97279a854473d9989e92b)
+
+Author: `John Haugeland `
+
+Merges [02bf1ff, 39f3906]
+
+  * Merge pull request #520 from StoneCypher/StartTweetingInGha
+  * Start tweeting in gha
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/21/2022 10:35:56 PM
+
+Commit [39f390677155346d07f55264f006c1067932670f](https://github.com/StoneCypher/jssm/commit/39f390677155346d07f55264f006c1067932670f)
+
+Author: `John Haugeland `
+
+  * Bump, rebuild
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/21/2022 10:33:47 PM
+
+Commit [03f81a35f2c158b1139589bb67fd230fa46be3be](https://github.com/StoneCypher/jssm/commit/03f81a35f2c158b1139589bb67fd230fa46be3be)
+
+Author: `John Haugeland `
+
+  * Automate GHA tweeting of releases to @FSL_and_JSSM; bump terser; fix protocol on youtube links
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.79.3] - 7/18/2022 6:41:12 PM
+
+Commit [02bf1ff5ef650323c2ad5d4a54d2c21caf0f272a](https://github.com/StoneCypher/jssm/commit/02bf1ff5ef650323c2ad5d4a54d2c21caf0f272a)
+
+Author: `John Haugeland `
+
+  * changing to a protocol-free url in docs to get youtube vids to load, test 1
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.79.2] - 7/14/2022 11:39:18 PM
+
+Commit [9f4e86c883c6bb776817da84ba3fe77473f47427](https://github.com/StoneCypher/jssm/commit/9f4e86c883c6bb776817da84ba3fe77473f47427)
+
+Author: `John Haugeland `
+
+Merges [f756f21, 3a127c6]
+
+  * Merge pull request #518 from StoneCypher/RequiredProperties
+  * Property requirement, fixes StoneCypher/fsl#1041
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/14/2022 11:31:58 PM
+
+Commit [3a127c6201604ec2323d72adabf72c07dd1425e3](https://github.com/StoneCypher/jssm/commit/3a127c6201604ec2323d72adabf72c07dd1425e3)
+
+Author: `John Haugeland `
+
+  * caught a typo
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/14/2022 11:26:20 PM
+
+Commit [0a97cd4664b15047b265bd0bf72fd7da79b2d528](https://github.com/StoneCypher/jssm/commit/0a97cd4664b15047b265bd0bf72fd7da79b2d528)
+
+Author: `John Haugeland `
+
+  * Property requirement, fixes StoneCypher/fsl#1041
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.79.1] - 7/14/2022 2:45:12 PM
+
+Commit [f756f219a0b8ca95feae287a110261dc364030cc](https://github.com/StoneCypher/jssm/commit/f756f219a0b8ca95feae287a110261dc364030cc)
+
+Author: `John Haugeland `
+
+Merges [ed93695, e2cc7d1]
+
+  * Merge pull request #517 from StoneCypher/StrictProp
+  * `.strict_prop`, fixes StoneCypher/fsl#1037; tests to enforce, fixes StoneCypher/fsl#1035
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/14/2022 2:37:44 PM
+
+Commit [e2cc7d1c49c6507572d26c30ff069aee19167eec](https://github.com/StoneCypher/jssm/commit/e2cc7d1c49c6507572d26c30ff069aee19167eec)
+
+Author: `John Haugeland `
+
+  * `.strict_prop`, fixes StoneCypher/fsl#1037; tests to enforce, fixes StoneCypher/fsl#1035
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.79.0] - 7/13/2022 9:32:13 PM
+
+Commit [ed936950b132042aeb299c02ad199fe84d5f41f5](https://github.com/StoneCypher/jssm/commit/ed936950b132042aeb299c02ad199fe84d5f41f5)
+
+Author: `John Haugeland `
+
+Merges [7e9fc0d, d28ab5a]
+
+  * Merge pull request #516 from StoneCypher/Properties
+  * Properties
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/13/2022 6:41:37 PM
+
+Commit [d28ab5a2a576d25bf45d5fd2f55895441a10cd99](https://github.com/StoneCypher/jssm/commit/d28ab5a2a576d25bf45d5fd2f55895441a10cd99)
+
+Author: `John Haugeland `
+
+  * State properties make it to machine, fixes StoneCypher/fsl#1040; overrides, fixes StoneCypher/fsl#1023
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/13/2022 2:23:16 PM
+
+Commit [ef4f483808e5aff64c4dee0ffac1472ac9202c4b](https://github.com/StoneCypher/jssm/commit/ef4f483808e5aff64c4dee0ffac1472ac9202c4b)
+
+Author: `John Haugeland `
+
+  * `.props`, fixes StoneCypher/fsl#1019; state props make it through compiler, fixes StoneCypher/fsl#1029; lots of doc improvements, numeric constants
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/13/2022 2:20:10 PM
+
+Commit [7814c864c7bffeeb755bc0f3d7ec1faf8e4a965d](https://github.com/StoneCypher/jssm/commit/7814c864c7bffeeb755bc0f3d7ec1faf8e4a965d)
+
+Author: `John Haugeland `
+
+  * State properties in grammar, fixes StoneCypher/fsl#1030, fixes StoneCypher/fsl#1031, fixes StoneCypher/fsl#1032, fixes StoneCypher/fsl#1033, fixes StoneCypher/fsl#1034
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/13/2022 9:06:10 AM
+
+Commit [1349b752fd40db754dfa760bfb60b16646ef5108](https://github.com/StoneCypher/jssm/commit/1349b752fd40db754dfa760bfb60b16646ef5108)
+
+Author: `John Haugeland `
+
+  * known_prop, fixes StoneCypher/fsl#1021
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/13/2022 8:14:19 AM
+
+Commit [c7191c8ba796bd21cb2ba123038b9c6b5b274057](https://github.com/StoneCypher/jssm/commit/c7191c8ba796bd21cb2ba123038b9c6b5b274057)
+
+Author: `John Haugeland `
+
+  * Default props now making it into machine, fixes StoneCypher/fsl#1039; datastructures, fixes StoneCypher/fsl#1022
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/12/2022 10:05:06 AM
+
+Commit [1629741f34d564706e6c91f8cfc60edcfdd379bb](https://github.com/StoneCypher/jssm/commit/1629741f34d564706e6c91f8cfc60edcfdd379bb)
+
+Author: `John Haugeland `
+
+  * Default properties now make it through compiler, fixes StoneCypher/fsl#1028; blocks repetition, fixes StoneCypher/fsl#1038
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/11/2022 10:38:54 PM
+
+Commit [fd306ed88144815a2d2fb26250709d4fba8f99fe](https://github.com/StoneCypher/jssm/commit/fd306ed88144815a2d2fb26250709d4fba8f99fe)
+
+Author: `John Haugeland `
+
+  * Basic machine properties now making it through aggregation
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/11/2022 10:10:29 PM
+
+Commit [400cbe62582aa2261b694f01e0d04704a76a12ef](https://github.com/StoneCypher/jssm/commit/400cbe62582aa2261b694f01e0d04704a76a12ef)
+
+Author: `John Haugeland `
+
+  * Basic tests for property defaults
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/11/2022 9:55:08 PM
+
+Commit [31425dd227fa0811e387d96f89e40e2c0e148df3](https://github.com/StoneCypher/jssm/commit/31425dd227fa0811e387d96f89e40e2c0e148df3)
+
+Author: `John Haugeland `
+
+  * Internal property datastructures, fixes StoneCypher/fsl#1022, getting started with StoneCypher/fsl#1018
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.78.0] - 7/9/2022 4:22:51 PM
+
+Commit [7e9fc0d832e0e46b477e27758183cc6ffc288916](https://github.com/StoneCypher/jssm/commit/7e9fc0d832e0e46b477e27758183cc6ffc288916)
+
+Author: `John Haugeland `
+
+Merges [6497ed4, 1e742f0]
+
+  * Merge pull request #514 from StoneCypher/Serialize
+  * Serialize
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/9/2022 3:50:44 PM
+
+Commit [1e742f089c9d0d012691abe9cc6db82d54925469](https://github.com/StoneCypher/jssm/commit/1e742f089c9d0d012691abe9cc6db82d54925469)
+
+Author: `John Haugeland `
+
+  * Draft implementation of serialization and deserialization.  Fixes StoneCypher/fsl#1000, fixes StoneCypher/fsl#1001, fixes StoneCypher/fsl#1002, fixes StoneCypher/fsl#1003, fixes StoneCypher/fsl#1004, fixes StoneCypher/fsl#1005, fixes StoneCypher/fsl#1006, fixes StoneCypher/fsl#1009, fixes StoneCypher/fsl#1011, fixes StoneCypher/fsl#1012
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/9/2022 1:00:20 PM
+
+Commit [05c1f81f02406cb3211e3d2bd84eefb2da201b3e](https://github.com/StoneCypher/jssm/commit/05c1f81f02406cb3211e3d2bd84eefb2da201b3e)
+
+Author: `John Haugeland `
+
+  * Spec underway
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.77.1] - 7/7/2022 10:36:21 PM
+
+Commit [6497ed49a6a7dbe55509ac552cc30adb9ee19c9c](https://github.com/StoneCypher/jssm/commit/6497ed49a6a7dbe55509ac552cc30adb9ee19c9c)
+
+Author: `John Haugeland `
+
+Merges [e9400bd, 4623580]
+
+  * Merge pull request #512 from StoneCypher/SynonymDoForAction
+  * Define do/1 to be a synonym for action/1, fixes StoneCypher/fsl#809
+
+
+
+
+ 
+
+ 
+
+## [Untagged] - 7/7/2022 10:18:20 PM
+
+Commit [462358017970f5d968d8309ba8ee96d74648ec03](https://github.com/StoneCypher/jssm/commit/462358017970f5d968d8309ba8ee96d74648ec03)
+
+Author: `John Haugeland `
+
+  * Define do/1 to be a synonym for action/1, fixes StoneCypher/fsl#809
+
+
+
+
+ 
+
+ 
+
+
+
+## [5.77.0] - 7/7/2022 10:18:06 PM
+
+Commit [e9400bd62c93201bcc34a002469e21910979cb2e](https://github.com/StoneCypher/jssm/commit/e9400bd62c93201bcc34a002469e21910979cb2e)
+
+Author: `John Haugeland `
+
+Merges [d1b55ae, 2c633a6]
+
+  * Merge pull request #511 from StoneCypher/SynonymGoForTransition
+  * Define go/1 to be a synonym for transition/1, fixes StoneCypher/fsl#810
+
+
+
+
+ 
+
+ 
 
-## [5.76.2] - 7/6/2022 8:27:33 AM
+## [Untagged] - 7/7/2022 10:11:44 PM
 
-Commit [d1b55ae8944031677c228f06eec6a5a28eb695ac](https://github.com/StoneCypher/jssm/commit/d1b55ae8944031677c228f06eec6a5a28eb695ac)
+Commit [2c633a61b2ee0f13583ddc85923596f6b473abe6](https://github.com/StoneCypher/jssm/commit/2c633a61b2ee0f13583ddc85923596f6b473abe6)
 
 Author: `John Haugeland `
 
-Merges [813d866, 40677c7]
-
-  * Merge pull request #510 from StoneCypher/BumpCloc
-  * Bump CLOC, fixes StoneCypher/fsl#995
+  * Define go/1 to be a synonym for transition/1, fixes StoneCypher/fsl#810
 
 
 
@@ -42,13 +2270,13 @@ Merges [813d866, 40677c7]
 
  
 
-## [Untagged] - 7/5/2022 1:24:10 PM
+## [Untagged] - 7/7/2022 12:29:56 PM
 
-Commit [40677c744241e590d901c317cdcc0046833a5257](https://github.com/StoneCypher/jssm/commit/40677c744241e590d901c317cdcc0046833a5257)
+Commit [d29b22488e10f3ee798b7ecb23598654fe987fb8](https://github.com/StoneCypher/jssm/commit/d29b22488e10f3ee798b7ecb23598654fe987fb8)
 
 Author: `John Haugeland `
 
-  * Uh, you have to git add to git commit, dummy
+  * it seems the bundling error I was facing when Discord insisted I just didn't get it might be a bug in deno
 
 
 
@@ -57,15 +2285,18 @@ Author: `John Haugeland `
 
  
 
-## [Untagged] - 7/5/2022 1:04:10 PM
+
+
+## [5.76.2] - 7/6/2022 8:27:33 AM
 
-Commit [58e88fec3f6412cadfc762f646ed50f6bc10eac6](https://github.com/StoneCypher/jssm/commit/58e88fec3f6412cadfc762f646ed50f6bc10eac6)
+Commit [d1b55ae8944031677c228f06eec6a5a28eb695ac](https://github.com/StoneCypher/jssm/commit/d1b55ae8944031677c228f06eec6a5a28eb695ac)
 
 Author: `John Haugeland `
 
-Merges [1cc0629, 0cc8f7b]
+Merges [813d866, 40677c7]
 
-  * WIP on IntroducingTheKitchenSinkDragon: 1cc0629 Sequester the stoch tests until they're more complete
+  * Merge pull request #510 from StoneCypher/BumpCloc
+  * Bump CLOC, fixes StoneCypher/fsl#995
 
 
 
@@ -74,13 +2305,13 @@ Merges [1cc0629, 0cc8f7b]
 
  
 
-## [Untagged] - 7/5/2022 1:04:10 PM
+## [Untagged] - 7/5/2022 1:24:10 PM
 
-Commit [0cc8f7bad92e4327128237bc9600cedd2e7cbb94](https://github.com/StoneCypher/jssm/commit/0cc8f7bad92e4327128237bc9600cedd2e7cbb94)
+Commit [40677c744241e590d901c317cdcc0046833a5257](https://github.com/StoneCypher/jssm/commit/40677c744241e590d901c317cdcc0046833a5257)
 
 Author: `John Haugeland `
 
-  * index on IntroducingTheKitchenSinkDragon: 1cc0629 Sequester the stoch tests until they're more complete
+  * Uh, you have to git add to git commit, dummy
 
 
 
@@ -235,21 +2466,6 @@ Author: `John Haugeland `
 
 
 
- 
-
- 
-
-## [Untagged] - 7/3/2022 11:41:29 AM
-
-Commit [7bf27e64e929c449d613d461fd1de1ceee4e8183](https://github.com/StoneCypher/jssm/commit/7bf27e64e929c449d613d461fd1de1ceee4e8183)
-
-Author: `John Haugeland `
-
-  * Force this directory to exist with a meaningles file that defies the gitignore, then roll version back because apparently .0 didn't get released
-
-
-
-
  
 
  
@@ -295,36 +2511,6 @@ Author: `John Haugeland `
 
 
 
- 
-
- 
-
-## [Untagged] - 7/3/2022 10:08:02 AM
-
-Commit [986fd0dd50adcb739f54e4fa3712628c94004505](https://github.com/StoneCypher/jssm/commit/986fd0dd50adcb739f54e4fa3712628c94004505)
-
-Author: `John Haugeland `
-
-  * added cloc, turned to disk, made a cute little reporter, fixes StoneCypher/fsl#985
-
-
-
-
- 
-
- 
-
-## [Untagged] - 7/3/2022 10:08:02 AM
-
-Commit [0c34b68d5a5d6666895965e5f8b4b9a9dadfe397](https://github.com/StoneCypher/jssm/commit/0c34b68d5a5d6666895965e5f8b4b9a9dadfe397)
-
-Author: `John Haugeland `
-
-  * added cloc, turned to disk, made a cute little reporter, fixes StoneCypher/fsl#985
-
-
-
-
  
 
  
@@ -2273,21 +4459,6 @@ Author: `John Haugeland `
 
 
 
- 
-
- 
-
-## [Untagged] - 5/22/2022 9:07:03 AM
-
-Commit [4dbe3833d503a7f5af7563e487ab6f722b01220f](https://github.com/StoneCypher/jssm/commit/4dbe3833d503a7f5af7563e487ab6f722b01220f)
-
-Author: `John Haugeland `
-
-  * Document arr_uniq_p; fix merge mess
-
-
-
-
  
 
  
@@ -2308,66 +4479,6 @@ Merges [fdb3369, bc9f107]
 
 
 
- 
-
- 
-
-## [Untagged] - 5/22/2022 8:52:35 AM
-
-Commit [9c6982187896ea62e1a7bdc989d4d16e57975f8a](https://github.com/StoneCypher/jssm/commit/9c6982187896ea62e1a7bdc989d4d16e57975f8a)
-
-Author: `John Haugeland `
-
-  * Document hook_name, fixes StoneCypher/#788, and named_hook_name, fixes StoneCypher/#789
-
-
-
-
- 
-
- 
-
-## [Untagged] - 5/22/2022 8:43:42 AM
-
-Commit [cc3b7dda265226ef7ca818d387c06628132673ef](https://github.com/StoneCypher/jssm/commit/cc3b7dda265226ef7ca818d387c06628132673ef)
-
-Author: `John Haugeland `
-
-  * document seq/1, document histo/1, a little extra testing, fixes StoneCypher/fsl#786, fixes StoneCypher/fsl#787
-
-
-
-
- 
-
- 
-
-## [Untagged] - 5/22/2022 8:43:42 AM
-
-Commit [9dbc57da37b83d3fc2a26c7de17aae8fe976a025](https://github.com/StoneCypher/jssm/commit/9dbc57da37b83d3fc2a26c7de17aae8fe976a025)
-
-Author: `John Haugeland `
-
-  * document seq/1, document histo/1, a little extra testing
-
-
-
-
- 
-
- 
-
-## [Untagged] - 5/22/2022 8:43:42 AM
-
-Commit [780cc714651030e2a89343620dff20669d317e62](https://github.com/StoneCypher/jssm/commit/780cc714651030e2a89343620dff20669d317e62)
-
-Author: `John Haugeland `
-
-  * seq/1, a little extra testing
-
-
-
-
  
 
  
@@ -3504,51 +5615,6 @@ Author: `John Haugeland `
 
 
 
- 
-
- 
-
-## [Untagged] - 5/8/2022 3:31:19 PM
-
-Commit [6f68f82516475c74e9ae958b0b9d9d9ea8496742](https://github.com/StoneCypher/jssm/commit/6f68f82516475c74e9ae958b0b9d9d9ea8496742)
-
-Author: `John Haugeland `
-
-  * Bumps eslint, fixes StoneCypher/fsl#723
-
-
-
-
- 
-
- 
-
-## [Untagged] - 5/8/2022 3:14:51 PM
-
-Commit [7985afdecc47ec9247357e386efa126a705f6e7b](https://github.com/StoneCypher/jssm/commit/7985afdecc47ec9247357e386efa126a705f6e7b)
-
-Author: `John Haugeland `
-
-  * was pinned by ts-jest, re-bumped
-
-
-
-
- 
-
- 
-
-## [Untagged] - 5/8/2022 3:09:14 PM
-
-Commit [ee261f9ce626b0df70932c82fe5e599abd4f1225](https://github.com/StoneCypher/jssm/commit/ee261f9ce626b0df70932c82fe5e599abd4f1225)
-
-Author: `John Haugeland `
-
-  * Bumps jest, fixes StoneCypher/fsl#719
-
-
-
-
  
 
  
@@ -3699,23 +5765,6 @@ Merges [e993d6b, 23c50e2]
 
 
 
- 
-
- 
-
-## [Untagged] - 5/8/2022 3:09:04 AM
-
-Commit [fbcda324d66dd8b569a4e60b93794af1a3fea8f0](https://github.com/StoneCypher/jssm/commit/fbcda324d66dd8b569a4e60b93794af1a3fea8f0)
-
-Author: `John Haugeland `
-
-Merges [23c50e2, e993d6b]
-
-  * Merge branch 'main' into AttemptToCorrectQualityDrop2
-
-
-
-
  
 
  
@@ -4228,21 +6277,6 @@ Author: `John Haugeland `
 
 
 
- 
-
- 
-
-## [Untagged] - 4/26/2022 12:26:11 AM
-
-Commit [330a670aaf0b8b793ad5d2c10d3321c9b1dd1b43](https://github.com/StoneCypher/jssm/commit/330a670aaf0b8b793ad5d2c10d3321c9b1dd1b43)
-
-Author: `John Haugeland `
-
-  * will get started here
-
-
-
-
  
 
  
@@ -6525,21 +8559,6 @@ Author: `John Haugeland `
 
 
 
- 
-
- 
-
-## [Untagged] - 1/14/2021 1:14:47 PM
-
-Commit [78a99337c1e690abeac5c9c03c745f50393c43ae](https://github.com/StoneCypher/jssm/commit/78a99337c1e690abeac5c9c03c745f50393c43ae)
-
-Author: `John Haugeland `
-
-  * fix 531 soon
-
-
-
-
  
 
  
@@ -7549,53 +9568,6 @@ Author: `John Haugeland `
 
 
 
- 
-
- 
-
-## [Untagged] - 1/28/2020 7:50:46 PM
-
-Commit [92ecbf90777430ab2db1de3d0595c3150368ba6d](https://github.com/StoneCypher/jssm/commit/92ecbf90777430ab2db1de3d0595c3150368ba6d)
-
-Author: `John Haugeland `
-
-Merges [1fa2e0b, 307ecf2]
-
-  * WIP on LetsSimplifyTheTautologies: 1fa2e0b first steps: centralize the constants
-
-
-
-
- 
-
- 
-
-## [Untagged] - 1/28/2020 7:50:44 PM
-
-Commit [307ecf2d66dc79fb6c6576641696a97b917d1b61](https://github.com/StoneCypher/jssm/commit/307ecf2d66dc79fb6c6576641696a97b917d1b61)
-
-Author: `John Haugeland `
-
-  * index on LetsSimplifyTheTautologies: 1fa2e0b first steps: centralize the constants
-
-
-
-
- 
-
- 
-
-## [Untagged] - 1/28/2020 7:11:13 PM
-
-Commit [1fa2e0be1bbfdbb4e2627bd4154d9e02da61e377](https://github.com/StoneCypher/jssm/commit/1fa2e0be1bbfdbb4e2627bd4154d9e02da61e377)
-
-Author: `John Haugeland `
-
-  * first steps: centralize the constants
-
-
-
-
  
 
  
@@ -8865,38 +10837,6 @@ Author: `John Haugeland `
 
 
 
- 
-
- 
-
-## [Untagged] - 5/6/2019 9:11:54 PM
-
-Commit [6a6dee46986db783cebbb6d7f7df9be594f61be6](https://github.com/StoneCypher/jssm/commit/6a6dee46986db783cebbb6d7f7df9be594f61be6)
-
-Author: `John Haugeland `
-
-Merges [816a498, e98824f]
-
-  * WIP on (no branch): 816a498 attempt to surgery the lcov directly :|
-
-
-
-
- 
-
- 
-
-## [Untagged] - 5/6/2019 9:11:54 PM
-
-Commit [e98824f54254cd8b32a755def3a5e0e6d936f842](https://github.com/StoneCypher/jssm/commit/e98824f54254cd8b32a755def3a5e0e6d936f842)
-
-Author: `John Haugeland `
-
-  * index on (no branch): 816a498 attempt to surgery the lcov directly :|
-
-
-
-
  
 
  
diff --git a/src/doc_md/CHANGELOG.md b/src/doc_md/CHANGELOG.md
index 486562e6..ed8ae052 100644
--- a/src/doc_md/CHANGELOG.md
+++ b/src/doc_md/CHANGELOG.md
@@ -2,7 +2,7 @@
 
 All notable changes to this project will be documented in this file.
 
-961 merges; 129 releases; Changlogging the last 10 commits; Full changelog at [CHANGELOG.long.md](CHANGELOG.long.md)
+1076 merges; 178 releases; Changlogging the last 10 commits; Full changelog at [CHANGELOG.long.md](CHANGELOG.long.md)
 
 
 
@@ -12,7 +12,7 @@ All notable changes to this project will be documented in this file.
 
 Published tags:
 
-5.76.2, 5.76.0, 5.75.1, 5.75.0, 5.74.0, 5.73.1, 5.73.0, 5.72.5, 5.72.4, 5.72.3, 5.72.2, 5.72.1, 5.72.0, 5.71.1, 5.71.0, 5.70.36, 5.70.35, 5.70.34, 5.70.33, 5.70.32, 5.70.31, 5.70.30, 5.70.29, 5.70.28, 5.70.27, 5.70.26, 5.70.25, 5.70.24, 5.70.23, 5.70.22, 5.70.21, 5.70.20, 5.70.19, 5.70.18, 5.70.16, 5.70.15, 5.70.14, 5.70.13, 5.70.12, 5.70.11, 5.70.10, 5.70.9, 5.70.8, 5.70.7, 5.70.6, 5.70.5, 5.70.4, 5.70.3, 5.70.2, 5.70.1, 5.70.0, 5.69.4, 5.69.3, 5.69.2, 5.69.0, 5.68.0, 5.67.2, 5.67.0, 5.66.0, 5.65.14, 5.65.12, 5.65.11, 5.65.10, 5.65.9, 5.65.8, 5.65.7, 5.65.5, 5.65.4, 5.65.3, 5.65.2, 5.65.1, 5.65.0, 5.64.2, 5.64.1, 5.64.0, 5.63.0, 5.62.0, 5.61.4, 5.61.3, 5.61.2, 5.61.1, 5.60.4, 5.60.3, 5.60.0, 5.59.1, 5.59.0, 5.58.1, 5.58.0, 5.57.1, 5.57.0, 5.56.2, 5.56.1, 5.55.0, 5.54.0, 5.53.0, 5.52.0, 5.51.0, 5.50.0, 5.49.0, 5.48.0, 5.47.0, 5.46.0, 5.45.2, 5.45.0, 5.44.0, 5.43.2, v5.42.0, 5.42.0, v5.41.15, 5.41.15, v5.41.14, 5.41.14, v5.41.12, 5.41.12, v5.41.10, 5.41.10, v5.41.9, 5.41.9, v5.41.8, 5.41.8, v5.41.7, v5.41.2, v5.41.1, v5.32.14, 5.14.0, 5.12.0, 5.11.12, 5.11.1, 5.11.0
+5.87.0, 5.86.3, 5.86.2, 5.86.1, 5.86.0, 5.85.11, 5.85.10, 5.85.9, 5.85.8, 5.85.7, 5.85.6, 5.85.5, 5.85.4, 5.85.3, 5.85.2, 5.85.1, 5.85.0, 5.84.1, 5.84.0, 5.83.2, 5.83.1, 5.83.0, 5.82.5, 5.82.4, 5.82.3, 5.82.2, 5.82.1, 5.82.0, 5.81.2, 5.81.0, 5.80.1, 5.80.0, 5.79.18, 5.79.17, 5.79.16, 5.79.15, 5.79.11, 5.79.10, 5.79.9, 5.79.8, 5.79.6, 5.79.4, 5.79.3, 5.79.2, 5.79.1, 5.79.0, 5.78.0, 5.77.1, 5.77.0, 5.76.2, 5.76.0, 5.75.1, 5.75.0, 5.74.0, 5.73.1, 5.73.0, 5.72.5, 5.72.4, 5.72.3, 5.72.2, 5.72.1, 5.72.0, 5.71.1, 5.71.0, 5.70.36, 5.70.35, 5.70.34, 5.70.33, 5.70.32, 5.70.31, 5.70.30, 5.70.29, 5.70.28, 5.70.27, 5.70.26, 5.70.25, 5.70.24, 5.70.23, 5.70.22, 5.70.21, 5.70.20, 5.70.19, 5.70.18, 5.70.16, 5.70.15, 5.70.14, 5.70.13, 5.70.12, 5.70.11, 5.70.10, 5.70.9, 5.70.8, 5.70.7, 5.70.6, 5.70.5, 5.70.4, 5.70.3, 5.70.2, 5.70.1, 5.70.0, 5.69.4, 5.69.3, 5.69.2, 5.69.0, 5.68.0, 5.67.2, 5.67.0, 5.66.0, 5.65.14, 5.65.12, 5.65.11, 5.65.10, 5.65.9, 5.65.8, 5.65.7, 5.65.5, 5.65.4, 5.65.3, 5.65.2, 5.65.1, 5.65.0, 5.64.2, 5.64.1, 5.64.0, 5.63.0, 5.62.0, 5.61.4, 5.61.3, 5.61.2, 5.61.1, 5.60.4, 5.60.3, 5.60.0, 5.59.1, 5.59.0, 5.58.1, 5.58.0, 5.57.1, 5.57.0, 5.56.2, 5.56.1, 5.55.0, 5.54.0, 5.53.0, 5.52.0, 5.51.0, 5.50.0, 5.49.0, 5.48.0, 5.47.0, 5.46.0, 5.45.2, 5.45.0, 5.44.0, 5.43.2, v5.42.0, 5.42.0, v5.41.15, 5.41.15, v5.41.14, 5.41.14, v5.41.12, 5.41.12, v5.41.10, 5.41.10, v5.41.9, 5.41.9, v5.41.8, 5.41.8, v5.41.7, v5.41.2, v5.41.1, v5.32.14, 5.14.0, 5.12.0, 5.11.12, 5.11.1, 5.11.0
 
 
 
@@ -22,18 +22,18 @@ Published tags:
 
  
 
-
+
 
-## [5.76.2] - 7/6/2022 8:27:33 AM
+## [5.87.0] - 12/3/2022 8:18:35 PM
 
-Commit [d1b55ae8944031677c228f06eec6a5a28eb695ac](https://github.com/StoneCypher/jssm/commit/d1b55ae8944031677c228f06eec6a5a28eb695ac)
+Commit [85963d8c154225916ec9bf1f494c480ca033dec9](https://github.com/StoneCypher/jssm/commit/85963d8c154225916ec9bf1f494c480ca033dec9)
 
 Author: `John Haugeland `
 
-Merges [813d866, 40677c7]
+Merges [dbb82ae, d6f77d1]
 
-  * Merge pull request #510 from StoneCypher/BumpCloc
-  * Bump CLOC, fixes StoneCypher/fsl#995
+  * Merge pull request #549 from StoneCypher/next_data
+  * Next data
 
 
 
@@ -42,13 +42,13 @@ Merges [813d866, 40677c7]
 
  
 
-## [Untagged] - 7/5/2022 1:24:10 PM
+## [Untagged] - 12/3/2022 7:40:06 PM
 
-Commit [40677c744241e590d901c317cdcc0046833a5257](https://github.com/StoneCypher/jssm/commit/40677c744241e590d901c317cdcc0046833a5257)
+Commit [d6f77d1be4cf107f2eda1cfddca81d4ebcfc7c99](https://github.com/StoneCypher/jssm/commit/d6f77d1be4cf107f2eda1cfddca81d4ebcfc7c99)
 
 Author: `John Haugeland `
 
-  * Uh, you have to git add to git commit, dummy
+  * forgot version bump
 
 
 
@@ -57,15 +57,13 @@ Author: `John Haugeland `
 
  
 
-## [Untagged] - 7/5/2022 1:04:10 PM
+## [Untagged] - 12/3/2022 7:32:06 PM
 
-Commit [58e88fec3f6412cadfc762f646ed50f6bc10eac6](https://github.com/StoneCypher/jssm/commit/58e88fec3f6412cadfc762f646ed50f6bc10eac6)
+Commit [e6227e3d26828277c002ff0dd67899ab89771fc2](https://github.com/StoneCypher/jssm/commit/e6227e3d26828277c002ff0dd67899ab89771fc2)
 
 Author: `John Haugeland `
 
-Merges [1cc0629, 0cc8f7b]
-
-  * WIP on IntroducingTheKitchenSinkDragon: 1cc0629 Sequester the stoch tests until they're more complete
+  * next_data, fixes StoneCypher/fsl#1233
 
 
 
@@ -74,13 +72,13 @@ Merges [1cc0629, 0cc8f7b]
 
  
 
-## [Untagged] - 7/5/2022 1:04:10 PM
+## [Untagged] - 12/2/2022 10:48:55 PM
 
-Commit [0cc8f7bad92e4327128237bc9600cedd2e7cbb94](https://github.com/StoneCypher/jssm/commit/0cc8f7bad92e4327128237bc9600cedd2e7cbb94)
+Commit [5fa6e48645cb75fcd5fe38e6ff08c0d5d64a7a23](https://github.com/StoneCypher/jssm/commit/5fa6e48645cb75fcd5fe38e6ff08c0d5d64a7a23)
 
 Author: `John Haugeland `
 
-  * index on IntroducingTheKitchenSinkDragon: 1cc0629 Sequester the stoch tests until they're more complete
+  * nextData underway
 
 
 
@@ -89,18 +87,16 @@ Author: `John Haugeland `
 
  
 
-
+
 
-## [5.76.0] - 7/5/2022 1:02:57 PM
+## [5.86.3] - 11/12/2022 6:09:16 PM
 
-Commit [813d8668300b88e72c0598ec9b5b19fce777d05e](https://github.com/StoneCypher/jssm/commit/813d8668300b88e72c0598ec9b5b19fce777d05e)
+Commit [dbb82aefc2744729fd17108d33d19f504dc1783e](https://github.com/StoneCypher/jssm/commit/dbb82aefc2744729fd17108d33d19f504dc1783e)
 
 Author: `John Haugeland `
 
-Merges [bdea503, 1cc0629]
-
-  * Merge pull request #509 from StoneCypher/IntroducingTheKitchenSinkDragon
-  * Introducing the kitchen sink dragon
+  * Implement override, implement in machine, allow override attribute
+  * Fixes StoneCypher/fsl#1228, fixes StoneCypher/fsl#1222, fixes StoneCypher/fsl#1232
 
 
 
@@ -109,13 +105,18 @@ Merges [bdea503, 1cc0629]
 
  
 
-## [Untagged] - 7/5/2022 12:58:07 PM
+
+
+## [5.86.2] - 11/12/2022 12:49:23 PM
 
-Commit [1cc0629fd1afa845b074c7f6dd2fa3ae16284429](https://github.com/StoneCypher/jssm/commit/1cc0629fd1afa845b074c7f6dd2fa3ae16284429)
+Commit [a033eb38e784cbc5c6bf15bef576b69bb935f9b2](https://github.com/StoneCypher/jssm/commit/a033eb38e784cbc5c6bf15bef576b69bb935f9b2)
 
 Author: `John Haugeland `
 
-  * Sequester the stoch tests until they're more complete
+Merges [48b4f92, 99a5fd6]
+
+  * Merge pull request #548 from StoneCypher/AllowsOverrideInCompiler
+  * allows override in compiler, constructor config to allow/disallow override, getters for override, cfg override, machine override
 
 
 
@@ -124,13 +125,14 @@ Author: `John Haugeland `
 
  
 
-## [Untagged] - 7/5/2022 8:08:12 AM
+## [Untagged] - 11/12/2022 12:44:20 PM
 
-Commit [6ea28bad46da225e3593c294837d397234e0a84d](https://github.com/StoneCypher/jssm/commit/6ea28bad46da225e3593c294837d397234e0a84d)
+Commit [99a5fd66ee5a342814cf34d89fb6dccc2f4ac7e9](https://github.com/StoneCypher/jssm/commit/99a5fd66ee5a342814cf34d89fb6dccc2f4ac7e9)
 
 Author: `John Haugeland `
 
-  * non-shrinkable proof of concept
+  * allows override in compiler, constructor config to allow/disallow override, getters for override, cfg override, machine override
+  * fixes StoneCypher/fsl#1225, fixes StoneCypher/fsl#1227, fixes StoneCypher/fsl#1229, fixes StoneCypher/fsl#1230, fixes StoneCypher/fsl#1231
 
 
 
@@ -139,13 +141,15 @@ Author: `John Haugeland `
 
  
 
-## [Untagged] - 7/4/2022 11:08:37 PM
+
+
+## [5.86.1] - 11/11/2022 6:41:15 PM
 
-Commit [86706ce989f8651b79f58dce6cf2511f43fa0629](https://github.com/StoneCypher/jssm/commit/86706ce989f8651b79f58dce6cf2511f43fa0629)
+Commit [48b4f928eb1a4597122b64e6eea38a57c19a112f](https://github.com/StoneCypher/jssm/commit/48b4f928eb1a4597122b64e6eea38a57c19a112f)
 
 Author: `John Haugeland `
 
-  * First draft of the KSD already caught a bug, removes equals from followup atom characters, fixes StoneCypher/fsl#993
+  * Allow override attribute in grammar, fixes StoneCypher/fsl#1226
 
 
 
@@ -154,30 +158,30 @@ Author: `John Haugeland `
 
  
 
-## [Untagged] - 7/3/2022 2:16:27 PM
+
 
-Commit [604f0dda3438d81a9209013d77caccc3b89cdd20](https://github.com/StoneCypher/jssm/commit/604f0dda3438d81a9209013d77caccc3b89cdd20)
+## [5.86.0] - 11/11/2022 6:22:48 PM
+
+Commit [31077c9256ee31f80398460b3af95bc65a8dbc3a](https://github.com/StoneCypher/jssm/commit/31077c9256ee31f80398460b3af95bc65a8dbc3a)
 
 Author: `John Haugeland `
 
-  * Update typescript, typedoc, and the two typescript-eslint plugins
+Merges [793f2fc, 3941c30]
 
+  * Merge pull request #547 from StoneCypher/allows_override
+  * .allows_override fixes StoneCypher/fsl#1224
 
 
 
- 
 
  
 
-
+ 
 
-## [5.75.1] - 7/3/2022 1:49:19 PM
+## [Untagged] - 11/11/2022 6:16:32 PM
 
-Commit [bdea50316e8e826af73a4e6ab39f925492328c51](https://github.com/StoneCypher/jssm/commit/bdea50316e8e826af73a4e6ab39f925492328c51)
+Commit [3941c3000e8544e6b674b4a060abb93a8f5c3455](https://github.com/StoneCypher/jssm/commit/3941c3000e8544e6b674b4a060abb93a8f5c3455)
 
 Author: `John Haugeland `
 
-Merges [cb76475, f084d51]
-
-  * Merge pull request #507 from StoneCypher/PutClocMetricsInReadme
-  * Cleanup stuff; suppress warnings about non-exported types, fixes StoneCypher/fsl#988
\ No newline at end of file
+  * .allows_override fixes StoneCypher/fsl#1224
\ No newline at end of file
diff --git a/src/doc_md/FeatureComparison.md b/src/doc_md/FeatureComparison.md
index 5b11ddf6..fc58370e 100644
--- a/src/doc_md/FeatureComparison.md
+++ b/src/doc_md/FeatureComparison.md
@@ -1,5 +1,2161 @@
 # Feature Comparison
 
-Does your machine do what you need?
+A quick look at what machines offer what functionality, across the 16 most
+popular FSMs on NPM at the time of writing.  Updates and extensions are
+encouraged.
 
-# TODO
\ No newline at end of file
+Definitions and a change link follow the tables.
+
+

+
+
+  
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+
Language features
jssmXStatejavascript-state-machinemachinafinityfsm-iteratorfsm-as-promisedstately.jsstate-machinenode-statefsm-eventfsmstentrobot3moodgrammar-graph
States16✅✅✅✅✅✅✅✅✅✅✅✅✅✅✅✅
Transitions14✅✅✅✅✅❌✅✅✅✅✅✅❌✅✅❌
Actions11✅✅✅❌✅❌✅✅✅✅✅✅✅❌❌❌
Data6✅✅✅❌✅❌❌❌❌❌❌❌✅✅❌❌
TypeScript data2✅✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌
General hooks7✅✅❌❌✅❌✅❌✅❌❌❌✅✅❌❌
Specific hooks10✅❌✅✅✅❌✅✅✅✅✅❌❌✅❌❌
Post-hooks4✅❌❌❌❌❌✅✅✅❌❌❌❌❌❌❌
Hook rejection4✅✅❌❌✅❌❌❌❌❌❌❌❌✅❌❌
Transactions1✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Extending machines3❌✅❌✅❌❌❌❌❌❌❌❌❌✅❌❌
Machine composition3❌❌❌❌✅❌❌❌❌❌❌✅❌✅❌❌
Dynamic graphs2❌❌❌❌❌❌❌❌✅❌❌❌❌❌✅❌
Properties3✅✅✅❌❌❌❌❌❌❌❌❌❌❌❌❌
Methods2✅❌✅❌❌❌❌❌❌❌❌❌❌❌❌❌
Weighted edges1✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Heirarchical states3❌✅❌✅✅❌❌❌❌❌❌❌❌❌❌❌
State groups2⌚❌❌✅❌❌❌❌❌❌❌❌❌❌❌✅
Timeouts4⌚✅❌✅✅❌❌❌❌✅❌❌❌❌❌❌
Immediates1⌚❌❌❌❌❌❌❌❌❌❌❌❌✅❌❌
Error hooks1✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Input/output tape1⌚❌❌❌❌✅❌❌❌❌❌❌❌❌❌✅
Tape validator1⌚❌❌❌❌❌❌❌❌❌❌❌❌❌❌✅
Termination6✅✅❌❌❌❌✅❌❌❌❌✅❌✅❌✅
Async transitions4❌❌✅❌❌❌✅❌❌❌❌❌❌✅✅❌
Event emitter3⌚✅✅✅❌❌❌❌❌❌❌❌❌❌❌❌
Random walks2✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌✅
Serialization2✅✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Factories4✅❌✅✅❌❌❌❌❌❌❌❌❌✅❌❌
Named instances2✅❌❌✅❌❌❌❌❌❌❌❌❌❌❌❌
Automatic API1⌚❌❌❌❌❌❌✅❌❌❌❌❌❌❌❌
Count1913101110286754541246
Notations
jssmXStatejavascript-state-machinemachinafinityfsm-iteratorfsm-as-promisedstately.jsstate-machinenode-statefsm-eventfsmstentrobot3moodgrammar-graph
String DSL3✅❌❌❌❌❌❌❌✅✅❌❌❌❌❌❌
Wildcards1❌❌❌❌❌❌❌❌❌✅❌❌❌❌❌❌
Stripes0⌚❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Cycles0⌚❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Kinds0⌚❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
State spread1✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Complex labels0⌚❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Count2000000001200000
API
jssmXStatejavascript-state-machinemachinafinityfsm-iteratorfsm-as-promisedstately.jsstate-machinenode-statefsm-eventfsmstentrobot3moodgrammar-graph
In-place extrapolation1⌚❌❌❌❌❌❌❌❌❌❌❌❌❌❌✅
Graph reflection API7✅✅✅❌✅❌✅❌✅❌❌❌❌❌❌✅
History4✅✅✅❌❌✅❌❌❌❌❌❌❌❌❌❌
State histograms1✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Count3220111010000002
Docs, Support, and Community
jssmXStatejavascript-state-machinemachinafinityfsm-iteratorfsm-as-promisedstately.jsstate-machinenode-statefsm-eventfsmstentrobot3moodgrammar-graph
Defined lifecycle4✅✅✅❌❌❌❌❌✅❌❌❌❌❌❌❌
Detailed errors2✅✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Extend existing objects2❌❌✅❌❌✅❌❌❌❌❌❌❌❌❌❌
Defined start states6✅❌✅✅✅❌✅❌❌❌❌❌❌✅❌❌
Probabilistic starts2✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌✅
In-source debugger1✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Browser debugger2❌❌❌✅❌❌❌❌❌❌❌❌✅❌❌❌
Compiler0⌚❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Cross-compiler0⌚❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Graph renderer4✅✅✅❌❌❌✅❌❌❌❌❌❌❌❌❌
Visual styling2✅❌✅❌❌❌❌❌❌❌❌❌❌❌❌❌
Manual5✅✅✅❌❌❌❌❌✅❌❌❌❌✅❌❌
API samples1✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Demo videos2✅✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Tutorial videos2✅✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Chat community3✅✅❌❌❌❌❌❌❌❌❌❌✅❌❌❌
Example library2✅✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Count13862112020002201
Testing
jssmXStatejavascript-state-machinemachinafinityfsm-iteratorfsm-as-promisedstately.jsstate-machinenode-statefsm-eventfsmstentrobot3moodgrammar-graph
100% test coverage1✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Fuzz testing1✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Mutation testing0⌚❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
i18n testing1✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Count3000000000000000
Tools
jssmXStatejavascript-state-machinemachinafinityfsm-iteratorfsm-as-promisedstately.jsstate-machinenode-statefsm-eventfsmstentrobot3moodgrammar-graph
Live editor2✅✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌
CLI1✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
VS Code Extension1❌✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Github Action0⌚❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
URL live-paste1✅❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Linter0⌚❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Minifier0⌚❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌
Count3200000000000000
Totals
jssmXStatejavascript-state-machinemachinafinityfsm-iteratorfsm-as-promisedstately.jsstate-machinenode-statefsm-eventfsmstentrobot3moodgrammar-graph
Language features1914101110286754541246
Notations2000000001200000
API3220111010000002
Docs/support13862112020002201
Testing3000000000000000
Tools3200000000000000
Sum totals432618131241161066561449

+
+

+
+
+
+
+
+ 
+
+ 
+
+## Definitions
+
+By section:
+
+
+
+
+
+ 
+
+ 
+
+###
+
+

+
+  
States

+  

+    The bread and butter of a state machine - the states that the machine is
+    permitted to occupy.  It's hard to understand what a state machine that
+    didn't support states would actually be.  On a traffic light, we probably
+    have red, yellow, green, and off.
+  

+
+  
Transitions

+  

+    A machine that supports transitions allows you to specify which state to
+    move to directly.  Almost all machines support transitions.  A handful of
+    machines do not (usually by only supporting actions instead.)  These are
+    often called go, switch, change,
+    state, set, or assign.
+  

+
+  
Actions

+  

+    Actions are things that can be done, from a given state.  These are distinct
+    from transitions, which specify the end goal, by being a label specifying
+    what's being done, instead; since these are also not part of the input or
+    output alphabets, these are effectively a layer of indirection on behavior.
+    What's useful here is the names can be repeated from different starting
+    points.  To progress in our traffic light without actions, we need to know
+    what color we're on to ask for the successor by title; with actions, we can
+    just teach each color the idea of next.  Actions are sometimes
+    called tasks, raise, signal,
+    event, or do.  In some machines these are mandatory;
+    in FSL they are optional.
+  

+
+  
Data

+  

+    Data is the difference between a Mealy and a Moore machine - data support
+    means you can track more than just states.  In a vending machine, having no
+    data means you need states for every valid sum of coin values (one for five
+    cents, one for ten cents, etc;) having data means you just track
+    a number for what's already contained.  Some machines call this
+    context, or occasionally input.
+  

+
+  
TypeScript data

+  

+    We say the machine supports TypeScript data if the machine's data object
+    type is customizable, is exposed to TypeScript, and can be enforced by
+    TypeScript.  In this way, the machine's data is fully part of the TypeScript
+    system.
+  

+
+  
General hooks

+  

+    Hooks allow you to specify a function that gets called because of something
+    that happened.  Support for general hooks means that you can establish a
+    hook on general or global events, such as "any transition" or "any event."
+  

+
+  
Specific hooks

+  

+    Support for specific hooks means that you can establish a hook on particular
+    states, transitions, or actions.
+  

+
+  
Post-hooks

+  

+    Posthooks fire after a transition is complete, rather than before, and the
+    data passed to the posthook reflects the later configuration.  If you wanted
+    to make an editor that visualized states' actions with buttons, you'd need
+    to use posthooks, not hooks, so that the buttons were for what state they're
+    now on, rather than the ones in the previous configuration.
+  

+
+  
Hook rejection

+  

+    Support for hook rejection means that a given hook is allowed to deny a
+    given behavior.  An example is a state machine representing a user
+    interface, which has a data member representing whether the user is logged
+    in, and which disallows switching to the personal profile when not. Hooks
+    that reject are sometimes called guards, and were called
+    guards in earlier versions of this machine.
+  

+
+  
Transactions

+  

+    In a transactional FSM, everything is transactional - if any hook in a
+    process rejects, none of the other transformations that would have taken
+    place do, and everything is rolled back to the end result of the last
+    successful transition.
+  

+
+  
Extending machines

+  

+    Support for extending machines means that an existing machine can be
+    augmented in place, while keeping its state and any data intact.  This is
+    distinct from changing the source that made a machine and recompiling it;
+    machine extension works on instances, not definitions.
+  

+
+  
Machine composition

+  

+    Machine composition is either the combination of two machines, or the
+    subordination of one machine to another using internal mechanisms.  This is
+    distinct from putting something together externally using hooks.
+  

+
+  
Dynamic graphs

+  

+    In a machine which supports dynamic graphs, the structure of the machine can
+    be changed while it is running, either in its states, its transitions, or
+    its actions.
+  

+
+  
Properties

+  

+    Support for properties means that states can and may be required to express
+    named values.  This can obviate repetitive switching to make decisions based
+    on the state outside, and unify the behavior of things depending on machines
+    under the machines' specification.  A traffic light state machine's light
+    color states might have properties regarding whether you may drive, or
+    whether to go slowly.
+  

+
+  
Methods

+  

+    Support for methods means that states may express named functions.  Consider
+    a state machine representing a network connection, which might be online or
+    offline; it might express a lookup function which falls back to a local
+    cache outside the presence of a network connection, but queries a backend
+    when connected.  This feature, when used fully, makes a state machine
+    equivalent to Strategy Pattern.
+  

+
+  
Weighted edges

+  

+    In a machine with weighted edges, transitions can be randomized, and some
+    probabilities may be stronger than others.  This allows machines to directly
+    model simple probabilities, or probability meshes when used with random
+    walks.  Use of this feature makes a state machine equivalent to a First
+    Order Markhov Chain.
+  

+
+  
Heirarchical states

+  

+    Heirarchical states are a major approach to reducing the number of
+    transitions in a machine, by allowing them to source from or target groups
+    of states rather than individual states, frequently reducing a typical
+    edge count from o(n^2) from state count down towards o(n)
+    from group count.  In an FSM representing a microwave, all states except
+    idle will have an action for cancel, which could be
+    reduced to the non-idle heirarchy.  A limitation of heirarchies is that they
+    generally cannot overlap, and groups frequently need to overlap.
+  

+
+  
State groups

+  

+    Another method of reducing transition count is to allow the definition of
+    arbitrary lists of states, and to treat them as heirarchical groups are
+    treated, as valid source and endpoints.  This is slightly more laborious,
+    but also more flexible, and can be used to implement heirarchical FSMs
+    directly.
+  

+
+  
Timeouts

+  

+    A state with a timeout will, if unchanged and unacted, switch of its own
+    volition to another state after a specified amount of time.  Any transition
+    or action automatically ends this timer.  This is extremely helpful when
+    implementing protocols, network behavior, enemy agent AI, or timed
+    element demonstrations.
+  

+
+  
Immediates

+  

+    In a machine with support for immediates, after a relevant transition,
+    action, or hook to a target state, a new transition will automatically occur
+    to a successor state with no delay.  The most common uses for immediates are
+    merging groups of paths and hooking the groups on the way through, inserting
+    things into history, coursing during parsing and random construction, or
+    construction of transfer states for things that wouldn't otherwise be
+    allowed, such as multiple actions that (eventually) have the same source and
+    destination states.
+  

+
+  
Error hooks

+  

+    An error hook is a hook that's called when an error fires.  Errors are
+    distinct from refusals - asking to switch to a state that isn't allowed, or
+    one that doesn't exist, are refusals, and should not fire this hook.  Errors
+    are for when you ask for things that don't make sense, such as a string with
+    an opening quote but not a closing quote.  Errors of that form are
+    relatively rare in finite state machines, but can be important when dealing
+    with data, dynamic graphs, or combined machines.
+  

+
+  
Input/output tape

+  

+    This is the formal classical finite state machine
+    (Σ,Γ,S,s0,𝛿,F) from the textbooks, which is defined as
+    two alphabets, one set of transformations, an initial state, and two token
+    streams.  From this worldview on finite state machines, the input alphabet
+    Σ is the things that are allowed to be on the input tape; the
+    output alphabet is the your state list by default, but could be changed by
+    your hooks; the set of states S is just the states you've defined;
+    the set of transformations 𝛿 is your transitions, accepts an input
+    symbol (from the tape) if Moore and also some data if Mealy; and
+    the two streams are the input tape and the output tape.  If you'd like to
+    write a FSM as an acceptor or a validator, typically you would use these
+    tape facilities.  These tend to be found in parsing, iteration, and utility
+    oriented machines.  If you are only using the input tape and a halting state
+    (by example, a machine that checks if the input is a number,) you create an
+    acceptor; if you use the output tape to produce a transformed set
+    of symbols (by example, an upper-casing machine,) you have instead made a
+    transducer.  Support for tape is quite rare, despite being high
+    value.
+  

+
+  
Tape validator

+  

+    A machine with tape validation has API to repeatedly use the same machine
+    to validate a set of inputs through tape, without making the user implement
+    the feed machinery repeatedly.  These are found almost exclusively in
+    parsing oriented machines.
+  

+
+  
Termination

+  

+    Machine support for termination implies that a machine pays attention to
+    when a state has no valid exits, frequently offering hooks or callbacks to
+    let the machine user know that a machine has finalized.  This is typically
+    found in parsing and validation oriented machines.
+  

+
+  
Async transitions

+  

+    Asynchronous transitions in machines typically mean that transitions may not
+    be instantaneous, and that the result of a transition may be a callback,
+    promise, or generator, instead of an immediately reflected change.  This
+    approach has tradeoffs.  On the upside, the number of states being tracked
+    is often significantly lower, and as such, the transition count quite a bit
+    lower.  On the other hand, this means that state machines may become locked
+    and unavailable, introducing concurrency concerns, and requiring an api for
+    mechanisms like is_changing.  An alternative approach is to
+    maintain the instantaneous API, and have states representing things
+    underway, which is closer to the fundamental nature of an FSM, single
+    threaded, and more precise, but also more verbose.
+  

+
+  
Event emitter

+  

+    An event emitter emits Javascript events for transitions, actions, and so
+    forth, as a convenient alternative way to notify the outside world besides
+    hooks.  As many Javascript tools consume events, this can remove a lot of
+    dispatch boilerplate.
+  

+
+  
Random walks

+  

+    Random walks allow you to wander over the possibilities in your state
+    machine.  Some state machines, like the canonical weather example, are well
+    suited to using this directly; in others, this is a great way to validate
+    that everything in your machine is reachable in a certain depth
+    (particularly valuable for machines which represent user interfaces.)  This
+    is also frequently a constituent piece of generating state heatmaps.
+  

+
+  
Serialization

+  

+    Serialization permits you to take the current state of a machine (with or
+    without its definition, with or without history, always with data) into a
+    string format which is safe for storage, and can be reliably unpacked again
+    later.  This is highly useful for save states, database storage, things
+    moving through queues, and state exchange.
+  

+
+  
Factories

+  

+    Factories allow you to create new instances of the same machine with other
+    configurations quickly and easily, and make it straightforward to map a
+    container as a set of configurations for new machines, or to treat a machine
+    specification as a generator.  Factories are useful when the same machine
+    will be used in large numbers.  An example would be the people in a game
+    like Roller Coaster Tycoon - every time a new customer enters the park, the
+    factory should spin off a new Person with a set of random preferences,
+    clothes, money, and so forth.
+  

+
+  
Named instances

+  

+    When re-using a machine frequently, such as with a factory method or a
+    generator, it is often useful to name the instances so that you can tell
+    them apart.  By example, this can be useful when making network connections,
+    parsing files in parallel, or when state machines represent assets in a
+    system, such as the people and objects in a video game.  As the number of
+    machines you manage grows, so too grows the value of naming instances.
+  

+
+  
Automatic API

+  

+    In a machine with an automatic API, transitions and/or actions are
+    automatically added to the object's method namespace as functions, so that
+    you don't need to call an indirection like .action('foo'), but
+    instead just .foo().  This can be complex - one may need a slugging
+    function, and collisions might become a problem.  However, this can also
+    yield more readable and usable machines, when done skillfully.
+  

+
+

+
+
+
+
+
+ 
+
+ 
+
+## Updates
+
+Mistake?  Something out of date?  New row or column needed?
+
+[Please let us know.](https://github.com/StoneCypher/fsl/issues/new?assignees=&labels=&template=feature-requesting-template.md&title=Change%20needed%20to%20Feature%20Comparison%20Matrix:&body=Please%20detail%20the%20necessary%20changes%20here&labels=Cleanup,Collected+propaganda,Competititon,Documentation,Help+sidebar,Other+environments,Publicity+and+Visibility)
diff --git a/src/doc_md/GettingStarted.md b/src/doc_md/GettingStarted.md
index 4fad787b..af7fa83c 100644
--- a/src/doc_md/GettingStarted.md
+++ b/src/doc_md/GettingStarted.md
@@ -46,7 +46,7 @@ the library directly in the HTML, from CDN.
 
 At this point, you can already play with the library, in the developer console.
 
-

+

 
 
 
@@ -127,7 +127,7 @@ We'll also add a bit of Javascript to make it usable.
 
 End result should look a bit like this:
 
-

+

 
 
 
@@ -214,7 +214,7 @@ window.onload = () => {
 
 And now, they're linked.
 
-

+

 
 
 
diff --git a/src/doc_md/Shootout.md b/src/doc_md/Shootout.md
index a904a78d..68960125 100644
--- a/src/doc_md/Shootout.md
+++ b/src/doc_md/Shootout.md
@@ -29,16 +29,16 @@ the end.
 
 | Library | Tog | Traf | Matt | Avg |
 | ---- | ---- | ---- | ---- | ---- |
-| jssm | **1** | **2** | **5** | 2.66 |
-| state-machine | 5 | 8 | 14 | 9 |
-| faste | 4 | 14 | 24 | 10.66 |
-| javascript-state-machine | 7 | 13 | **23** | 14.33 |
-| finity | 7 | 10 | 28 | 15 |
-| stately | 8 | 18 | 24 | 16.66 |
-| robot | 17 | 24 | 31 | 24 |
-| xstate | **16** | 36 | 33 | 28.33 |
-| nanostate | 8 | **12** | 15 | 11.66 |
-| machina | 20 | 26 | 36 | 27.33 |
+| jssm | **[1](#jssm-toggle-machine-1-line)** | **[2](#jssm-traffic-light-2-lines)** | **[5](#jssm-states-of-matter-5-lines)** | 2.66 |
+| state-machine | [5](#state-machine-toggle-machine-5-lines) | [8](#state-machine-traffic-light-8-lines) | [14](#state-machine-states-of-matter-14-lines) | 9 |
+| faste | [4](#faste-toggle-machine-4-lines) | [14](#faste-traffic-light-14-lines) | [24](#created-faste-states-of-matter-24-lines) | 10.66 |
+| javascript-state-machine | [7](#javascript-state-machine-toggle-machine-7-lines) | [13](#javascript-state-machine-traffic-light-13-lines) | **[23](#javascript-state-machine-states-of-matter-23-lines)** | 14.33 |
+| finity | [7](#created-finity-toggle-machine-7-lines) | [10](#created-finity-traffic-light-10-lines) | [28](#created-finity-states-of-matter-28-lines) | 15 |
+| stately | [8](#created-stately-toggle-machine-8-lines) | [18](#created-stately-traffic-light-18-lines) | [24](#created-stately-states-of-matter-24-lines) | 16.66 |
+| robot | [17](#created-robot-toggle-machine-17-lines) | [24](#created-robot-traffic-light-24-lines) | [31](#created-robot-states-of-matter-31-lines) | 24 |
+| xstate | **[16](#xstate-toggle-machine-16-lines)** | [36](#created-xstate-traffic-light-36-lines) | [33](#created-xstate-traffic-light-33-lines) | 28.33 |
+| nanostate | [8](#nanostate-toggle-machine-8-lines) | **[12](#nanostate-traffic-light-12-lines)** | [15](#nanostate-states-of-matter-15-lines-❌-cannot-implement) | 11.66 |
+| machina | [20](#machina-toggle-machine-20-lines) | [26](#machina-traffic-light-26-lines) | [36](#machina-states-of-matter-36-lines-❌-cannot-implement) | 27.33 |
 
 
 
@@ -55,21 +55,20 @@ linking them with actions.
 
 | lib | length |
 | ---- | ---- |
-| jssm | 1 |
-| faste | 4 |
-| state-machine | 5 |
-| finity | 7 |
-| javascript-state-machine | 7 |
-| stately | 8 |
-| nanostate | 8 |
-| xstate | 16 |
-| robot | 17 |
-| machina | 20 |
+| jssm | [1](#jssm-toggle-machine-1-line) |
+| faste | [4](#faste-toggle-machine-4-lines) |
+| state-machine | [5](#state-machine-toggle-machine-5-lines) |
+| finity | [7](#created-finity-toggle-machine-7-lines) |
+| javascript-state-machine | [7](#javascript-state-machine-toggle-machine-7-lines) |
+| stately | [8](#created-stately-toggle-machine-8-lines) |
+| nanostate | [8](#nanostate-toggle-machine-8-lines) |
+| xstate | [16](#xstate-toggle-machine-16-lines) |
+| robot | [17](#created-robot-toggle-machine-17-lines) |
+| machina | [20](#machina-toggle-machine-20-lines) |
 
  
 
 ### `jssm` toggle machine, 1 line
-
 ```javascript
 export const toggleMachine = sm`active 'TOGGLE' <=> 'TOGGLE' inactive;`;
 ````
@@ -278,16 +277,16 @@ systems' lingo.)
 
 | lib | length |
 | ---- | ---- |
-| jssm | 2 |
-| state-machine | 8 |
-| finity | 10 |
-| javascript-state-machine | 13 |
-| nanostate | 12 |
-| faste | 14 |
-| stately | 18 |
-| robot | 24 |
-| xstate | 36 |
-| machina | 26 |
+| jssm | [2](#jssm-traffic-light-2-lines) |
+| state-machine | [8](#state-machine-traffic-light-8-lines) |
+| finity | [10](#created-finity-traffic-light-10-lines) |
+| javascript-state-machine | [13](#javascript-state-machine-traffic-light-13-lines) |
+| faste | [14](#faste-traffic-light-14-lines) |
+| stately | [18](#created-stately-traffic-light-18-lines) |
+| robot | [24](#created-robot-traffic-light-24-lines) |
+| xstate | [36](#created-xstate-traffic-light-36-lines) |
+| nanostate | [12](#nanostate-traffic-light-12-lines) |
+| machina | [26](#machina-traffic-light-26-lines) |
 
  
 
@@ -583,16 +582,16 @@ or an edge, in other machines' terminology.)
 
 | lib | length |
 | ---- | ---- |
-| jssm | 5 |
-| state-machine | 14 |
-| nanostate | 15 ❌ |
-| javascript-state-machine | 23 |
-| stately | 24 |
-| faste | 24 |
-| finity | 28 |
-| robot | 31 |
-| xstate | 35 |
-| machina | 36 ❌ |
+| jssm | [5](#jssm-states-of-matter-5-lines) |
+| state-machine | [14](#state-machine-states-of-matter-14-lines) |
+| nanostate | [15](#nanostate-states-of-matter-15-lines-❌-cannot-implement) ❌ |
+| javascript-state-machine | [23](#javascript-state-machine-states-of-matter-23-lines) |
+| stately | [24](#created-stately-states-of-matter-24-lines) |
+| faste | [24](#created-faste-states-of-matter-24-lines) |
+| finity | [28](#created-finity-states-of-matter-28-lines) |
+| robot | [31](#created-robot-states-of-matter-31-lines) |
+| xstate | [33](#created-xstate-traffic-light-33-lines) |
+| machina | [36](#machina-states-of-matter-36-lines-❌-cannot-implement) ❌ |
 
  
 
diff --git a/src/doc_md/WhatAreStateMachines.md b/src/doc_md/WhatAreStateMachines.md
index f04ec8e5..8e3e5ce3 100644
--- a/src/doc_md/WhatAreStateMachines.md
+++ b/src/doc_md/WhatAreStateMachines.md
@@ -1,12 +1,31 @@
 # What are Finite State Machines?
 
+Support tools are important to keeping software running correctly.  As
+programmers move from small software to medium software, they often find that
+teaching the computer more about what's going on, so that the computer can
+meaningfully argue, is a productive strategy.
+
+`Type system`s are an obvious example - if you have a variable meant to store a
+number, and accidentally attempt to assign some text to it, it is useful for
+your programming lanugage or environment to be able to discover and announce the
+mistake.  `Check constraint`s, `foreign key`s, `spec`s, and `unit test`s are
+other examples of teaching the computer to say "no."
+
+`Finite State Machine`s are a very powerful mechanism for teaching the computer
+what's actually happening.  They represent something as a collection of `states`
+(finite because you predefine which ones exist,) then define which states may
+turn into which other states.  Most of the value of a `state machine` comes from
+this modelling, and from refusing inappropriate transitions.
+
 `Finite State Machine`s are a classic tool from the 1950s, meant to allow a
 system to be better defined.  In formal and high safety systems they are a
 critical tool.  FSL, the `Finite State Language`, exists to make them easier to
 write, debug, and maintain.
 
-Most likely, you're already pretty familiar with a lot of state machines.  On
-those grounds, we teach state machines by example.
+Most likely, you're already pretty familiar with a lot of state machines -
+light switches, traffic lights, microwaves, and so forth.  On those grounds, we
+teach state machines by example.
+
 
 
 
@@ -53,6 +72,9 @@ And were we to graph this, it might look like so:
 ![](./SimpleLightSwitch.png)
 
 But, a light switch is hardly convincing, or much worth paying attention to.
+There isn't a whole lot of value here, except for showing notation.
+
+
 
 
 
@@ -67,9 +89,9 @@ The traffic light is maybe the smallest useful state machine.  It's three states
 important that a traffic light doesn't "go backwards."
 
 Traffic lights are directional in several ways.  The important one is color: a
-traffic light that's `Yellow` must next go to `Red`.  If the wrong thing
+traffic light that's `Yellow` must next go to `Red`.  ***If the wrong thing
 happens, and the light goes from `Yellow` to `Green` instead, an accident might
-happen.  People could die.
+happen***.  People could die.
 
 In code, you'd need to do something like this:
 
@@ -94,11 +116,24 @@ function switch_to(next) {
 
 }
 
+switch_to('red');
+switch_to('green');
+switch_to('yellow');
 switch_to('red');
 ```
 
 And that is a rudimentary state machine.
 
+
+
+
+
+ 
+
+ 
+
+## Doing it in FSL
+
 Of course, we're in a state machine programming language and library whose
 design is meant to make them simple, so, we'd write this, instead:
 
@@ -108,7 +143,10 @@ const TrafficLight = sm`
   [Red Yellow Green] -> Off;
 `;
 
-TrafficLight.transition('Red');
+TrafficLight.go('Red');
+TrafficLight.go('Green');
+TrafficLight.go('Yellow');
+TrafficLight.go('Red');
 ```
 
 It's implied that, unless you say otherwise, the first mentioned state is the
@@ -129,27 +167,46 @@ This is, roughly, the value of type systems, check constraints, proof systems,
 some kinds of constraint programming, and arguably of testing and even linting:
 teaching the machine what wrong is, so that it can support you.
 
+
+
+
+
+ 
+
+ 
+
+## Making life easier.
+
 State machines are an extremely powerful tool for machine auditing and machine
-self-diagnosis.  They can also, however, be supportive and convenient.  By
-example, the previous state machine requires a user to know what color it's
-currently in to proceed.  This seems undesirable.  Let's teach it to accept an
-instruction `next` to proeed to whatever the next correct color is:
+self-diagnosis.
+
+They can also, however, be supportive and convenient.  By example, the previous
+version of our traffic light state machine requires a user to know what color
+it's currently in, in order to proceed.
+
+This seems undesirable.  Less thinking is better.
+
+Let's teach our machine to accept an instruction `next` to proeed to whatever
+the correct successor color is:
 
 
 ```fsl
-Off -> Red;
+Off 'enable' -> Red;
 Red 'next' -> Green 'next' -> Yellow 'next' -> Red;
-[Red Yellow Green] -> Off;
+[Red Yellow Green] 'disable' -> Off;
 ```
 
 We didn't have to break off the opening `Off -> Red` that way; the author just
 thinks it's cleaner looking (indeed, this machine can be a one-liner if you
 don't much care about readability.)
 
-Now, we can interact with the machine as such:
+Now, we can interact with the machine in this easier way:
 
 ```typescript
-TrafficLight.action('next');
+TrafficLight.do('enable');  // to red
+TrafficLight.do('next');    // to green
+TrafficLight.do('next');    // to yellow
+TrafficLight.do('next');    // to red
 ```
 
 
@@ -164,6 +221,8 @@ And, already, a bunch of other simple machines are accessable.  Some examples:
 
  
 
+### Three brightness lamp
+
 Three brightness lamp is pretty similar to a traffic light, except that `Off` is
 part of the main loop instead of an extra state:
 
@@ -175,6 +234,8 @@ Off 'touch' -> Bright 'touch' -> Medium 'touch' -> Dim 'touch' -> Off;
 
  
 
+### Locking door
+
 A locking door, by contrast, might have a state for `Unlocked` which responds to
 `open` by switching to `Opened`, but a state `Locked` which responds to `open`
 by going to itself (or perhaps just not expressing the action at all.)
@@ -188,6 +249,8 @@ Locked 'open' -> Locked;
 
  
 
+### States of matter
+
 The basic four states of matter on Earth:
 
 ```fsl
diff --git a/src/md/README_base.md b/src/md/README_base.md
index 68906398..8be7a585 100644
--- a/src/md/README_base.md
+++ b/src/md/README_base.md
@@ -402,7 +402,7 @@ looks like HTML in Javascript, that's a DSL.
 This library implements a simple language for `defining finite state machine`s inside of strings.  For example, this
 `DSL` defines that `'a -> b;'` actually means "create two states, create a transition between them, assign the first as
 the initial state", et cetera.  That micro-language is the `DSL` that we'll be referring to a lot, coming up.  This
-`DSL`'s formal name is `jssm-dot`, because it's a descendant-in-spirit of an older flowcharting language
+`DSL`'s parser's original name was `jssm-dot`, because it's a descendant-in-spirit of an older flowcharting language
 [DOT](http://www.graphviz.org/content/dot-language), from [graphviz](graphviz.org), which is also used to make the
 visualizations in [jssm-viz](https://github.com/StoneCypher/jssm-viz) by way of [viz-js](viz-js.com).
 
@@ -528,7 +528,7 @@ Let's load it and use it!  😀
 ### An introduction to machine design
 
 Let's make a `state machine` for ATMs.  In the process, we will use a lot of core concepts of `finite state machine`s
-and of `jssm-dot`, this library's `DSL`.
+and of `fsl`, this library's `DSL`.
 
 We're going to improve on this [NCSU ATM diagram](https://people.engr.ncsu.edu/efg/210/s99/Notes/fsm/atm.gif) that I
 found:
diff --git a/src/site/typedoc-addon.css b/src/site/typedoc-addon.css
index ddb83006..757087d7 100644
--- a/src/site/typedoc-addon.css
+++ b/src/site/typedoc-addon.css
@@ -69,4 +69,31 @@ html li.pages-entry-depth-4 { padding-left: 75px; }
 html li.pages-entry-depth-5 { padding-left: 90px; }
 
 .youtube-embed        { position: relative; padding-bottom: 56.25%; /* enforces 16:9 aspect */ }
-.youtube-embed iframe { position: absolute; top: 0; left: 0; width: 100%; height: 100%; border: 1px solid black; }
\ No newline at end of file
+.youtube-embed iframe { position: absolute; top: 0; left: 0; width: 100%; height: 100%; border: 1px solid black; }
+
+.frot_th_tab                         { vertical-align: bottom; }
+.frot_th_tab table tbody th          { position: relative; font-weight: normal; padding: 6px 4px; }
+.frot_th_tab tr.headings th          { height: 12em; width: 1.25em; }
+.frot_th_tab td, .frot_th_tab th     { vertical-align: bottom; font-weight: normal; text-align: center; }
+.frot_th_tab table tbody td          { padding: 6px 4px; min-width: 1em; max-width: 1em; }
+.frot                                { transform-origin: 0 0; transform: rotate(-90deg); display: inline-block; position: absolute; left: 0em; bottom: -0.75em; font-weight: 400; }
+.frot_th_tab th span                 { width: 12em; text-align: left; }
+.frot_th_tab .rot                    { left: 0.2em; }
+.frot_th_tab table tr+tr th          { width: 11em; text-align: right; }
+.frot_th_tab th.tablenotch           { background: transparent; border-top-color: transparent; border-left-color: transparent; }
+
+.tsd-panel .frot_th_tab table tbody tr.headings { background: transparent; }
+           .frot_th_tab tr+tr th+th             { width: 1.25em; text-align: center; }
+
+.tsd-panel .frot_th_tab table tr.faketitle    { background: transparent; }
+.tsd-panel .frot_th_tab table tr.faketitle td { background: transparent; border: 0; text-align: left; font-weight: bold; font-size: 150%; padding: 1.5em 0 0.5em 0; }
+
+.sums td { font-weight: bold; }
+
+dt+dd { margin-top: 0.25em; }
+dd+dt { margin-top: 1em; }
+dt    { font-weight: bold; font-size: 110%; }
+dd    { line-height: 120%; padding: 0; margin: 0 0 0 2em; }
+
+dl tt  { background-color: rgba(0,0,0,   0.1); border-radius: 0.25em; display: inline-block; padding: 0 0.1em; }
+dl syn { background-color: rgba(0,0,128, 0.1); border-radius: 0.25em; display: inline-block; padding: 0 0.1em; }
diff --git a/src/ts/jssm-dot.peg b/src/ts/fsl_parser.peg
similarity index 79%
rename from src/ts/jssm-dot.peg
rename to src/ts/fsl_parser.peg
index 3735f608..17d2b9f5 100644
--- a/src/ts/jssm-dot.peg
+++ b/src/ts/fsl_parser.peg
@@ -2,6 +2,10 @@
 // If you're in PegJS Online and see "Missing initializer in const declaration,"
 // go down to the rule Exp and take the typescript type off of the const there
 //
+// Then do the same thing on SubExp
+//
+// Just search for "Reminder"
+//
 // Can't take it out permanently because it's necessary for the typescript chain
 
 
@@ -20,6 +24,11 @@ Theme
   / "default"
   / "modern"
   / "ocean"
+  / "bold"
+
+ThemeOrThemeList
+  = '[' WS? ths:(Theme WS)* th:Theme? ']' { const themes = ths.map(t => t[0]); themes.push(th); return themes; }
+  / th:Theme                              { return [th]; }
 
 
 
@@ -184,9 +193,6 @@ LineStyle
   / "dotted"
   / "dashed"
 
-HexDigit
-  = [0-9a-fA-F]
-
 Char
   = Unescaped
   / Escape Sequence:(
@@ -205,9 +211,12 @@ Char
     )
     { return Sequence; }
 
+Null      = 'null'      { return null; }
+Undefined = 'undefined' { return undefined; }
+
 Escape    = "\\"
 QuoteMark = '"'
-Unescaped = [\x20-\x21\x23-\x5B\x5D-\u10FFFF]  // explicitly omits "
+Unescaped = [\x00-\x21\x23-\x5B\x5D-\uFFFF]  // explicitly omits "
 
 ActionLabelChar
   = ActionLabelUnescaped
@@ -228,7 +237,7 @@ ActionLabelChar
     { return Sequence; }
 
 ActionLabelQuoteMark = "'"
-ActionLabelUnescaped = [\x20-\x26\x28-\x5B\x5D-\u10FFFF]  // explicitly omits ' which is hex 27
+ActionLabelUnescaped = [\x20-\x26\x28-\x5B\x5D-\uFFFF]  // explicitly omits ' which is hex 27
 
 ActionLabel "action label"
   = ActionLabelQuoteMark chars:ActionLabelChar* ActionLabelQuoteMark { return chars.join(""); }
@@ -290,6 +299,15 @@ DecimalDigit
 NonZeroDigit
   = [1-9]
 
+HexDigit
+  = [0-9a-f]i
+
+BinaryDigit
+  = [0-1]
+
+OctalDigit
+  = [0-1]
+
 NonNegNumber "nonneg number"
   = IntegerLiteral "." DecimalDigit* WS? { return parseFloat(text()); }
   / IntegerLiteral                   WS? { return parseFloat(text()); }
@@ -298,6 +316,94 @@ NonNegNumber "nonneg number"
 
 
 
+JsNumericLiteral "number"
+  = literal:JsHexIntegerLiteral      { return literal; }
+  / literal:JsBinaryIntegerLiteral   { return literal; }
+  / literal:NonJsOctalIntegerLiteral { return literal; }
+  / literal:JsDecimalLiteral         { return literal; }
+  / 'NaN'                            { return NaN; }
+  / 'NegativeInfinity'               { return Number.NEGATIVE_INFINITY; }
+  / 'NegativeInf'                    { return Number.NEGATIVE_INFINITY; }
+  / 'NegInfinity'                    { return Number.NEGATIVE_INFINITY; }
+  / 'NegInf'                         { return Number.NEGATIVE_INFINITY; }
+  / 'NInfinity'                      { return Number.NEGATIVE_INFINITY; }
+  / 'NInf'                           { return Number.NEGATIVE_INFINITY; }
+  / '-∞'                             { return Number.NEGATIVE_INFINITY; }
+  / 'PInfinity'                      { return Number.POSITIVE_INFINITY; }
+  / 'Infinity'                       { return Number.POSITIVE_INFINITY; }
+  / 'PInf'                           { return Number.POSITIVE_INFINITY; }
+  / 'Inf'                            { return Number.POSITIVE_INFINITY; }
+  / '∞'                              { return Number.POSITIVE_INFINITY; }
+  / 'Epsilon'                        { return Number.EPSILON; }
+  / '𝜀'                              { return Number.EPSILON; }            // math page epsilon
+  / 'ε'                              { return Number.EPSILON; }            // greek language epsilon
+  / 'Pi'                             { return Math.PI; }
+  / '𝜋'                              { return Math.PI; }
+  / 'π'                              { return Math.PI; }
+  / 'EulerNumber'                    { return Math.E; }
+  / 'E'                              { return Math.E; }
+  / 'e'                              { return Math.E; }
+  / 'Ɛ'                              { return Math.E; }
+  / 'ℇ'                              { return Math.E; }
+  / 'Root2'                          { return Math.SQRT2; }
+  / 'RootHalf'                       { return Math.SQRT1_2; }
+  / 'Ln2'                            { return Math.LN2; }
+  / 'NatLog2'                        { return Math.LN2; }
+  / 'Ln10'                           { return Math.LN10; }
+  / 'NatLog10'                       { return Math.LN10; }
+  / 'Log2E'                          { return Math.LOG2E; }
+  / 'Log10E'                         { return Math.LOG10E; }
+  / 'MaxSafeInt'                     { return Number.MAX_SAFE_INTEGER; }
+  / 'MinSafeInt'                     { return Number.MIN_SAFE_INTEGER; }
+  / 'MaxPosNum'                      { return Number.MAX_VALUE; }
+  / 'MinPosNum'                      { return Number.MIN_VALUE; }
+  / 'Phi'                            { return 1.61803398874989484820; }    // doubles trace 16 decimal digits, so 20 is extra
+  / '𝜑'                              { return 1.61803398874989484820; }
+  / '𝜙'                              { return 1.61803398874989484820; }
+  / 'ϕ'                              { return 1.61803398874989484820; }
+  / 'φ'                              { return 1.61803398874989484820; }
+  / 'EulerConstant'                  { return 0.57721566490153286060; }
+  / 'γ'                              { return 0.57721566490153286060; }
+  / '𝛾'                              { return 0.57721566490153286060; }
+  / 'γ'                              { return 0.57721566490153286060; }
+
+JsDecimalLiteral
+  = JsDecimalIntegerLiteral "." DecimalDigit* JsNExponentPart? { return parseFloat(text()); }
+  /                         "." DecimalDigit+ JsNExponentPart? { return parseFloat(text()); }
+  / JsDecimalIntegerLiteral                   JsNExponentPart? { return parseFloat(text()); }
+
+JsDecimalIntegerLiteral
+  = "0"
+  / NonZeroDigit DecimalDigit*
+
+JsNExponentPart
+  = JsNExponentIndicator JsNSignedInteger
+
+JsNExponentIndicator
+  = "e"i
+
+JsNSignedInteger
+  = [+-]? DecimalDigit+
+
+JsHexIntegerLiteral
+  = "0x"i digits:$HexDigit+ {
+      return parseInt(digits, 16);
+     }
+
+JsBinaryIntegerLiteral
+  = "0b"i digits:$BinaryDigit+ {
+      return parseInt(digits, 2);
+     }
+
+NonJsOctalIntegerLiteral
+  = "0o"i digits:$OctalDigit+ {
+      return parseInt(digits, 8);
+     }
+
+
+
+
+
 SemVer
   = major:IntegerLiteral "." minor:IntegerLiteral "." patch:IntegerLiteral
   { return {
@@ -543,7 +649,7 @@ SingleEdgeColor "single edge color"
   = WS? "edge_color" WS? ":" WS? value:Color WS? ";" WS? { return {key:'single_edge_color', value:value}; }
 
 TransitionLineStyle "transition line style"
-  = WS? "linestyle" WS? ":" WS? value:LineStyle WS? ";" WS? { return {key:'transition_line_style', value:value}; }
+  = WS? "line-style" WS? ":" WS? value:LineStyle WS? ";" WS? { return {key:'transition_line_style', value:value}; }
 
 ArrowItems
   = SingleEdgeColor
@@ -657,37 +763,55 @@ GvizLayout
   / "fdp"
   / "neato"
 
-StateItemShapeKey
-  = "shape"
-
-StateItemShape
-  = WS? "shape" WS? ":" WS? value:GvizShape WS? ";" WS? { return {key:"shape", value:value}; }
-
-StateItem
-  = StateItemShape
+// StateItemShapeKey
+//   = "shape"
+//
+// StateItemShape
+//   = WS? "shape" WS? ":" WS? value:GvizShape WS? ";" WS? { return { shape: value }; }
+//
+// StateItem
+//   = StateItemShape
 
 StateItems
-  = StateItem+
+  = StateDeclarationItem+
 
 ConfigState
   = WS? "state" WS? ":" WS? "{" WS? state_items:StateItems? WS? "};" WS? {
-    return { key: "state_config", value: { config_kind: "state", config_items: state_items || [] } };
+    return { key: "default_state_config", value: state_items || [] };
   }
 
 ConfigStartState
   = WS? "start_state" WS? ":" WS? "{" WS? state_items:StateItems? WS? "};" WS? {
-    return { key: "state_config", value: { config_kind: "in_state", config_items: state_items || [] } };
+    return { key: "default_start_state_config", value: state_items || [] };
   }
 
 ConfigEndState
   = WS? "end_state" WS? ":" WS? "{" WS? state_items:StateItems? WS? "};" WS? {
-    return { key: "state_config", value: { config_kind: "out_state", config_items: state_items || [] } };
+    return { key: "default_end_state_config", value: state_items || [] };
+  }
+
+ConfigActiveState
+  = WS? "active_state" WS? ":" WS? "{" WS? state_items:StateItems? WS? "};" WS? {
+    return { key: "default_active_state_config", value: state_items || [] };
+  }
+
+ConfigTerminalState
+  = WS? "terminal_state" WS? ":" WS? "{" WS? state_items:StateItems? WS? "};" WS? {
+    return { key: "default_terminal_state_config", value: state_items || [] };
+  }
+
+ConfigHookedState
+  = WS? "hooked_state" WS? ":" WS? "{" WS? state_items:StateItems? WS? "};" WS? {
+    return { key: "default_hooked_state_config", value: state_items || [] };
   }
 
 ConfigAnyState
   = ConfigState
   / ConfigStartState
   / ConfigEndState
+  / ConfigActiveState
+  / ConfigTerminalState
+  / ConfigHookedState
 
 
 
@@ -717,14 +841,14 @@ TransitionKey
   / "todo"
 
 TransitionItem
-  = transitionkey:TransitionKey ":" value:Label ";" { return {key:transitionkey, value:value}; }
+  = key:TransitionKey ":" value:Label ";" { return { key, value }; }
 
 TransitionItems
   = GraphDefaultEdgeColor
   / TransitionItem+
 
 GraphDefaultEdgeColor "graph default edge color"
-  = WS? "edge_color" WS? ":" WS? value:Color WS? ";" WS? { return {key:'graph_default_edge_color', value:value}; }
+  = WS? "edge_color" WS? ":" WS? value:Color WS? ";" WS? { return { key:'graph_default_edge_color', value }; }
 
 ConfigTransition
   = WS? "transition" WS? ":" WS? "{" WS? transition_items:TransitionItems? WS? "};" WS? {
@@ -736,16 +860,28 @@ ConfigTransition
 
 
 ConfigGraphLayout
-  = WS? "graph_layout"   WS? ":" WS? value:GvizLayout WS? ";" WS? { return {key:"graph_layout",   value:value}; }
+  = WS? "graph_layout"    WS? ":" WS? value:GvizLayout WS? ";" WS? { return { key: "graph_layout",    value: value }; }
 
 ConfigStartNodes
-  = WS? "start_states"   WS? ":" WS? value:LabelList  WS? ";" WS? { return {key:"start_states",   value:value}; }
+  = WS? "start_states"    WS? ":" WS? value:LabelList  WS? ";" WS? { return { key: "start_states",    value: value }; }
 
 ConfigEndNodes
-  = WS? "end_states"     WS? ":" WS? value:LabelList  WS? ";" WS? { return {key:"end_states",     value:value}; }
+  = WS? "end_states"      WS? ":" WS? value:LabelList  WS? ";" WS? { return { key: "end_states",      value: value }; }
 
 ConfigGraphBgColor
-  = WS? "graph_bg_color" WS? ":" WS? value:Color      WS? ";" WS? { return {key:"graph_bg_color", value:value}; }
+  = WS? "graph_bg_color"  WS? ":" WS? value:Color      WS? ";" WS? { return { key: "graph_bg_color",  value: value }; }
+
+ConfigAllowsOverride
+  = WS? "allows_override" WS? ":" WS? value:OverrideT  WS? ";" WS? { return { key: "allows_override", value: value }; }
+
+
+
+
+
+OverrideT
+  = 'true'      { return true;      }
+  / 'false'     { return false;     }
+  / 'undefined' { return undefined; }
 
 
 
@@ -760,6 +896,7 @@ Config "configuration"
   / ConfigAnyState
   / ConfigValidation
   / ConfigGraphBgColor
+  / ConfigAllowsOverride
 
 
 
@@ -833,7 +970,7 @@ FslVersion
   = WS? "fsl_version"         WS? ":" WS? value:SemVer               WS? ";" WS? { return { key: "fsl_version", value }; }
 
 MachineTheme
-  = WS? "theme"               WS? ":" WS? value:Theme                WS? ";" WS? { return { key: "theme", value }; }
+  = WS? "theme"               WS? ":" WS? value:ThemeOrThemeList     WS? ";" WS? { return { key: "theme", value }; }
 
 MachineFlow
   = WS? "flow"                WS? ":" WS? value:Direction            WS? ";" WS? { return { key: "flow", value }; }
@@ -864,6 +1001,20 @@ MachineAttribute "machine attribute"
 
 
 
+PropertyVal
+  = String
+  / Boolean
+  / JsNumericLiteral
+  / Null
+  / Undefined
+
+
+
+
+
+SdStateLabel "color"
+  = WS? "label"            WS? ":" WS? value:Label     WS? ";" WS? { return { key:'state-label', value }; }
+
 SdStateColor "color"
   = WS? "color"            WS? ":" WS? value:Color     WS? ";" WS? { return { key:'color', value }; }
 
@@ -883,19 +1034,32 @@ SdStateCorners "corners"
   = WS? "corners"          WS? ":" WS? value:Corners   WS? ";" WS? { return { key:'corners', value }; }
 
 SdStateLineStyle "linestyle"
-  = WS? "linestyle"        WS? ":" WS? value:LineStyle WS? ";" WS? { return { key:'linestyle', value }; }
+  = WS? "line-style"       WS? ":" WS? value:LineStyle WS? ";" WS? { return { key:'line-style', value }; }
+  / WS? "linestyle"        WS? ":" WS? value:LineStyle WS? ";" WS? { return { key:'line-style', value }; }
+
+
+SdStateProperty "state property"
+  = WS? "property" WS? ":" WS? name:Atom WS value:PropertyVal               WS? ";" WS? {
+    return { key: 'state_property', name, value }
+  }
+  / WS? "property" WS? ":" WS? name:Atom WS value:PropertyVal WS 'required' WS? ";" WS? {
+    return { key: 'state_property', name, value, required: true }
+  }
+
 
-StateDeclarationItems
-  = SdStateColor
+StateDeclarationItem
+  = SdStateLabel
+  / SdStateColor
   / SdStateTextColor
   / SdStateBackgroundColor
   / SdStateBorderColor
   / SdStateShape
   / SdStateCorners
   / SdStateLineStyle
+  / SdStateProperty
 
 StateDeclarationDesc
-  = "{" WS? items:StateDeclarationItems* WS? "}" { return items; }
+  = "{" WS? items:StateDeclarationItem* WS? "}" { return items; }
 
 StateDeclaration
   = WS? "state" WS name:Label WS? ":" WS? value:StateDeclarationDesc WS? ";" WS? { return { key:'state_declaration', name, value }; }
@@ -911,55 +1075,16 @@ NamedList
 
 
 
-MachinePropertyDefaultNull
-  = 'null'
-
-MachinePropertyDefaultUndefined
-  = 'undefined'
-
-MachinePropertyDefaultBoolean
-  = 'true'
-  / 'false'
-
-MachinePropertyDefaultNumber
-  = '-'? IntegerLiteral "." DecimalDigit* WS? { return parseFloat( text() ); }
-  / '-'? IntegerLiteral                   WS? { return parseFloat( text() ); }
-  / 'Infinity'
-  / 'NegInfinity'
-  / 'NaN'
-  / 'MaxSafeInt'
-  / 'MinSafeInt'
-
-MachinePropertyDefaultString
-  = '"' chars:MachinePropertyDefaultStringCharacter* '"' { return chars.join(''); }
-
-MachinePropertyDefaultStringCharacter
-  = !('"' / "\\") char:.                                     { return char;     }
-  / "\\" sequence:MachinePropertyDefaultStringEscapeSequence { return sequence; }
-
-MachinePropertyDefaultStringEscapeSequence
-  = "'"
-  / '"'
-  / "\\"
-  / "b"  { return "\b";   }
-  / "f"  { return "\f";   }
-  / "n"  { return "\n";   }
-  / "r"  { return "\r";   }
-  / "t"  { return "\t";   }
-  / "v"  { return "\x0B"; }
-
 MachinePropertyDefault
-  = MachinePropertyDefaultNull
-  / MachinePropertyDefaultUndefined
-  / MachinePropertyDefaultBoolean
-  / MachinePropertyDefaultNumber
-  / MachinePropertyDefaultString
+  = PropertyVal
 //   / MachinePropertyDefaultArray
 //   / MachinePropertyDefaultObject
 
 MachineProperty
-  = WS? "property" WS? name:Label WS? 'default' WS default_value:MachinePropertyDefault WS? ";" WS? { return { key:'property_definition', name, default_value }; }
-  / WS? "property" WS? name:Label WS?                                                       ";" WS? { return { key:'property_definition', name };          }
+  = WS? "property" WS name:Label WS 'default' WS default_value:MachinePropertyDefault WS  'required' WS? ";" WS? { return { key:'property_definition', name, default_value, required: true }; }
+  / WS? "property" WS name:Label                                                      WS  'required' WS? ";" WS? { return { key:'property_definition', name,                required: true }; }
+  / WS? "property" WS name:Label WS 'default' WS default_value:MachinePropertyDefault                WS? ";" WS? { return { key:'property_definition', name, default_value                 }; }
+  / WS? "property" WS name:Label                                                                     WS? ";" WS? { return { key:'property_definition', name                                }; }
 
 
 
@@ -993,4 +1118,4 @@ Term
   / Config
 
 TermList
-  = term:Term*
+  = term:Term*
\ No newline at end of file
diff --git a/src/ts/fsl_parser.ts b/src/ts/fsl_parser.ts
new file mode 100644
index 00000000..5fc2b463
--- /dev/null
+++ b/src/ts/fsl_parser.ts
@@ -0,0 +1,17271 @@
+/*
+ * Generated by PEG.js 0.10.0.
+ *
+ * http://pegjs.org/
+ */
+
+"use strict";
+
+function peg$subclass(child, parent) {
+  function ctor() { this.constructor = child; }
+  ctor.prototype = parent.prototype;
+  child.prototype = new ctor();
+}
+
+function peg$SyntaxError(message, expected, found, location) {
+  this.message  = message;
+  this.expected = expected;
+  this.found    = found;
+  this.location = location;
+  this.name     = "SyntaxError";
+
+  if (typeof Error.captureStackTrace === "function") {
+    Error.captureStackTrace(this, peg$SyntaxError);
+  }
+}
+
+peg$subclass(peg$SyntaxError, Error);
+
+peg$SyntaxError.buildMessage = function(expected, found) {
+  var DESCRIBE_EXPECTATION_FNS = {
+        literal: function(expectation) {
+          return "\"" + literalEscape(expectation.text) + "\"";
+        },
+
+        "class": function(expectation) {
+          var escapedParts = "",
+              i;
+
+          for (i = 0; i < expectation.parts.length; i++) {
+            escapedParts += expectation.parts[i] instanceof Array
+              ? classEscape(expectation.parts[i][0]) + "-" + classEscape(expectation.parts[i][1])
+              : classEscape(expectation.parts[i]);
+          }
+
+          return "[" + (expectation.inverted ? "^" : "") + escapedParts + "]";
+        },
+
+        any: function(expectation) {
+          return "any character";
+        },
+
+        end: function(expectation) {
+          return "end of input";
+        },
+
+        other: function(expectation) {
+          return expectation.description;
+        }
+      };
+
+  function hex(ch) {
+    return ch.charCodeAt(0).toString(16).toUpperCase();
+  }
+
+  function literalEscape(s) {
+    return s
+      .replace(/\\/g, '\\\\')
+      .replace(/"/g,  '\\"')
+      .replace(/\0/g, '\\0')
+      .replace(/\t/g, '\\t')
+      .replace(/\n/g, '\\n')
+      .replace(/\r/g, '\\r')
+      .replace(/[\x00-\x0F]/g,          function(ch) { return '\\x0' + hex(ch); })
+      .replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return '\\x'  + hex(ch); });
+  }
+
+  function classEscape(s) {
+    return s
+      .replace(/\\/g, '\\\\')
+      .replace(/\]/g, '\\]')
+      .replace(/\^/g, '\\^')
+      .replace(/-/g,  '\\-')
+      .replace(/\0/g, '\\0')
+      .replace(/\t/g, '\\t')
+      .replace(/\n/g, '\\n')
+      .replace(/\r/g, '\\r')
+      .replace(/[\x00-\x0F]/g,          function(ch) { return '\\x0' + hex(ch); })
+      .replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return '\\x'  + hex(ch); });
+  }
+
+  function describeExpectation(expectation) {
+    return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
+  }
+
+  function describeExpected(expected) {
+    var descriptions = new Array(expected.length),
+        i, j;
+
+    for (i = 0; i < expected.length; i++) {
+      descriptions[i] = describeExpectation(expected[i]);
+    }
+
+    descriptions.sort();
+
+    if (descriptions.length > 0) {
+      for (i = 1, j = 1; i < descriptions.length; i++) {
+        if (descriptions[i - 1] !== descriptions[i]) {
+          descriptions[j] = descriptions[i];
+          j++;
+        }
+      }
+      descriptions.length = j;
+    }
+
+    switch (descriptions.length) {
+      case 1:
+        return descriptions[0];
+
+      case 2:
+        return descriptions[0] + " or " + descriptions[1];
+
+      default:
+        return descriptions.slice(0, -1).join(", ")
+          + ", or "
+          + descriptions[descriptions.length - 1];
+    }
+  }
+
+  function describeFound(found) {
+    return found ? "\"" + literalEscape(found) + "\"" : "end of input";
+  }
+
+  return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";
+};
+
+function peg$parse(input, options) {
+  options = options !== void 0 ? options : {};
+
+  var peg$FAILED = {},
+
+      peg$startRuleFunctions = { Document: peg$parseDocument },
+      peg$startRuleFunction  = peg$parseDocument,
+
+      peg$c0 = function(e) { return e; },
+      peg$c1 = "none",
+      peg$c2 = peg$literalExpectation("none", false),
+      peg$c3 = "default",
+      peg$c4 = peg$literalExpectation("default", false),
+      peg$c5 = "modern",
+      peg$c6 = peg$literalExpectation("modern", false),
+      peg$c7 = "ocean",
+      peg$c8 = peg$literalExpectation("ocean", false),
+      peg$c9 = "bold",
+      peg$c10 = peg$literalExpectation("bold", false),
+      peg$c11 = "[",
+      peg$c12 = peg$literalExpectation("[", false),
+      peg$c13 = "]",
+      peg$c14 = peg$literalExpectation("]", false),
+      peg$c15 = function(ths, th) { const themes = ths.map(t => t[0]); themes.push(th); return themes; },
+      peg$c16 = function(th) { return [th]; },
+      peg$c17 = "box3d",
+      peg$c18 = peg$literalExpectation("box3d", false),
+      peg$c19 = "polygon",
+      peg$c20 = peg$literalExpectation("polygon", false),
+      peg$c21 = "ellipse",
+      peg$c22 = peg$literalExpectation("ellipse", false),
+      peg$c23 = "oval",
+      peg$c24 = peg$literalExpectation("oval", false),
+      peg$c25 = "circle",
+      peg$c26 = peg$literalExpectation("circle", false),
+      peg$c27 = "point",
+      peg$c28 = peg$literalExpectation("point", false),
+      peg$c29 = "egg",
+      peg$c30 = peg$literalExpectation("egg", false),
+      peg$c31 = "triangle",
+      peg$c32 = peg$literalExpectation("triangle", false),
+      peg$c33 = "plaintext",
+      peg$c34 = peg$literalExpectation("plaintext", false),
+      peg$c35 = "plain",
+      peg$c36 = peg$literalExpectation("plain", false),
+      peg$c37 = "diamond",
+      peg$c38 = peg$literalExpectation("diamond", false),
+      peg$c39 = "trapezium",
+      peg$c40 = peg$literalExpectation("trapezium", false),
+      peg$c41 = "parallelogram",
+      peg$c42 = peg$literalExpectation("parallelogram", false),
+      peg$c43 = "house",
+      peg$c44 = peg$literalExpectation("house", false),
+      peg$c45 = "pentagon",
+      peg$c46 = peg$literalExpectation("pentagon", false),
+      peg$c47 = "hexagon",
+      peg$c48 = peg$literalExpectation("hexagon", false),
+      peg$c49 = "septagon",
+      peg$c50 = peg$literalExpectation("septagon", false),
+      peg$c51 = "octagon",
+      peg$c52 = peg$literalExpectation("octagon", false),
+      peg$c53 = "doublecircle",
+      peg$c54 = peg$literalExpectation("doublecircle", false),
+      peg$c55 = "doubleoctagon",
+      peg$c56 = peg$literalExpectation("doubleoctagon", false),
+      peg$c57 = "tripleoctagon",
+      peg$c58 = peg$literalExpectation("tripleoctagon", false),
+      peg$c59 = "invtriangle",
+      peg$c60 = peg$literalExpectation("invtriangle", false),
+      peg$c61 = "invtrapezium",
+      peg$c62 = peg$literalExpectation("invtrapezium", false),
+      peg$c63 = "invhouse",
+      peg$c64 = peg$literalExpectation("invhouse", false),
+      peg$c65 = "Mdiamond",
+      peg$c66 = peg$literalExpectation("Mdiamond", false),
+      peg$c67 = "Msquare",
+      peg$c68 = peg$literalExpectation("Msquare", false),
+      peg$c69 = "Mcircle",
+      peg$c70 = peg$literalExpectation("Mcircle", false),
+      peg$c71 = "rectangle",
+      peg$c72 = peg$literalExpectation("rectangle", false),
+      peg$c73 = "rect",
+      peg$c74 = peg$literalExpectation("rect", false),
+      peg$c75 = "square",
+      peg$c76 = peg$literalExpectation("square", false),
+      peg$c77 = "star",
+      peg$c78 = peg$literalExpectation("star", false),
+      peg$c79 = "underline",
+      peg$c80 = peg$literalExpectation("underline", false),
+      peg$c81 = "cylinder",
+      peg$c82 = peg$literalExpectation("cylinder", false),
+      peg$c83 = "note",
+      peg$c84 = peg$literalExpectation("note", false),
+      peg$c85 = "tab",
+      peg$c86 = peg$literalExpectation("tab", false),
+      peg$c87 = "folder",
+      peg$c88 = peg$literalExpectation("folder", false),
+      peg$c89 = "box",
+      peg$c90 = peg$literalExpectation("box", false),
+      peg$c91 = "component",
+      peg$c92 = peg$literalExpectation("component", false),
+      peg$c93 = "promoter",
+      peg$c94 = peg$literalExpectation("promoter", false),
+      peg$c95 = "cds",
+      peg$c96 = peg$literalExpectation("cds", false),
+      peg$c97 = "terminator",
+      peg$c98 = peg$literalExpectation("terminator", false),
+      peg$c99 = "utr",
+      peg$c100 = peg$literalExpectation("utr", false),
+      peg$c101 = "primersite",
+      peg$c102 = peg$literalExpectation("primersite", false),
+      peg$c103 = "restrictionsite",
+      peg$c104 = peg$literalExpectation("restrictionsite", false),
+      peg$c105 = "fivepoverhang",
+      peg$c106 = peg$literalExpectation("fivepoverhang", false),
+      peg$c107 = "threepoverhang",
+      peg$c108 = peg$literalExpectation("threepoverhang", false),
+      peg$c109 = "noverhang",
+      peg$c110 = peg$literalExpectation("noverhang", false),
+      peg$c111 = "assembly",
+      peg$c112 = peg$literalExpectation("assembly", false),
+      peg$c113 = "signature",
+      peg$c114 = peg$literalExpectation("signature", false),
+      peg$c115 = "insulator",
+      peg$c116 = peg$literalExpectation("insulator", false),
+      peg$c117 = "ribosite",
+      peg$c118 = peg$literalExpectation("ribosite", false),
+      peg$c119 = "rnastab",
+      peg$c120 = peg$literalExpectation("rnastab", false),
+      peg$c121 = "proteasesite",
+      peg$c122 = peg$literalExpectation("proteasesite", false),
+      peg$c123 = "proteinstab",
+      peg$c124 = peg$literalExpectation("proteinstab", false),
+      peg$c125 = "rpromoter",
+      peg$c126 = peg$literalExpectation("rpromoter", false),
+      peg$c127 = "rarrow",
+      peg$c128 = peg$literalExpectation("rarrow", false),
+      peg$c129 = "larrow",
+      peg$c130 = peg$literalExpectation("larrow", false),
+      peg$c131 = "lpromoter",
+      peg$c132 = peg$literalExpectation("lpromoter", false),
+      peg$c133 = "record",
+      peg$c134 = peg$literalExpectation("record", false),
+      peg$c135 = peg$otherExpectation("forward light arrow ->"),
+      peg$c136 = "->",
+      peg$c137 = peg$literalExpectation("->", false),
+      peg$c138 = "\u2192",
+      peg$c139 = peg$literalExpectation("\u2192", false),
+      peg$c140 = function() { return "->"; },
+      peg$c141 = peg$otherExpectation("two way light arrow <->"),
+      peg$c142 = "<->",
+      peg$c143 = peg$literalExpectation("<->", false),
+      peg$c144 = "\u2194",
+      peg$c145 = peg$literalExpectation("\u2194", false),
+      peg$c146 = function() { return "<->"; },
+      peg$c147 = peg$otherExpectation("back light arrow <-"),
+      peg$c148 = "<-",
+      peg$c149 = peg$literalExpectation("<-", false),
+      peg$c150 = "\u2190",
+      peg$c151 = peg$literalExpectation("\u2190", false),
+      peg$c152 = function() { return "<-"; },
+      peg$c153 = peg$otherExpectation("forward fat arrow =>"),
+      peg$c154 = "=>",
+      peg$c155 = peg$literalExpectation("=>", false),
+      peg$c156 = "\u21D2",
+      peg$c157 = peg$literalExpectation("\u21D2", false),
+      peg$c158 = function() { return "=>"; },
+      peg$c159 = peg$otherExpectation("two way fat arrow <=>"),
+      peg$c160 = "<=>",
+      peg$c161 = peg$literalExpectation("<=>", false),
+      peg$c162 = "\u21D4",
+      peg$c163 = peg$literalExpectation("\u21D4", false),
+      peg$c164 = function() { return "<=>"; },
+      peg$c165 = peg$otherExpectation("back fat arrow <="),
+      peg$c166 = "<=",
+      peg$c167 = peg$literalExpectation("<=", false),
+      peg$c168 = "\u21D0",
+      peg$c169 = peg$literalExpectation("\u21D0", false),
+      peg$c170 = function() { return "<="; },
+      peg$c171 = peg$otherExpectation("forward tilde arrow ~>"),
+      peg$c172 = "~>",
+      peg$c173 = peg$literalExpectation("~>", false),
+      peg$c174 = "\u219B",
+      peg$c175 = peg$literalExpectation("\u219B", false),
+      peg$c176 = function() { return "~>"; },
+      peg$c177 = peg$otherExpectation("two way tilde arrow <~>"),
+      peg$c178 = "<~>",
+      peg$c179 = peg$literalExpectation("<~>", false),
+      peg$c180 = "\u21AE",
+      peg$c181 = peg$literalExpectation("\u21AE", false),
+      peg$c182 = function() { return "<~>"; },
+      peg$c183 = peg$otherExpectation("back tilde arrow <~"),
+      peg$c184 = "<~",
+      peg$c185 = peg$literalExpectation("<~", false),
+      peg$c186 = "\u219A",
+      peg$c187 = peg$literalExpectation("\u219A", false),
+      peg$c188 = function() { return "<~"; },
+      peg$c189 = peg$otherExpectation("light fat arrow <-=>"),
+      peg$c190 = "<-=>",
+      peg$c191 = peg$literalExpectation("<-=>", false),
+      peg$c192 = "\u2190\u21D2",
+      peg$c193 = peg$literalExpectation("\u2190\u21D2", false),
+      peg$c194 = function() { return "<-=>"; },
+      peg$c195 = peg$otherExpectation("light tilde arrow <-~>"),
+      peg$c196 = "<-~>",
+      peg$c197 = peg$literalExpectation("<-~>", false),
+      peg$c198 = "\u2190\u219B",
+      peg$c199 = peg$literalExpectation("\u2190\u219B", false),
+      peg$c200 = function() { return "<-~>"; },
+      peg$c201 = peg$otherExpectation("fat light arrow <=->"),
+      peg$c202 = "<=->",
+      peg$c203 = peg$literalExpectation("<=->", false),
+      peg$c204 = "\u21D0\u2192",
+      peg$c205 = peg$literalExpectation("\u21D0\u2192", false),
+      peg$c206 = function() { return "<=->"; },
+      peg$c207 = peg$otherExpectation("fat tilde arrow <=~>"),
+      peg$c208 = "<=~>",
+      peg$c209 = peg$literalExpectation("<=~>", false),
+      peg$c210 = "\u21D0\u219B",
+      peg$c211 = peg$literalExpectation("\u21D0\u219B", false),
+      peg$c212 = function() { return "<=~>"; },
+      peg$c213 = peg$otherExpectation("tilde light arrow <~->"),
+      peg$c214 = "<~->",
+      peg$c215 = peg$literalExpectation("<~->", false),
+      peg$c216 = "\u219A\u2192",
+      peg$c217 = peg$literalExpectation("\u219A\u2192", false),
+      peg$c218 = function() { return "<~->"; },
+      peg$c219 = peg$otherExpectation("tilde fat arrow <~=>"),
+      peg$c220 = "<~=>",
+      peg$c221 = peg$literalExpectation("<~=>", false),
+      peg$c222 = "\u219A\u21D2",
+      peg$c223 = peg$literalExpectation("\u219A\u21D2", false),
+      peg$c224 = function() { return "<~=>"; },
+      peg$c225 = peg$otherExpectation("light arrow"),
+      peg$c226 = peg$otherExpectation("fat arrow"),
+      peg$c227 = peg$otherExpectation("tilde arrow"),
+      peg$c228 = peg$otherExpectation("mixed arrow"),
+      peg$c229 = peg$otherExpectation("arrow"),
+      peg$c230 = "true",
+      peg$c231 = peg$literalExpectation("true", false),
+      peg$c232 = function() { return true;  },
+      peg$c233 = "false",
+      peg$c234 = peg$literalExpectation("false", false),
+      peg$c235 = function() { return false; },
+      peg$c236 = "regular",
+      peg$c237 = peg$literalExpectation("regular", false),
+      peg$c238 = "rounded",
+      peg$c239 = peg$literalExpectation("rounded", false),
+      peg$c240 = "lined",
+      peg$c241 = peg$literalExpectation("lined", false),
+      peg$c242 = "solid",
+      peg$c243 = peg$literalExpectation("solid", false),
+      peg$c244 = "dotted",
+      peg$c245 = peg$literalExpectation("dotted", false),
+      peg$c246 = "dashed",
+      peg$c247 = peg$literalExpectation("dashed", false),
+      peg$c248 = "\"",
+      peg$c249 = peg$literalExpectation("\"", false),
+      peg$c250 = "\\",
+      peg$c251 = peg$literalExpectation("\\", false),
+      peg$c252 = "/",
+      peg$c253 = peg$literalExpectation("/", false),
+      peg$c254 = "b",
+      peg$c255 = peg$literalExpectation("b", false),
+      peg$c256 = function() { return "\b"; },
+      peg$c257 = "f",
+      peg$c258 = peg$literalExpectation("f", false),
+      peg$c259 = function() { return "\f"; },
+      peg$c260 = "n",
+      peg$c261 = peg$literalExpectation("n", false),
+      peg$c262 = function() { return "\n"; },
+      peg$c263 = "r",
+      peg$c264 = peg$literalExpectation("r", false),
+      peg$c265 = function() { return "\r"; },
+      peg$c266 = "t",
+      peg$c267 = peg$literalExpectation("t", false),
+      peg$c268 = function() { return "\t"; },
+      peg$c269 = "v",
+      peg$c270 = peg$literalExpectation("v", false),
+      peg$c271 = function() { return "\v"; },
+      peg$c272 = "u",
+      peg$c273 = peg$literalExpectation("u", false),
+      peg$c274 = function(digits) {
+                return String.fromCharCode(parseInt(digits, 16));
+              },
+      peg$c275 = function(Sequence) { return Sequence; },
+      peg$c276 = "null",
+      peg$c277 = peg$literalExpectation("null", false),
+      peg$c278 = function() { return null; },
+      peg$c279 = "undefined",
+      peg$c280 = peg$literalExpectation("undefined", false),
+      peg$c281 = function() { return undefined; },
+      peg$c282 = /^[\0-!#-[\]-\uFFFF]/,
+      peg$c283 = peg$classExpectation([["\0", "!"], ["#", "["], ["]", "\uFFFF"]], false, false),
+      peg$c284 = "'",
+      peg$c285 = peg$literalExpectation("'", false),
+      peg$c286 = /^[ -&(-[\]-\uFFFF]/,
+      peg$c287 = peg$classExpectation([[" ", "&"], ["(", "["], ["]", "\uFFFF"]], false, false),
+      peg$c288 = peg$otherExpectation("action label"),
+      peg$c289 = function(chars) { return chars.join(""); },
+      peg$c290 = /^[\n\r\u2028\u2029]/,
+      peg$c291 = peg$classExpectation(["\n", "\r", "\u2028", "\u2029"], false, false),
+      peg$c292 = /^[ \t\n\r\x0B]/,
+      peg$c293 = peg$classExpectation([" ", "\t", "\n", "\r", "\x0B"], false, false),
+      peg$c294 = "*/",
+      peg$c295 = peg$literalExpectation("*/", false),
+      peg$c296 = peg$anyExpectation(),
+      peg$c297 = peg$otherExpectation("block comment"),
+      peg$c298 = "/*",
+      peg$c299 = peg$literalExpectation("/*", false),
+      peg$c300 = peg$otherExpectation("line comment"),
+      peg$c301 = "//",
+      peg$c302 = peg$literalExpectation("//", false),
+      peg$c303 = peg$otherExpectation("whitespace"),
+      peg$c304 = /^[ \t\r\n\x0B]/,
+      peg$c305 = peg$classExpectation([" ", "\t", "\r", "\n", "\x0B"], false, false),
+      peg$c306 = peg$otherExpectation("string"),
+      peg$c307 = /^[0-9a-zA-Z._!$\^*!?,\x80-\uFFFF]/,
+      peg$c308 = peg$classExpectation([["0", "9"], ["a", "z"], ["A", "Z"], ".", "_", "!", "$", "^", "*", "!", "?", ",", ["\x80", "\uFFFF"]], false, false),
+      peg$c309 = /^[0-9a-zA-Z.+_\^()*&$#@!?,\x80-\uFFFF]/,
+      peg$c310 = peg$classExpectation([["0", "9"], ["a", "z"], ["A", "Z"], ".", "+", "_", "^", "(", ")", "*", "&", "$", "#", "@", "!", "?", ",", ["\x80", "\uFFFF"]], false, false),
+      peg$c311 = peg$otherExpectation("atom"),
+      peg$c312 = function(firstletter, text) {
+            return firstletter + ((text || []).join(''));
+          },
+      peg$c313 = peg$otherExpectation("label"),
+      peg$c314 = "0",
+      peg$c315 = peg$literalExpectation("0", false),
+      peg$c316 = /^[0-9]/,
+      peg$c317 = peg$classExpectation([["0", "9"]], false, false),
+      peg$c318 = /^[1-9]/,
+      peg$c319 = peg$classExpectation([["1", "9"]], false, false),
+      peg$c320 = /^[0-9a-f]/i,
+      peg$c321 = peg$classExpectation([["0", "9"], ["a", "f"]], false, true),
+      peg$c322 = /^[0-1]/,
+      peg$c323 = peg$classExpectation([["0", "1"]], false, false),
+      peg$c324 = peg$otherExpectation("nonneg number"),
+      peg$c325 = ".",
+      peg$c326 = peg$literalExpectation(".", false),
+      peg$c327 = function() { return parseFloat(text()); },
+      peg$c328 = peg$otherExpectation("number"),
+      peg$c329 = function(literal) { return literal; },
+      peg$c330 = "NaN",
+      peg$c331 = peg$literalExpectation("NaN", false),
+      peg$c332 = function() { return NaN; },
+      peg$c333 = "NegativeInfinity",
+      peg$c334 = peg$literalExpectation("NegativeInfinity", false),
+      peg$c335 = function() { return Number.NEGATIVE_INFINITY; },
+      peg$c336 = "NegativeInf",
+      peg$c337 = peg$literalExpectation("NegativeInf", false),
+      peg$c338 = "NegInfinity",
+      peg$c339 = peg$literalExpectation("NegInfinity", false),
+      peg$c340 = "NegInf",
+      peg$c341 = peg$literalExpectation("NegInf", false),
+      peg$c342 = "NInfinity",
+      peg$c343 = peg$literalExpectation("NInfinity", false),
+      peg$c344 = "NInf",
+      peg$c345 = peg$literalExpectation("NInf", false),
+      peg$c346 = "-\u221E",
+      peg$c347 = peg$literalExpectation("-\u221E", false),
+      peg$c348 = "PInfinity",
+      peg$c349 = peg$literalExpectation("PInfinity", false),
+      peg$c350 = function() { return Number.POSITIVE_INFINITY; },
+      peg$c351 = "Infinity",
+      peg$c352 = peg$literalExpectation("Infinity", false),
+      peg$c353 = "PInf",
+      peg$c354 = peg$literalExpectation("PInf", false),
+      peg$c355 = "Inf",
+      peg$c356 = peg$literalExpectation("Inf", false),
+      peg$c357 = "\u221E",
+      peg$c358 = peg$literalExpectation("\u221E", false),
+      peg$c359 = "Epsilon",
+      peg$c360 = peg$literalExpectation("Epsilon", false),
+      peg$c361 = function() { return Number.EPSILON; },
+      peg$c362 = "\uD835\uDF00",
+      peg$c363 = peg$literalExpectation("\uD835\uDF00", false),
+      peg$c364 = "\u03B5",
+      peg$c365 = peg$literalExpectation("\u03B5", false),
+      peg$c366 = "Pi",
+      peg$c367 = peg$literalExpectation("Pi", false),
+      peg$c368 = function() { return Math.PI; },
+      peg$c369 = "\uD835\uDF0B",
+      peg$c370 = peg$literalExpectation("\uD835\uDF0B", false),
+      peg$c371 = "\u03C0",
+      peg$c372 = peg$literalExpectation("\u03C0", false),
+      peg$c373 = "EulerNumber",
+      peg$c374 = peg$literalExpectation("EulerNumber", false),
+      peg$c375 = function() { return Math.E; },
+      peg$c376 = "E",
+      peg$c377 = peg$literalExpectation("E", false),
+      peg$c378 = "e",
+      peg$c379 = peg$literalExpectation("e", false),
+      peg$c380 = "\u0190",
+      peg$c381 = peg$literalExpectation("\u0190", false),
+      peg$c382 = "\u2107",
+      peg$c383 = peg$literalExpectation("\u2107", false),
+      peg$c384 = "Root2",
+      peg$c385 = peg$literalExpectation("Root2", false),
+      peg$c386 = function() { return Math.SQRT2; },
+      peg$c387 = "RootHalf",
+      peg$c388 = peg$literalExpectation("RootHalf", false),
+      peg$c389 = function() { return Math.SQRT1_2; },
+      peg$c390 = "Ln2",
+      peg$c391 = peg$literalExpectation("Ln2", false),
+      peg$c392 = function() { return Math.LN2; },
+      peg$c393 = "NatLog2",
+      peg$c394 = peg$literalExpectation("NatLog2", false),
+      peg$c395 = "Ln10",
+      peg$c396 = peg$literalExpectation("Ln10", false),
+      peg$c397 = function() { return Math.LN10; },
+      peg$c398 = "NatLog10",
+      peg$c399 = peg$literalExpectation("NatLog10", false),
+      peg$c400 = "Log2E",
+      peg$c401 = peg$literalExpectation("Log2E", false),
+      peg$c402 = function() { return Math.LOG2E; },
+      peg$c403 = "Log10E",
+      peg$c404 = peg$literalExpectation("Log10E", false),
+      peg$c405 = function() { return Math.LOG10E; },
+      peg$c406 = "MaxSafeInt",
+      peg$c407 = peg$literalExpectation("MaxSafeInt", false),
+      peg$c408 = function() { return Number.MAX_SAFE_INTEGER; },
+      peg$c409 = "MinSafeInt",
+      peg$c410 = peg$literalExpectation("MinSafeInt", false),
+      peg$c411 = function() { return Number.MIN_SAFE_INTEGER; },
+      peg$c412 = "MaxPosNum",
+      peg$c413 = peg$literalExpectation("MaxPosNum", false),
+      peg$c414 = function() { return Number.MAX_VALUE; },
+      peg$c415 = "MinPosNum",
+      peg$c416 = peg$literalExpectation("MinPosNum", false),
+      peg$c417 = function() { return Number.MIN_VALUE; },
+      peg$c418 = "Phi",
+      peg$c419 = peg$literalExpectation("Phi", false),
+      peg$c420 = function() { return 1.61803398874989484820; },
+      peg$c421 = "\uD835\uDF11",
+      peg$c422 = peg$literalExpectation("\uD835\uDF11", false),
+      peg$c423 = "\uD835\uDF19",
+      peg$c424 = peg$literalExpectation("\uD835\uDF19", false),
+      peg$c425 = "\u03D5",
+      peg$c426 = peg$literalExpectation("\u03D5", false),
+      peg$c427 = "\u03C6",
+      peg$c428 = peg$literalExpectation("\u03C6", false),
+      peg$c429 = "EulerConstant",
+      peg$c430 = peg$literalExpectation("EulerConstant", false),
+      peg$c431 = function() { return 0.57721566490153286060; },
+      peg$c432 = "\u03B3",
+      peg$c433 = peg$literalExpectation("\u03B3", false),
+      peg$c434 = "\uD835\uDEFE",
+      peg$c435 = peg$literalExpectation("\uD835\uDEFE", false),
+      peg$c436 = peg$literalExpectation("e", true),
+      peg$c437 = /^[+\-]/,
+      peg$c438 = peg$classExpectation(["+", "-"], false, false),
+      peg$c439 = "0x",
+      peg$c440 = peg$literalExpectation("0x", true),
+      peg$c441 = function(digits) {
+            return parseInt(digits, 16);
+           },
+      peg$c442 = "0b",
+      peg$c443 = peg$literalExpectation("0b", true),
+      peg$c444 = function(digits) {
+            return parseInt(digits, 2);
+           },
+      peg$c445 = "0o",
+      peg$c446 = peg$literalExpectation("0o", true),
+      peg$c447 = function(digits) {
+            return parseInt(digits, 8);
+           },
+      peg$c448 = function(major, minor, patch) { return {
+          major: parseInt(major,10),
+          minor: parseInt(minor,10),
+          patch: parseInt(patch,10),
+          full: text()
+        }; },
+      peg$c449 = "^",
+      peg$c450 = peg$literalExpectation("^", false),
+      peg$c451 = "~",
+      peg$c452 = peg$literalExpectation("~", false),
+      peg$c453 = ">=",
+      peg$c454 = peg$literalExpectation(">=", false),
+      peg$c455 = "<",
+      peg$c456 = peg$literalExpectation("<", false),
+      peg$c457 = ">",
+      peg$c458 = peg$literalExpectation(">", false),
+      peg$c459 = "http://",
+      peg$c460 = peg$literalExpectation("http://", false),
+      peg$c461 = "https://",
+      peg$c462 = peg$literalExpectation("https://", false),
+      peg$c463 = /^[a-zA-Z0-9!*'():;@&=+$,\/?#[\]_.~\-]/,
+      peg$c464 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "!", "*", "'", "(", ")", ":", ";", "@", "&", "=", "+", "$", ",", "/", "?", "#", "[", "]", "_", ".", "~", "-"], false, false),
+      peg$c465 = function(protocol) { return text(); },
+      peg$c466 = "aliceblue",
+      peg$c467 = peg$literalExpectation("aliceblue", false),
+      peg$c468 = function() { return '#f0f8ffff'; },
+      peg$c469 = "AliceBlue",
+      peg$c470 = peg$literalExpectation("AliceBlue", false),
+      peg$c471 = "antiquewhite",
+      peg$c472 = peg$literalExpectation("antiquewhite", false),
+      peg$c473 = function() { return '#faebd7ff'; },
+      peg$c474 = "AntiqueWhite",
+      peg$c475 = peg$literalExpectation("AntiqueWhite", false),
+      peg$c476 = "aquamarine",
+      peg$c477 = peg$literalExpectation("aquamarine", false),
+      peg$c478 = function() { return '#7fffd4ff'; },
+      peg$c479 = "Aquamarine",
+      peg$c480 = peg$literalExpectation("Aquamarine", false),
+      peg$c481 = "aqua",
+      peg$c482 = peg$literalExpectation("aqua", false),
+      peg$c483 = function() { return '#00ffffff'; },
+      peg$c484 = "Aqua",
+      peg$c485 = peg$literalExpectation("Aqua", false),
+      peg$c486 = "azure",
+      peg$c487 = peg$literalExpectation("azure", false),
+      peg$c488 = function() { return '#f0ffffff'; },
+      peg$c489 = "Azure",
+      peg$c490 = peg$literalExpectation("Azure", false),
+      peg$c491 = "beige",
+      peg$c492 = peg$literalExpectation("beige", false),
+      peg$c493 = function() { return '#f5f5dcff'; },
+      peg$c494 = "Beige",
+      peg$c495 = peg$literalExpectation("Beige", false),
+      peg$c496 = "bisque",
+      peg$c497 = peg$literalExpectation("bisque", false),
+      peg$c498 = function() { return '#ffe4c4ff'; },
+      peg$c499 = "Bisque",
+      peg$c500 = peg$literalExpectation("Bisque", false),
+      peg$c501 = "black",
+      peg$c502 = peg$literalExpectation("black", false),
+      peg$c503 = function() { return '#000000ff'; },
+      peg$c504 = "Black",
+      peg$c505 = peg$literalExpectation("Black", false),
+      peg$c506 = "blanchedalmond",
+      peg$c507 = peg$literalExpectation("blanchedalmond", false),
+      peg$c508 = function() { return '#ffebcdff'; },
+      peg$c509 = "BlanchedAlmond",
+      peg$c510 = peg$literalExpectation("BlanchedAlmond", false),
+      peg$c511 = "blueviolet",
+      peg$c512 = peg$literalExpectation("blueviolet", false),
+      peg$c513 = function() { return '#8a2be2ff'; },
+      peg$c514 = "BlueViolet",
+      peg$c515 = peg$literalExpectation("BlueViolet", false),
+      peg$c516 = "blue",
+      peg$c517 = peg$literalExpectation("blue", false),
+      peg$c518 = function() { return '#0000ffff'; },
+      peg$c519 = "Blue",
+      peg$c520 = peg$literalExpectation("Blue", false),
+      peg$c521 = "brown",
+      peg$c522 = peg$literalExpectation("brown", false),
+      peg$c523 = function() { return '#a52a2aff'; },
+      peg$c524 = "Brown",
+      peg$c525 = peg$literalExpectation("Brown", false),
+      peg$c526 = "burlywood",
+      peg$c527 = peg$literalExpectation("burlywood", false),
+      peg$c528 = function() { return '#deb887ff'; },
+      peg$c529 = "BurlyWood",
+      peg$c530 = peg$literalExpectation("BurlyWood", false),
+      peg$c531 = "cadetblue",
+      peg$c532 = peg$literalExpectation("cadetblue", false),
+      peg$c533 = function() { return '#5f9ea0ff'; },
+      peg$c534 = "CadetBlue",
+      peg$c535 = peg$literalExpectation("CadetBlue", false),
+      peg$c536 = "chartreuse",
+      peg$c537 = peg$literalExpectation("chartreuse", false),
+      peg$c538 = function() { return '#7fff00ff'; },
+      peg$c539 = "Chartreuse",
+      peg$c540 = peg$literalExpectation("Chartreuse", false),
+      peg$c541 = "chocolate",
+      peg$c542 = peg$literalExpectation("chocolate", false),
+      peg$c543 = function() { return '#d2691eff'; },
+      peg$c544 = "Chocolate",
+      peg$c545 = peg$literalExpectation("Chocolate", false),
+      peg$c546 = "coral",
+      peg$c547 = peg$literalExpectation("coral", false),
+      peg$c548 = function() { return '#ff7f50ff'; },
+      peg$c549 = "Coral",
+      peg$c550 = peg$literalExpectation("Coral", false),
+      peg$c551 = "cornflowerblue",
+      peg$c552 = peg$literalExpectation("cornflowerblue", false),
+      peg$c553 = function() { return '#6495edff'; },
+      peg$c554 = "CornflowerBlue",
+      peg$c555 = peg$literalExpectation("CornflowerBlue", false),
+      peg$c556 = "cornsilk",
+      peg$c557 = peg$literalExpectation("cornsilk", false),
+      peg$c558 = function() { return '#fff8dcff'; },
+      peg$c559 = "Cornsilk",
+      peg$c560 = peg$literalExpectation("Cornsilk", false),
+      peg$c561 = "crimson",
+      peg$c562 = peg$literalExpectation("crimson", false),
+      peg$c563 = function() { return '#dc143cff'; },
+      peg$c564 = "Crimson",
+      peg$c565 = peg$literalExpectation("Crimson", false),
+      peg$c566 = "cyan",
+      peg$c567 = peg$literalExpectation("cyan", false),
+      peg$c568 = "Cyan",
+      peg$c569 = peg$literalExpectation("Cyan", false),
+      peg$c570 = "darkblue",
+      peg$c571 = peg$literalExpectation("darkblue", false),
+      peg$c572 = function() { return '#00008bff'; },
+      peg$c573 = "DarkBlue",
+      peg$c574 = peg$literalExpectation("DarkBlue", false),
+      peg$c575 = "darkcyan",
+      peg$c576 = peg$literalExpectation("darkcyan", false),
+      peg$c577 = function() { return '#008b8bff'; },
+      peg$c578 = "DarkCyan",
+      peg$c579 = peg$literalExpectation("DarkCyan", false),
+      peg$c580 = "darkgoldenrod",
+      peg$c581 = peg$literalExpectation("darkgoldenrod", false),
+      peg$c582 = function() { return '#b8860bff'; },
+      peg$c583 = "DarkGoldenRod",
+      peg$c584 = peg$literalExpectation("DarkGoldenRod", false),
+      peg$c585 = "darkgray",
+      peg$c586 = peg$literalExpectation("darkgray", false),
+      peg$c587 = function() { return '#a9a9a9ff'; },
+      peg$c588 = "DarkGray",
+      peg$c589 = peg$literalExpectation("DarkGray", false),
+      peg$c590 = "darkgrey",
+      peg$c591 = peg$literalExpectation("darkgrey", false),
+      peg$c592 = "DarkGrey",
+      peg$c593 = peg$literalExpectation("DarkGrey", false),
+      peg$c594 = "darkgreen",
+      peg$c595 = peg$literalExpectation("darkgreen", false),
+      peg$c596 = function() { return '#006400ff'; },
+      peg$c597 = "DarkGreen",
+      peg$c598 = peg$literalExpectation("DarkGreen", false),
+      peg$c599 = "darkkhaki",
+      peg$c600 = peg$literalExpectation("darkkhaki", false),
+      peg$c601 = function() { return '#bdb76bff'; },
+      peg$c602 = "DarkKhaki",
+      peg$c603 = peg$literalExpectation("DarkKhaki", false),
+      peg$c604 = "darkmagenta",
+      peg$c605 = peg$literalExpectation("darkmagenta", false),
+      peg$c606 = function() { return '#8b008bff'; },
+      peg$c607 = "DarkMagenta",
+      peg$c608 = peg$literalExpectation("DarkMagenta", false),
+      peg$c609 = "darkolivegreen",
+      peg$c610 = peg$literalExpectation("darkolivegreen", false),
+      peg$c611 = function() { return '#556b2fff'; },
+      peg$c612 = "DarkOliveGreen",
+      peg$c613 = peg$literalExpectation("DarkOliveGreen", false),
+      peg$c614 = "darkorange",
+      peg$c615 = peg$literalExpectation("darkorange", false),
+      peg$c616 = function() { return '#ff8c00ff'; },
+      peg$c617 = "Darkorange",
+      peg$c618 = peg$literalExpectation("Darkorange", false),
+      peg$c619 = "darkorchid",
+      peg$c620 = peg$literalExpectation("darkorchid", false),
+      peg$c621 = function() { return '#9932ccff'; },
+      peg$c622 = "DarkOrchid",
+      peg$c623 = peg$literalExpectation("DarkOrchid", false),
+      peg$c624 = "darkred",
+      peg$c625 = peg$literalExpectation("darkred", false),
+      peg$c626 = function() { return '#8b0000ff'; },
+      peg$c627 = "DarkRed",
+      peg$c628 = peg$literalExpectation("DarkRed", false),
+      peg$c629 = "darksalmon",
+      peg$c630 = peg$literalExpectation("darksalmon", false),
+      peg$c631 = function() { return '#e9967aff'; },
+      peg$c632 = "DarkSalmon",
+      peg$c633 = peg$literalExpectation("DarkSalmon", false),
+      peg$c634 = "darkseagreen",
+      peg$c635 = peg$literalExpectation("darkseagreen", false),
+      peg$c636 = function() { return '#8fbc8fff'; },
+      peg$c637 = "DarkSeaGreen",
+      peg$c638 = peg$literalExpectation("DarkSeaGreen", false),
+      peg$c639 = "darkslateblue",
+      peg$c640 = peg$literalExpectation("darkslateblue", false),
+      peg$c641 = function() { return '#483d8bff'; },
+      peg$c642 = "DarkSlateBlue",
+      peg$c643 = peg$literalExpectation("DarkSlateBlue", false),
+      peg$c644 = "darkslategray",
+      peg$c645 = peg$literalExpectation("darkslategray", false),
+      peg$c646 = function() { return '#2f4f4fff'; },
+      peg$c647 = "DarkSlateGray",
+      peg$c648 = peg$literalExpectation("DarkSlateGray", false),
+      peg$c649 = "darkslategrey",
+      peg$c650 = peg$literalExpectation("darkslategrey", false),
+      peg$c651 = "DarkSlateGrey",
+      peg$c652 = peg$literalExpectation("DarkSlateGrey", false),
+      peg$c653 = "darkturquoise",
+      peg$c654 = peg$literalExpectation("darkturquoise", false),
+      peg$c655 = function() { return '#00ced1ff'; },
+      peg$c656 = "DarkTurquoise",
+      peg$c657 = peg$literalExpectation("DarkTurquoise", false),
+      peg$c658 = "darkviolet",
+      peg$c659 = peg$literalExpectation("darkviolet", false),
+      peg$c660 = function() { return '#9400d3ff'; },
+      peg$c661 = "DarkViolet",
+      peg$c662 = peg$literalExpectation("DarkViolet", false),
+      peg$c663 = "deeppink",
+      peg$c664 = peg$literalExpectation("deeppink", false),
+      peg$c665 = function() { return '#ff1493ff'; },
+      peg$c666 = "DeepPink",
+      peg$c667 = peg$literalExpectation("DeepPink", false),
+      peg$c668 = "deepskyblue",
+      peg$c669 = peg$literalExpectation("deepskyblue", false),
+      peg$c670 = function() { return '#00bfffff'; },
+      peg$c671 = "DeepSkyBlue",
+      peg$c672 = peg$literalExpectation("DeepSkyBlue", false),
+      peg$c673 = "dimgray",
+      peg$c674 = peg$literalExpectation("dimgray", false),
+      peg$c675 = function() { return '#696969ff'; },
+      peg$c676 = "DimGray",
+      peg$c677 = peg$literalExpectation("DimGray", false),
+      peg$c678 = "dimgrey",
+      peg$c679 = peg$literalExpectation("dimgrey", false),
+      peg$c680 = "DimGrey",
+      peg$c681 = peg$literalExpectation("DimGrey", false),
+      peg$c682 = "dodgerblue",
+      peg$c683 = peg$literalExpectation("dodgerblue", false),
+      peg$c684 = function() { return '#1e90ffff'; },
+      peg$c685 = "DodgerBlue",
+      peg$c686 = peg$literalExpectation("DodgerBlue", false),
+      peg$c687 = "firebrick",
+      peg$c688 = peg$literalExpectation("firebrick", false),
+      peg$c689 = function() { return '#b22222ff'; },
+      peg$c690 = "FireBrick",
+      peg$c691 = peg$literalExpectation("FireBrick", false),
+      peg$c692 = "floralwhite",
+      peg$c693 = peg$literalExpectation("floralwhite", false),
+      peg$c694 = function() { return '#fffaf0ff'; },
+      peg$c695 = "FloralWhite",
+      peg$c696 = peg$literalExpectation("FloralWhite", false),
+      peg$c697 = "forestgreen",
+      peg$c698 = peg$literalExpectation("forestgreen", false),
+      peg$c699 = function() { return '#228b22ff'; },
+      peg$c700 = "ForestGreen",
+      peg$c701 = peg$literalExpectation("ForestGreen", false),
+      peg$c702 = "fuchsia",
+      peg$c703 = peg$literalExpectation("fuchsia", false),
+      peg$c704 = function() { return '#ff00ffff'; },
+      peg$c705 = "Fuchsia",
+      peg$c706 = peg$literalExpectation("Fuchsia", false),
+      peg$c707 = "gainsboro",
+      peg$c708 = peg$literalExpectation("gainsboro", false),
+      peg$c709 = function() { return '#dcdcdcff'; },
+      peg$c710 = "Gainsboro",
+      peg$c711 = peg$literalExpectation("Gainsboro", false),
+      peg$c712 = "ghostwhite",
+      peg$c713 = peg$literalExpectation("ghostwhite", false),
+      peg$c714 = function() { return '#f8f8ffff'; },
+      peg$c715 = "GhostWhite",
+      peg$c716 = peg$literalExpectation("GhostWhite", false),
+      peg$c717 = "goldenrod",
+      peg$c718 = peg$literalExpectation("goldenrod", false),
+      peg$c719 = function() { return '#daa520ff'; },
+      peg$c720 = "GoldenRod",
+      peg$c721 = peg$literalExpectation("GoldenRod", false),
+      peg$c722 = "gold",
+      peg$c723 = peg$literalExpectation("gold", false),
+      peg$c724 = function() { return '#ffd700ff'; },
+      peg$c725 = "Gold",
+      peg$c726 = peg$literalExpectation("Gold", false),
+      peg$c727 = "gray",
+      peg$c728 = peg$literalExpectation("gray", false),
+      peg$c729 = function() { return '#808080ff'; },
+      peg$c730 = "Gray",
+      peg$c731 = peg$literalExpectation("Gray", false),
+      peg$c732 = "grey",
+      peg$c733 = peg$literalExpectation("grey", false),
+      peg$c734 = "Grey",
+      peg$c735 = peg$literalExpectation("Grey", false),
+      peg$c736 = "greenyellow",
+      peg$c737 = peg$literalExpectation("greenyellow", false),
+      peg$c738 = function() { return '#adff2fff'; },
+      peg$c739 = "GreenYellow",
+      peg$c740 = peg$literalExpectation("GreenYellow", false),
+      peg$c741 = "green",
+      peg$c742 = peg$literalExpectation("green", false),
+      peg$c743 = function() { return '#008000ff'; },
+      peg$c744 = "Green",
+      peg$c745 = peg$literalExpectation("Green", false),
+      peg$c746 = "honeydew",
+      peg$c747 = peg$literalExpectation("honeydew", false),
+      peg$c748 = function() { return '#f0fff0ff'; },
+      peg$c749 = "HoneyDew",
+      peg$c750 = peg$literalExpectation("HoneyDew", false),
+      peg$c751 = "hotpink",
+      peg$c752 = peg$literalExpectation("hotpink", false),
+      peg$c753 = function() { return '#ff69b4ff'; },
+      peg$c754 = "HotPink",
+      peg$c755 = peg$literalExpectation("HotPink", false),
+      peg$c756 = "indianred",
+      peg$c757 = peg$literalExpectation("indianred", false),
+      peg$c758 = function() { return '#cd5c5cff'; },
+      peg$c759 = "IndianRed",
+      peg$c760 = peg$literalExpectation("IndianRed", false),
+      peg$c761 = "indigo",
+      peg$c762 = peg$literalExpectation("indigo", false),
+      peg$c763 = function() { return '#4b0082ff'; },
+      peg$c764 = "Indigo",
+      peg$c765 = peg$literalExpectation("Indigo", false),
+      peg$c766 = "ivory",
+      peg$c767 = peg$literalExpectation("ivory", false),
+      peg$c768 = function() { return '#fffff0ff'; },
+      peg$c769 = "Ivory",
+      peg$c770 = peg$literalExpectation("Ivory", false),
+      peg$c771 = "khaki",
+      peg$c772 = peg$literalExpectation("khaki", false),
+      peg$c773 = function() { return '#f0e68cff'; },
+      peg$c774 = "Khaki",
+      peg$c775 = peg$literalExpectation("Khaki", false),
+      peg$c776 = "lavenderblush",
+      peg$c777 = peg$literalExpectation("lavenderblush", false),
+      peg$c778 = function() { return '#fff0f5ff'; },
+      peg$c779 = "LavenderBlush",
+      peg$c780 = peg$literalExpectation("LavenderBlush", false),
+      peg$c781 = "lavender",
+      peg$c782 = peg$literalExpectation("lavender", false),
+      peg$c783 = function() { return '#e6e6faff'; },
+      peg$c784 = "Lavender",
+      peg$c785 = peg$literalExpectation("Lavender", false),
+      peg$c786 = "lawngreen",
+      peg$c787 = peg$literalExpectation("lawngreen", false),
+      peg$c788 = function() { return '#7cfc00ff'; },
+      peg$c789 = "LawnGreen",
+      peg$c790 = peg$literalExpectation("LawnGreen", false),
+      peg$c791 = "lemonchiffon",
+      peg$c792 = peg$literalExpectation("lemonchiffon", false),
+      peg$c793 = function() { return '#fffacdff'; },
+      peg$c794 = "LemonChiffon",
+      peg$c795 = peg$literalExpectation("LemonChiffon", false),
+      peg$c796 = "lightblue",
+      peg$c797 = peg$literalExpectation("lightblue", false),
+      peg$c798 = function() { return '#add8e6ff'; },
+      peg$c799 = "LightBlue",
+      peg$c800 = peg$literalExpectation("LightBlue", false),
+      peg$c801 = "lightcoral",
+      peg$c802 = peg$literalExpectation("lightcoral", false),
+      peg$c803 = function() { return '#f08080ff'; },
+      peg$c804 = "LightCoral",
+      peg$c805 = peg$literalExpectation("LightCoral", false),
+      peg$c806 = "lightcyan",
+      peg$c807 = peg$literalExpectation("lightcyan", false),
+      peg$c808 = function() { return '#e0ffffff'; },
+      peg$c809 = "LightCyan",
+      peg$c810 = peg$literalExpectation("LightCyan", false),
+      peg$c811 = "lightgoldenrodyellow",
+      peg$c812 = peg$literalExpectation("lightgoldenrodyellow", false),
+      peg$c813 = function() { return '#fafad2ff'; },
+      peg$c814 = "LightGoldenRodYellow",
+      peg$c815 = peg$literalExpectation("LightGoldenRodYellow", false),
+      peg$c816 = "lightgray",
+      peg$c817 = peg$literalExpectation("lightgray", false),
+      peg$c818 = function() { return '#d3d3d3ff'; },
+      peg$c819 = "LightGray",
+      peg$c820 = peg$literalExpectation("LightGray", false),
+      peg$c821 = "lightgrey",
+      peg$c822 = peg$literalExpectation("lightgrey", false),
+      peg$c823 = "LightGrey",
+      peg$c824 = peg$literalExpectation("LightGrey", false),
+      peg$c825 = "lightgreen",
+      peg$c826 = peg$literalExpectation("lightgreen", false),
+      peg$c827 = function() { return '#90ee90ff'; },
+      peg$c828 = "LightGreen",
+      peg$c829 = peg$literalExpectation("LightGreen", false),
+      peg$c830 = "lightpink",
+      peg$c831 = peg$literalExpectation("lightpink", false),
+      peg$c832 = function() { return '#ffb6c1ff'; },
+      peg$c833 = "LightPink",
+      peg$c834 = peg$literalExpectation("LightPink", false),
+      peg$c835 = "lightsalmon",
+      peg$c836 = peg$literalExpectation("lightsalmon", false),
+      peg$c837 = function() { return '#ffa07aff'; },
+      peg$c838 = "LightSalmon",
+      peg$c839 = peg$literalExpectation("LightSalmon", false),
+      peg$c840 = "lightseagreen",
+      peg$c841 = peg$literalExpectation("lightseagreen", false),
+      peg$c842 = function() { return '#20b2aaff'; },
+      peg$c843 = "LightSeaGreen",
+      peg$c844 = peg$literalExpectation("LightSeaGreen", false),
+      peg$c845 = "lightskyblue",
+      peg$c846 = peg$literalExpectation("lightskyblue", false),
+      peg$c847 = function() { return '#87cefaff'; },
+      peg$c848 = "LightSkyBlue",
+      peg$c849 = peg$literalExpectation("LightSkyBlue", false),
+      peg$c850 = "lightslategray",
+      peg$c851 = peg$literalExpectation("lightslategray", false),
+      peg$c852 = function() { return '#778899ff'; },
+      peg$c853 = "LightSlateGray",
+      peg$c854 = peg$literalExpectation("LightSlateGray", false),
+      peg$c855 = "lightslategrey",
+      peg$c856 = peg$literalExpectation("lightslategrey", false),
+      peg$c857 = "LightSlateGrey",
+      peg$c858 = peg$literalExpectation("LightSlateGrey", false),
+      peg$c859 = "lightsteelblue",
+      peg$c860 = peg$literalExpectation("lightsteelblue", false),
+      peg$c861 = function() { return '#b0c4deff'; },
+      peg$c862 = "LightSteelBlue",
+      peg$c863 = peg$literalExpectation("LightSteelBlue", false),
+      peg$c864 = "lightyellow",
+      peg$c865 = peg$literalExpectation("lightyellow", false),
+      peg$c866 = function() { return '#ffffe0ff'; },
+      peg$c867 = "LightYellow",
+      peg$c868 = peg$literalExpectation("LightYellow", false),
+      peg$c869 = "limegreen",
+      peg$c870 = peg$literalExpectation("limegreen", false),
+      peg$c871 = function() { return '#32cd32ff'; },
+      peg$c872 = "LimeGreen",
+      peg$c873 = peg$literalExpectation("LimeGreen", false),
+      peg$c874 = "lime",
+      peg$c875 = peg$literalExpectation("lime", false),
+      peg$c876 = function() { return '#00ff00ff'; },
+      peg$c877 = "Lime",
+      peg$c878 = peg$literalExpectation("Lime", false),
+      peg$c879 = "linen",
+      peg$c880 = peg$literalExpectation("linen", false),
+      peg$c881 = function() { return '#faf0e6ff'; },
+      peg$c882 = "Linen",
+      peg$c883 = peg$literalExpectation("Linen", false),
+      peg$c884 = "magenta",
+      peg$c885 = peg$literalExpectation("magenta", false),
+      peg$c886 = "Magenta",
+      peg$c887 = peg$literalExpectation("Magenta", false),
+      peg$c888 = "maroon",
+      peg$c889 = peg$literalExpectation("maroon", false),
+      peg$c890 = function() { return '#800000ff'; },
+      peg$c891 = "Maroon",
+      peg$c892 = peg$literalExpectation("Maroon", false),
+      peg$c893 = "mediumaquamarine",
+      peg$c894 = peg$literalExpectation("mediumaquamarine", false),
+      peg$c895 = function() { return '#66cdaaff'; },
+      peg$c896 = "MediumAquaMarine",
+      peg$c897 = peg$literalExpectation("MediumAquaMarine", false),
+      peg$c898 = "mediumblue",
+      peg$c899 = peg$literalExpectation("mediumblue", false),
+      peg$c900 = function() { return '#0000cdff'; },
+      peg$c901 = "MediumBlue",
+      peg$c902 = peg$literalExpectation("MediumBlue", false),
+      peg$c903 = "mediumorchid",
+      peg$c904 = peg$literalExpectation("mediumorchid", false),
+      peg$c905 = function() { return '#ba55d3ff'; },
+      peg$c906 = "MediumOrchid",
+      peg$c907 = peg$literalExpectation("MediumOrchid", false),
+      peg$c908 = "mediumpurple",
+      peg$c909 = peg$literalExpectation("mediumpurple", false),
+      peg$c910 = function() { return '#9370d8ff'; },
+      peg$c911 = "MediumPurple",
+      peg$c912 = peg$literalExpectation("MediumPurple", false),
+      peg$c913 = "mediumseagreen",
+      peg$c914 = peg$literalExpectation("mediumseagreen", false),
+      peg$c915 = function() { return '#3cb371ff'; },
+      peg$c916 = "MediumSeaGreen",
+      peg$c917 = peg$literalExpectation("MediumSeaGreen", false),
+      peg$c918 = "mediumslateblue",
+      peg$c919 = peg$literalExpectation("mediumslateblue", false),
+      peg$c920 = function() { return '#7b68eeff'; },
+      peg$c921 = "MediumSlateBlue",
+      peg$c922 = peg$literalExpectation("MediumSlateBlue", false),
+      peg$c923 = "mediumspringgreen",
+      peg$c924 = peg$literalExpectation("mediumspringgreen", false),
+      peg$c925 = function() { return '#00fa9aff'; },
+      peg$c926 = "MediumSpringGreen",
+      peg$c927 = peg$literalExpectation("MediumSpringGreen", false),
+      peg$c928 = "mediumturquoise",
+      peg$c929 = peg$literalExpectation("mediumturquoise", false),
+      peg$c930 = function() { return '#48d1ccff'; },
+      peg$c931 = "MediumTurquoise",
+      peg$c932 = peg$literalExpectation("MediumTurquoise", false),
+      peg$c933 = "mediumvioletred",
+      peg$c934 = peg$literalExpectation("mediumvioletred", false),
+      peg$c935 = function() { return '#c71585ff'; },
+      peg$c936 = "MediumVioletRed",
+      peg$c937 = peg$literalExpectation("MediumVioletRed", false),
+      peg$c938 = "midnightblue",
+      peg$c939 = peg$literalExpectation("midnightblue", false),
+      peg$c940 = function() { return '#191970ff'; },
+      peg$c941 = "MidnightBlue",
+      peg$c942 = peg$literalExpectation("MidnightBlue", false),
+      peg$c943 = "mintcream",
+      peg$c944 = peg$literalExpectation("mintcream", false),
+      peg$c945 = function() { return '#f5fffaff'; },
+      peg$c946 = "MintCream",
+      peg$c947 = peg$literalExpectation("MintCream", false),
+      peg$c948 = "mistyrose",
+      peg$c949 = peg$literalExpectation("mistyrose", false),
+      peg$c950 = function() { return '#ffe4e1ff'; },
+      peg$c951 = "MistyRose",
+      peg$c952 = peg$literalExpectation("MistyRose", false),
+      peg$c953 = "moccasin",
+      peg$c954 = peg$literalExpectation("moccasin", false),
+      peg$c955 = function() { return '#ffe4b5ff'; },
+      peg$c956 = "Moccasin",
+      peg$c957 = peg$literalExpectation("Moccasin", false),
+      peg$c958 = "navajowhite",
+      peg$c959 = peg$literalExpectation("navajowhite", false),
+      peg$c960 = function() { return '#ffdeadff'; },
+      peg$c961 = "NavajoWhite",
+      peg$c962 = peg$literalExpectation("NavajoWhite", false),
+      peg$c963 = "navy",
+      peg$c964 = peg$literalExpectation("navy", false),
+      peg$c965 = function() { return '#000080ff'; },
+      peg$c966 = "Navy",
+      peg$c967 = peg$literalExpectation("Navy", false),
+      peg$c968 = "oldlace",
+      peg$c969 = peg$literalExpectation("oldlace", false),
+      peg$c970 = function() { return '#fdf5e6ff'; },
+      peg$c971 = "OldLace",
+      peg$c972 = peg$literalExpectation("OldLace", false),
+      peg$c973 = "olivedrab",
+      peg$c974 = peg$literalExpectation("olivedrab", false),
+      peg$c975 = function() { return '#6b8e23ff'; },
+      peg$c976 = "OliveDrab",
+      peg$c977 = peg$literalExpectation("OliveDrab", false),
+      peg$c978 = "olive",
+      peg$c979 = peg$literalExpectation("olive", false),
+      peg$c980 = function() { return '#808000ff'; },
+      peg$c981 = "Olive",
+      peg$c982 = peg$literalExpectation("Olive", false),
+      peg$c983 = "orangered",
+      peg$c984 = peg$literalExpectation("orangered", false),
+      peg$c985 = function() { return '#ff4500ff'; },
+      peg$c986 = "OrangeRed",
+      peg$c987 = peg$literalExpectation("OrangeRed", false),
+      peg$c988 = "orange",
+      peg$c989 = peg$literalExpectation("orange", false),
+      peg$c990 = function() { return '#ffa500ff'; },
+      peg$c991 = "Orange",
+      peg$c992 = peg$literalExpectation("Orange", false),
+      peg$c993 = "orchid",
+      peg$c994 = peg$literalExpectation("orchid", false),
+      peg$c995 = function() { return '#da70d6ff'; },
+      peg$c996 = "Orchid",
+      peg$c997 = peg$literalExpectation("Orchid", false),
+      peg$c998 = "palegoldenrod",
+      peg$c999 = peg$literalExpectation("palegoldenrod", false),
+      peg$c1000 = function() { return '#eee8aaff'; },
+      peg$c1001 = "PaleGoldenRod",
+      peg$c1002 = peg$literalExpectation("PaleGoldenRod", false),
+      peg$c1003 = "palegreen",
+      peg$c1004 = peg$literalExpectation("palegreen", false),
+      peg$c1005 = function() { return '#98fb98ff'; },
+      peg$c1006 = "PaleGreen",
+      peg$c1007 = peg$literalExpectation("PaleGreen", false),
+      peg$c1008 = "paleturquoise",
+      peg$c1009 = peg$literalExpectation("paleturquoise", false),
+      peg$c1010 = function() { return '#afeeeeff'; },
+      peg$c1011 = "PaleTurquoise",
+      peg$c1012 = peg$literalExpectation("PaleTurquoise", false),
+      peg$c1013 = "palevioletred",
+      peg$c1014 = peg$literalExpectation("palevioletred", false),
+      peg$c1015 = function() { return '#d87093ff'; },
+      peg$c1016 = "PaleVioletRed",
+      peg$c1017 = peg$literalExpectation("PaleVioletRed", false),
+      peg$c1018 = "papayawhip",
+      peg$c1019 = peg$literalExpectation("papayawhip", false),
+      peg$c1020 = function() { return '#ffefd5ff'; },
+      peg$c1021 = "PapayaWhip",
+      peg$c1022 = peg$literalExpectation("PapayaWhip", false),
+      peg$c1023 = "peachpuff",
+      peg$c1024 = peg$literalExpectation("peachpuff", false),
+      peg$c1025 = function() { return '#ffdab9ff'; },
+      peg$c1026 = "PeachPuff",
+      peg$c1027 = peg$literalExpectation("PeachPuff", false),
+      peg$c1028 = "peru",
+      peg$c1029 = peg$literalExpectation("peru", false),
+      peg$c1030 = function() { return '#cd853fff'; },
+      peg$c1031 = "Peru",
+      peg$c1032 = peg$literalExpectation("Peru", false),
+      peg$c1033 = "pink",
+      peg$c1034 = peg$literalExpectation("pink", false),
+      peg$c1035 = function() { return '#ffc0cbff'; },
+      peg$c1036 = "Pink",
+      peg$c1037 = peg$literalExpectation("Pink", false),
+      peg$c1038 = "plum",
+      peg$c1039 = peg$literalExpectation("plum", false),
+      peg$c1040 = function() { return '#dda0ddff'; },
+      peg$c1041 = "Plum",
+      peg$c1042 = peg$literalExpectation("Plum", false),
+      peg$c1043 = "powderblue",
+      peg$c1044 = peg$literalExpectation("powderblue", false),
+      peg$c1045 = function() { return '#b0e0e6ff'; },
+      peg$c1046 = "PowderBlue",
+      peg$c1047 = peg$literalExpectation("PowderBlue", false),
+      peg$c1048 = "purple",
+      peg$c1049 = peg$literalExpectation("purple", false),
+      peg$c1050 = function() { return '#800080ff'; },
+      peg$c1051 = "Purple",
+      peg$c1052 = peg$literalExpectation("Purple", false),
+      peg$c1053 = "red",
+      peg$c1054 = peg$literalExpectation("red", false),
+      peg$c1055 = function() { return '#ff0000ff'; },
+      peg$c1056 = "Red",
+      peg$c1057 = peg$literalExpectation("Red", false),
+      peg$c1058 = "rosybrown",
+      peg$c1059 = peg$literalExpectation("rosybrown", false),
+      peg$c1060 = function() { return '#bc8f8fff'; },
+      peg$c1061 = "RosyBrown",
+      peg$c1062 = peg$literalExpectation("RosyBrown", false),
+      peg$c1063 = "royalblue",
+      peg$c1064 = peg$literalExpectation("royalblue", false),
+      peg$c1065 = function() { return '#4169e1ff'; },
+      peg$c1066 = "RoyalBlue",
+      peg$c1067 = peg$literalExpectation("RoyalBlue", false),
+      peg$c1068 = "saddlebrown",
+      peg$c1069 = peg$literalExpectation("saddlebrown", false),
+      peg$c1070 = function() { return '#8b4513ff'; },
+      peg$c1071 = "SaddleBrown",
+      peg$c1072 = peg$literalExpectation("SaddleBrown", false),
+      peg$c1073 = "salmon",
+      peg$c1074 = peg$literalExpectation("salmon", false),
+      peg$c1075 = function() { return '#fa8072ff'; },
+      peg$c1076 = "Salmon",
+      peg$c1077 = peg$literalExpectation("Salmon", false),
+      peg$c1078 = "sandybrown",
+      peg$c1079 = peg$literalExpectation("sandybrown", false),
+      peg$c1080 = function() { return '#f4a460ff'; },
+      peg$c1081 = "SandyBrown",
+      peg$c1082 = peg$literalExpectation("SandyBrown", false),
+      peg$c1083 = "seagreen",
+      peg$c1084 = peg$literalExpectation("seagreen", false),
+      peg$c1085 = function() { return '#2e8b57ff'; },
+      peg$c1086 = "SeaGreen",
+      peg$c1087 = peg$literalExpectation("SeaGreen", false),
+      peg$c1088 = "seashell",
+      peg$c1089 = peg$literalExpectation("seashell", false),
+      peg$c1090 = function() { return '#fff5eeff'; },
+      peg$c1091 = "SeaShell",
+      peg$c1092 = peg$literalExpectation("SeaShell", false),
+      peg$c1093 = "sienna",
+      peg$c1094 = peg$literalExpectation("sienna", false),
+      peg$c1095 = function() { return '#a0522dff'; },
+      peg$c1096 = "Sienna",
+      peg$c1097 = peg$literalExpectation("Sienna", false),
+      peg$c1098 = "silver",
+      peg$c1099 = peg$literalExpectation("silver", false),
+      peg$c1100 = function() { return '#c0c0c0ff'; },
+      peg$c1101 = "Silver",
+      peg$c1102 = peg$literalExpectation("Silver", false),
+      peg$c1103 = "skyblue",
+      peg$c1104 = peg$literalExpectation("skyblue", false),
+      peg$c1105 = function() { return '#87ceebff'; },
+      peg$c1106 = "SkyBlue",
+      peg$c1107 = peg$literalExpectation("SkyBlue", false),
+      peg$c1108 = "slateblue",
+      peg$c1109 = peg$literalExpectation("slateblue", false),
+      peg$c1110 = function() { return '#6a5acdff'; },
+      peg$c1111 = "SlateBlue",
+      peg$c1112 = peg$literalExpectation("SlateBlue", false),
+      peg$c1113 = "slategray",
+      peg$c1114 = peg$literalExpectation("slategray", false),
+      peg$c1115 = function() { return '#708090ff'; },
+      peg$c1116 = "SlateGray",
+      peg$c1117 = peg$literalExpectation("SlateGray", false),
+      peg$c1118 = "slategrey",
+      peg$c1119 = peg$literalExpectation("slategrey", false),
+      peg$c1120 = "SlateGrey",
+      peg$c1121 = peg$literalExpectation("SlateGrey", false),
+      peg$c1122 = "snow",
+      peg$c1123 = peg$literalExpectation("snow", false),
+      peg$c1124 = function() { return '#fffafaff'; },
+      peg$c1125 = "Snow",
+      peg$c1126 = peg$literalExpectation("Snow", false),
+      peg$c1127 = "springgreen",
+      peg$c1128 = peg$literalExpectation("springgreen", false),
+      peg$c1129 = function() { return '#00ff7fff'; },
+      peg$c1130 = "SpringGreen",
+      peg$c1131 = peg$literalExpectation("SpringGreen", false),
+      peg$c1132 = "steelblue",
+      peg$c1133 = peg$literalExpectation("steelblue", false),
+      peg$c1134 = function() { return '#4682b4ff'; },
+      peg$c1135 = "SteelBlue",
+      peg$c1136 = peg$literalExpectation("SteelBlue", false),
+      peg$c1137 = "tan",
+      peg$c1138 = peg$literalExpectation("tan", false),
+      peg$c1139 = function() { return '#d2b48cff'; },
+      peg$c1140 = "Tan",
+      peg$c1141 = peg$literalExpectation("Tan", false),
+      peg$c1142 = "teal",
+      peg$c1143 = peg$literalExpectation("teal", false),
+      peg$c1144 = function() { return '#008080ff'; },
+      peg$c1145 = "Teal",
+      peg$c1146 = peg$literalExpectation("Teal", false),
+      peg$c1147 = "thistle",
+      peg$c1148 = peg$literalExpectation("thistle", false),
+      peg$c1149 = function() { return '#d8bfd8ff'; },
+      peg$c1150 = "Thistle",
+      peg$c1151 = peg$literalExpectation("Thistle", false),
+      peg$c1152 = "tomato",
+      peg$c1153 = peg$literalExpectation("tomato", false),
+      peg$c1154 = function() { return '#ff6347ff'; },
+      peg$c1155 = "Tomato",
+      peg$c1156 = peg$literalExpectation("Tomato", false),
+      peg$c1157 = "turquoise",
+      peg$c1158 = peg$literalExpectation("turquoise", false),
+      peg$c1159 = function() { return '#40e0d0ff'; },
+      peg$c1160 = "Turquoise",
+      peg$c1161 = peg$literalExpectation("Turquoise", false),
+      peg$c1162 = "violet",
+      peg$c1163 = peg$literalExpectation("violet", false),
+      peg$c1164 = function() { return '#ee82eeff'; },
+      peg$c1165 = "Violet",
+      peg$c1166 = peg$literalExpectation("Violet", false),
+      peg$c1167 = "wheat",
+      peg$c1168 = peg$literalExpectation("wheat", false),
+      peg$c1169 = function() { return '#f5deb3ff'; },
+      peg$c1170 = "Wheat",
+      peg$c1171 = peg$literalExpectation("Wheat", false),
+      peg$c1172 = "whitesmoke",
+      peg$c1173 = peg$literalExpectation("whitesmoke", false),
+      peg$c1174 = function() { return '#f5f5f5ff'; },
+      peg$c1175 = "WhiteSmoke",
+      peg$c1176 = peg$literalExpectation("WhiteSmoke", false),
+      peg$c1177 = "white",
+      peg$c1178 = peg$literalExpectation("white", false),
+      peg$c1179 = function() { return '#ffffffff'; },
+      peg$c1180 = "White",
+      peg$c1181 = peg$literalExpectation("White", false),
+      peg$c1182 = "yellowgreen",
+      peg$c1183 = peg$literalExpectation("yellowgreen", false),
+      peg$c1184 = function() { return '#9acd32ff'; },
+      peg$c1185 = "YellowGreen",
+      peg$c1186 = peg$literalExpectation("YellowGreen", false),
+      peg$c1187 = "yellow",
+      peg$c1188 = peg$literalExpectation("yellow", false),
+      peg$c1189 = function() { return '#ffff00ff'; },
+      peg$c1190 = "Yellow",
+      peg$c1191 = peg$literalExpectation("Yellow", false),
+      peg$c1192 = function(lab) { return lab; },
+      peg$c1193 = "#",
+      peg$c1194 = peg$literalExpectation("#", false),
+      peg$c1195 = function(r, g, b) {
+          return `#${r}${r}${g}${g}${b}${b}ff`; },
+      peg$c1196 = function(r1, r2, g1, g2, b1, b2) {
+          return `#${r1}${r2}${g1}${g2}${b1}${b2}ff`; },
+      peg$c1197 = function(r, g, b, a) {
+          return `#${r}${r}${g}${g}${b}${b}${a}${a}`; },
+      peg$c1198 = function(r1, r2, g1, g2, b1, b2, a1, a2) {
+          return `#${r1}${r2}${g1}${g2}${b1}${b2}${a1}${a2}`; },
+      peg$c1199 = peg$otherExpectation("color"),
+      peg$c1200 = "arc_label",
+      peg$c1201 = peg$literalExpectation("arc_label", false),
+      peg$c1202 = "head_label",
+      peg$c1203 = peg$literalExpectation("head_label", false),
+      peg$c1204 = "tail_label",
+      peg$c1205 = peg$literalExpectation("tail_label", false),
+      peg$c1206 = ":",
+      peg$c1207 = peg$literalExpectation(":", false),
+      peg$c1208 = ";",
+      peg$c1209 = peg$literalExpectation(";", false),
+      peg$c1210 = function(key, value) { return {key:key, value:value}; },
+      peg$c1211 = peg$otherExpectation("single edge color"),
+      peg$c1212 = "edge_color",
+      peg$c1213 = peg$literalExpectation("edge_color", false),
+      peg$c1214 = function(value) { return {key:'single_edge_color', value:value}; },
+      peg$c1215 = peg$otherExpectation("transition line style"),
+      peg$c1216 = "line-style",
+      peg$c1217 = peg$literalExpectation("line-style", false),
+      peg$c1218 = function(value) { return {key:'transition_line_style', value:value}; },
+      peg$c1219 = "{",
+      peg$c1220 = peg$literalExpectation("{", false),
+      peg$c1221 = "}",
+      peg$c1222 = peg$literalExpectation("}", false),
+      peg$c1223 = function(items) { return items; },
+      peg$c1224 = "%",
+      peg$c1225 = peg$literalExpectation("%", false),
+      peg$c1226 = function(value) { return { key: 'arrow probability', value: value }; },
+      peg$c1227 = function(names) { return names.map(i => i[0]); },
+      peg$c1228 = "+|",
+      peg$c1229 = peg$literalExpectation("+|", false),
+      peg$c1230 = function(nzd, dd) { return { key: 'stripe', value:      parseInt(`${nzd}${dd}`, 10) }; },
+      peg$c1231 = "-|",
+      peg$c1232 = peg$literalExpectation("-|", false),
+      peg$c1233 = function(nzd, dd) { return { key: 'stripe', value: -1 * parseInt(`${nzd}${dd}`, 10) }; },
+      peg$c1234 = "+",
+      peg$c1235 = peg$literalExpectation("+", false),
+      peg$c1236 = function(nzd, dd) { return { key: 'cycle', value:      parseInt(`${nzd}${dd}`, 10) }; },
+      peg$c1237 = "-",
+      peg$c1238 = peg$literalExpectation("-", false),
+      peg$c1239 = function(nzd, dd) { return { key: 'cycle', value: -1 * parseInt(`${nzd}${dd}`, 10) }; },
+      peg$c1240 = "+0",
+      peg$c1241 = peg$literalExpectation("+0", false),
+      peg$c1242 = function() { return { key: 'cycle', value: 0                                }; },
+      peg$c1243 = function(r_action, r_prob, l_desc, arrow, r_desc, l_prob, l_action, label, tail) {
+
+            // Reminder: remove this type and the one in Exp if you want to work in pegjs online
+            // TODO: properly type this
+            const base: any = { kind: arrow, to: label };
+
+            if (tail && (tail !== [])) { base.se            = tail;         }
+            if (l_desc)                { base.l_desc        = l_desc;       }
+            if (r_desc)                { base.r_desc        = r_desc;       }
+            if (l_action)              { base.l_action      = l_action;     }
+            if (r_action)              { base.r_action      = r_action;     }
+            if (l_prob)                { base.l_probability = l_prob.value; }
+            if (r_prob)                { base.r_probability = r_prob.value; }
+
+            return base;
+
+          },
+      peg$c1244 = function(label, se) {
+          // Reminder: remove this type and the one in subexp if you want to work in pegjs online
+          // TODO: properly type this
+          const base: any = { key: 'transition', from: label };
+          if (se && (se !== [])) { base.se = se; }
+          return base;
+        },
+      peg$c1245 = "whargarbl",
+      peg$c1246 = peg$literalExpectation("whargarbl", false),
+      peg$c1247 = "todo",
+      peg$c1248 = peg$literalExpectation("todo", false),
+      peg$c1249 = function(validationkey, value) { return {key:validationkey, value:value}; },
+      peg$c1250 = "validation",
+      peg$c1251 = peg$literalExpectation("validation", false),
+      peg$c1252 = "};",
+      peg$c1253 = peg$literalExpectation("};", false),
+      peg$c1254 = function(validation_items) {
+          return { config_kind: "validation", config_items: validation_items || [] };
+        },
+      peg$c1255 = "dot",
+      peg$c1256 = peg$literalExpectation("dot", false),
+      peg$c1257 = "circo",
+      peg$c1258 = peg$literalExpectation("circo", false),
+      peg$c1259 = "fdp",
+      peg$c1260 = peg$literalExpectation("fdp", false),
+      peg$c1261 = "neato",
+      peg$c1262 = peg$literalExpectation("neato", false),
+      peg$c1263 = "state",
+      peg$c1264 = peg$literalExpectation("state", false),
+      peg$c1265 = function(state_items) {
+          return { key: "default_state_config", value: state_items || [] };
+        },
+      peg$c1266 = "start_state",
+      peg$c1267 = peg$literalExpectation("start_state", false),
+      peg$c1268 = function(state_items) {
+          return { key: "default_start_state_config", value: state_items || [] };
+        },
+      peg$c1269 = "end_state",
+      peg$c1270 = peg$literalExpectation("end_state", false),
+      peg$c1271 = function(state_items) {
+          return { key: "default_end_state_config", value: state_items || [] };
+        },
+      peg$c1272 = "active_state",
+      peg$c1273 = peg$literalExpectation("active_state", false),
+      peg$c1274 = function(state_items) {
+          return { key: "default_active_state_config", value: state_items || [] };
+        },
+      peg$c1275 = "terminal_state",
+      peg$c1276 = peg$literalExpectation("terminal_state", false),
+      peg$c1277 = function(state_items) {
+          return { key: "default_terminal_state_config", value: state_items || [] };
+        },
+      peg$c1278 = "hooked_state",
+      peg$c1279 = peg$literalExpectation("hooked_state", false),
+      peg$c1280 = function(state_items) {
+          return { key: "default_hooked_state_config", value: state_items || [] };
+        },
+      peg$c1281 = function(actionkey, value) { return {key:actionkey, value:value}; },
+      peg$c1282 = "action",
+      peg$c1283 = peg$literalExpectation("action", false),
+      peg$c1284 = function(action_items) {
+          return { config_kind: "action", config_items: action_items || [] };
+        },
+      peg$c1285 = function(key, value) { return { key, value }; },
+      peg$c1286 = peg$otherExpectation("graph default edge color"),
+      peg$c1287 = function(value) { return { key:'graph_default_edge_color', value }; },
+      peg$c1288 = "transition",
+      peg$c1289 = peg$literalExpectation("transition", false),
+      peg$c1290 = function(transition_items) {
+          return { config_kind: "transition", config_items: transition_items || [] };
+        },
+      peg$c1291 = "graph_layout",
+      peg$c1292 = peg$literalExpectation("graph_layout", false),
+      peg$c1293 = function(value) { return { key: "graph_layout",    value: value }; },
+      peg$c1294 = "start_states",
+      peg$c1295 = peg$literalExpectation("start_states", false),
+      peg$c1296 = function(value) { return { key: "start_states",    value: value }; },
+      peg$c1297 = "end_states",
+      peg$c1298 = peg$literalExpectation("end_states", false),
+      peg$c1299 = function(value) { return { key: "end_states",      value: value }; },
+      peg$c1300 = "graph_bg_color",
+      peg$c1301 = peg$literalExpectation("graph_bg_color", false),
+      peg$c1302 = function(value) { return { key: "graph_bg_color",  value: value }; },
+      peg$c1303 = "allows_override",
+      peg$c1304 = peg$literalExpectation("allows_override", false),
+      peg$c1305 = function(value) { return { key: "allows_override", value: value }; },
+      peg$c1306 = function() { return true;      },
+      peg$c1307 = function() { return false;     },
+      peg$c1308 = peg$otherExpectation("configuration"),
+      peg$c1309 = "MIT",
+      peg$c1310 = peg$literalExpectation("MIT", false),
+      peg$c1311 = "BSD 2-clause",
+      peg$c1312 = peg$literalExpectation("BSD 2-clause", false),
+      peg$c1313 = "BSD 3-clause",
+      peg$c1314 = peg$literalExpectation("BSD 3-clause", false),
+      peg$c1315 = "Apache 2.0",
+      peg$c1316 = peg$literalExpectation("Apache 2.0", false),
+      peg$c1317 = "Mozilla 2.0",
+      peg$c1318 = peg$literalExpectation("Mozilla 2.0", false),
+      peg$c1319 = "Public domain",
+      peg$c1320 = peg$literalExpectation("Public domain", false),
+      peg$c1321 = "GPL v2",
+      peg$c1322 = peg$literalExpectation("GPL v2", false),
+      peg$c1323 = "GPL v3",
+      peg$c1324 = peg$literalExpectation("GPL v3", false),
+      peg$c1325 = "LGPL v2.1",
+      peg$c1326 = peg$literalExpectation("LGPL v2.1", false),
+      peg$c1327 = "LGPL v3.0",
+      peg$c1328 = peg$literalExpectation("LGPL v3.0", false),
+      peg$c1329 = "Unknown",
+      peg$c1330 = peg$literalExpectation("Unknown", false),
+      peg$c1331 = peg$otherExpectation("direction"),
+      peg$c1332 = "up",
+      peg$c1333 = peg$literalExpectation("up", false),
+      peg$c1334 = "right",
+      peg$c1335 = peg$literalExpectation("right", false),
+      peg$c1336 = "down",
+      peg$c1337 = peg$literalExpectation("down", false),
+      peg$c1338 = "left",
+      peg$c1339 = peg$literalExpectation("left", false),
+      peg$c1340 = peg$otherExpectation("hook definition (open/closed)"),
+      peg$c1341 = "open",
+      peg$c1342 = peg$literalExpectation("open", false),
+      peg$c1343 = "closed",
+      peg$c1344 = peg$literalExpectation("closed", false),
+      peg$c1345 = "machine_author",
+      peg$c1346 = peg$literalExpectation("machine_author", false),
+      peg$c1347 = function(value) { return { key: "machine_author", value }; },
+      peg$c1348 = "machine_contributor",
+      peg$c1349 = peg$literalExpectation("machine_contributor", false),
+      peg$c1350 = function(value) { return { key: "machine_contributor", value }; },
+      peg$c1351 = "machine_comment",
+      peg$c1352 = peg$literalExpectation("machine_comment", false),
+      peg$c1353 = function(value) { return { key: "machine_comment", value }; },
+      peg$c1354 = "machine_definition",
+      peg$c1355 = peg$literalExpectation("machine_definition", false),
+      peg$c1356 = function(value) { return { key: "machine_definition", value }; },
+      peg$c1357 = "machine_name",
+      peg$c1358 = peg$literalExpectation("machine_name", false),
+      peg$c1359 = function(value) { return { key: "machine_name", value }; },
+      peg$c1360 = "machine_reference",
+      peg$c1361 = peg$literalExpectation("machine_reference", false),
+      peg$c1362 = function(value) { return { key: "machine_reference", value }; },
+      peg$c1363 = "machine_version",
+      peg$c1364 = peg$literalExpectation("machine_version", false),
+      peg$c1365 = function(value) { return { key: "machine_version", value }; },
+      peg$c1366 = "machine_license",
+      peg$c1367 = peg$literalExpectation("machine_license", false),
+      peg$c1368 = function(value) { return { key: "machine_license", value }; },
+      peg$c1369 = "machine_language",
+      peg$c1370 = peg$literalExpectation("machine_language", false),
+      peg$c1371 = function(value) { return { key: "machine_language", value }; },
+      peg$c1372 = "fsl_version",
+      peg$c1373 = peg$literalExpectation("fsl_version", false),
+      peg$c1374 = function(value) { return { key: "fsl_version", value }; },
+      peg$c1375 = "theme",
+      peg$c1376 = peg$literalExpectation("theme", false),
+      peg$c1377 = function(value) { return { key: "theme", value }; },
+      peg$c1378 = "flow",
+      peg$c1379 = peg$literalExpectation("flow", false),
+      peg$c1380 = function(value) { return { key: "flow", value }; },
+      peg$c1381 = "hooks",
+      peg$c1382 = peg$literalExpectation("hooks", false),
+      peg$c1383 = function(value) { return { key: "hook_definition", value }; },
+      peg$c1384 = "dot_preamble",
+      peg$c1385 = peg$literalExpectation("dot_preamble", false),
+      peg$c1386 = function(value) { return { key: "dot_preamble", value }; },
+      peg$c1387 = peg$otherExpectation("machine attribute"),
+      peg$c1388 = "label",
+      peg$c1389 = peg$literalExpectation("label", false),
+      peg$c1390 = function(value) { return { key:'state-label', value }; },
+      peg$c1391 = "color",
+      peg$c1392 = peg$literalExpectation("color", false),
+      peg$c1393 = function(value) { return { key:'color', value }; },
+      peg$c1394 = peg$otherExpectation("text color"),
+      peg$c1395 = "text-color",
+      peg$c1396 = peg$literalExpectation("text-color", false),
+      peg$c1397 = function(value) { return { key:'text-color', value }; },
+      peg$c1398 = peg$otherExpectation("background color"),
+      peg$c1399 = "background-color",
+      peg$c1400 = peg$literalExpectation("background-color", false),
+      peg$c1401 = function(value) { return { key:'background-color', value }; },
+      peg$c1402 = peg$otherExpectation("border color"),
+      peg$c1403 = "border-color",
+      peg$c1404 = peg$literalExpectation("border-color", false),
+      peg$c1405 = function(value) { return { key:'border-color', value }; },
+      peg$c1406 = peg$otherExpectation("shape"),
+      peg$c1407 = "shape",
+      peg$c1408 = peg$literalExpectation("shape", false),
+      peg$c1409 = function(value) { return { key:'shape', value }; },
+      peg$c1410 = peg$otherExpectation("corners"),
+      peg$c1411 = "corners",
+      peg$c1412 = peg$literalExpectation("corners", false),
+      peg$c1413 = function(value) { return { key:'corners', value }; },
+      peg$c1414 = peg$otherExpectation("linestyle"),
+      peg$c1415 = function(value) { return { key:'line-style', value }; },
+      peg$c1416 = "linestyle",
+      peg$c1417 = peg$literalExpectation("linestyle", false),
+      peg$c1418 = peg$otherExpectation("state property"),
+      peg$c1419 = "property",
+      peg$c1420 = peg$literalExpectation("property", false),
+      peg$c1421 = function(name, value) {
+          return { key: 'state_property', name, value }
+        },
+      peg$c1422 = "required",
+      peg$c1423 = peg$literalExpectation("required", false),
+      peg$c1424 = function(name, value) {
+          return { key: 'state_property', name, value, required: true }
+        },
+      peg$c1425 = function(name, value) { return { key:'state_declaration', name, value }; },
+      peg$c1426 = "&",
+      peg$c1427 = peg$literalExpectation("&", false),
+      peg$c1428 = function(name, value) { return { key:'named_list', name, value }; },
+      peg$c1429 = function(name, default_value) { return { key:'property_definition', name, default_value, required: true }; },
+      peg$c1430 = function(name) { return { key:'property_definition', name,                required: true }; },
+      peg$c1431 = function(name, default_value) { return { key:'property_definition', name, default_value                 }; },
+      peg$c1432 = function(name) { return { key:'property_definition', name                                }; },
+      peg$c1433 = "arrange",
+      peg$c1434 = peg$literalExpectation("arrange", false),
+      peg$c1435 = function(value) { return { key: 'arrange_declaration', value }; },
+      peg$c1436 = "arrange-start",
+      peg$c1437 = peg$literalExpectation("arrange-start", false),
+      peg$c1438 = function(value) { return { key: 'arrange_start_declaration', value }; },
+      peg$c1439 = "arrange-end",
+      peg$c1440 = peg$literalExpectation("arrange-end", false),
+      peg$c1441 = function(value) { return { key: 'arrange_end_declaration', value }; },
+      peg$c1442 = 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;
+
+  if ("startRule" in options) {
+    if (!(options.startRule in peg$startRuleFunctions)) {
+      throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
+    }
+
+    peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
+  }
+
+  function text() {
+    return input.substring(peg$savedPos, peg$currPos);
+  }
+
+  function location() {
+    return peg$computeLocation(peg$savedPos, peg$currPos);
+  }
+
+  function expected(description, location) {
+    location = location !== void 0 ? location : peg$computeLocation(peg$savedPos, peg$currPos)
+
+    throw peg$buildStructuredError(
+      [peg$otherExpectation(description)],
+      input.substring(peg$savedPos, peg$currPos),
+      location
+    );
+  }
+
+  function error(message, location) {
+    location = location !== void 0 ? location : peg$computeLocation(peg$savedPos, peg$currPos)
+
+    throw peg$buildSimpleError(message, location);
+  }
+
+  function peg$literalExpectation(text, ignoreCase) {
+    return { type: "literal", text: text, ignoreCase: ignoreCase };
+  }
+
+  function peg$classExpectation(parts, inverted, ignoreCase) {
+    return { type: "class", parts: parts, inverted: inverted, ignoreCase: ignoreCase };
+  }
+
+  function peg$anyExpectation() {
+    return { type: "any" };
+  }
+
+  function peg$endExpectation() {
+    return { type: "end" };
+  }
+
+  function peg$otherExpectation(description) {
+    return { type: "other", description: description };
+  }
+
+  function peg$computePosDetails(pos) {
+    var details = peg$posDetailsCache[pos], p;
+
+    if (details) {
+      return details;
+    } else {
+      p = pos - 1;
+      while (!peg$posDetailsCache[p]) {
+        p--;
+      }
+
+      details = peg$posDetailsCache[p];
+      details = {
+        line:   details.line,
+        column: details.column
+      };
+
+      while (p < pos) {
+        if (input.charCodeAt(p) === 10) {
+          details.line++;
+          details.column = 1;
+        } else {
+          details.column++;
+        }
+
+        p++;
+      }
+
+      peg$posDetailsCache[pos] = details;
+      return details;
+    }
+  }
+
+  function peg$computeLocation(startPos, endPos) {
+    var startPosDetails = peg$computePosDetails(startPos),
+        endPosDetails   = peg$computePosDetails(endPos);
+
+    return {
+      start: {
+        offset: startPos,
+        line:   startPosDetails.line,
+        column: startPosDetails.column
+      },
+      end: {
+        offset: endPos,
+        line:   endPosDetails.line,
+        column: endPosDetails.column
+      }
+    };
+  }
+
+  function peg$fail(expected) {
+    if (peg$currPos < peg$maxFailPos) { return; }
+
+    if (peg$currPos > peg$maxFailPos) {
+      peg$maxFailPos = peg$currPos;
+      peg$maxFailExpected = [];
+    }
+
+    peg$maxFailExpected.push(expected);
+  }
+
+  function peg$buildSimpleError(message, location) {
+    return new peg$SyntaxError(message, null, null, location);
+  }
+
+  function peg$buildStructuredError(expected, found, location) {
+    return new peg$SyntaxError(
+      peg$SyntaxError.buildMessage(expected, found),
+      expected,
+      found,
+      location
+    );
+  }
+
+  function peg$parseDocument() {
+    var s0, s1, s2, s3;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseTermList();
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s1 = peg$c0(s2);
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseTheme() {
+    var s0;
+
+    if (input.substr(peg$currPos, 4) === peg$c1) {
+      s0 = peg$c1;
+      peg$currPos += 4;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c2); }
+    }
+    if (s0 === peg$FAILED) {
+      if (input.substr(peg$currPos, 7) === peg$c3) {
+        s0 = peg$c3;
+        peg$currPos += 7;
+      } else {
+        s0 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c4); }
+      }
+      if (s0 === peg$FAILED) {
+        if (input.substr(peg$currPos, 6) === peg$c5) {
+          s0 = peg$c5;
+          peg$currPos += 6;
+        } else {
+          s0 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$c6); }
+        }
+        if (s0 === peg$FAILED) {
+          if (input.substr(peg$currPos, 5) === peg$c7) {
+            s0 = peg$c7;
+            peg$currPos += 5;
+          } else {
+            s0 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c8); }
+          }
+          if (s0 === peg$FAILED) {
+            if (input.substr(peg$currPos, 4) === peg$c9) {
+              s0 = peg$c9;
+              peg$currPos += 4;
+            } else {
+              s0 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$c10); }
+            }
+          }
+        }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseThemeOrThemeList() {
+    var s0, s1, s2, s3, s4, s5, s6;
+
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 91) {
+      s1 = peg$c11;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c12); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseWS();
+      if (s2 === peg$FAILED) {
+        s2 = null;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = [];
+        s4 = peg$currPos;
+        s5 = peg$parseTheme();
+        if (s5 !== peg$FAILED) {
+          s6 = peg$parseWS();
+          if (s6 !== peg$FAILED) {
+            s5 = [s5, s6];
+            s4 = s5;
+          } else {
+            peg$currPos = s4;
+            s4 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s4;
+          s4 = peg$FAILED;
+        }
+        while (s4 !== peg$FAILED) {
+          s3.push(s4);
+          s4 = peg$currPos;
+          s5 = peg$parseTheme();
+          if (s5 !== peg$FAILED) {
+            s6 = peg$parseWS();
+            if (s6 !== peg$FAILED) {
+              s5 = [s5, s6];
+              s4 = s5;
+            } else {
+              peg$currPos = s4;
+              s4 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s4;
+            s4 = peg$FAILED;
+          }
+        }
+        if (s3 !== peg$FAILED) {
+          s4 = peg$parseTheme();
+          if (s4 === peg$FAILED) {
+            s4 = null;
+          }
+          if (s4 !== peg$FAILED) {
+            if (input.charCodeAt(peg$currPos) === 93) {
+              s5 = peg$c13;
+              peg$currPos++;
+            } else {
+              s5 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$c14); }
+            }
+            if (s5 !== peg$FAILED) {
+              peg$savedPos = s0;
+              s1 = peg$c15(s3, s4);
+              s0 = s1;
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = peg$parseTheme();
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c16(s1);
+      }
+      s0 = s1;
+    }
+
+    return s0;
+  }
+
+  function peg$parseGvizShape() {
+    var s0;
+
+    if (input.substr(peg$currPos, 5) === peg$c17) {
+      s0 = peg$c17;
+      peg$currPos += 5;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c18); }
+    }
+    if (s0 === peg$FAILED) {
+      if (input.substr(peg$currPos, 7) === peg$c19) {
+        s0 = peg$c19;
+        peg$currPos += 7;
+      } else {
+        s0 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c20); }
+      }
+      if (s0 === peg$FAILED) {
+        if (input.substr(peg$currPos, 7) === peg$c21) {
+          s0 = peg$c21;
+          peg$currPos += 7;
+        } else {
+          s0 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$c22); }
+        }
+        if (s0 === peg$FAILED) {
+          if (input.substr(peg$currPos, 4) === peg$c23) {
+            s0 = peg$c23;
+            peg$currPos += 4;
+          } else {
+            s0 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c24); }
+          }
+          if (s0 === peg$FAILED) {
+            if (input.substr(peg$currPos, 6) === peg$c25) {
+              s0 = peg$c25;
+              peg$currPos += 6;
+            } else {
+              s0 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$c26); }
+            }
+            if (s0 === peg$FAILED) {
+              if (input.substr(peg$currPos, 5) === peg$c27) {
+                s0 = peg$c27;
+                peg$currPos += 5;
+              } else {
+                s0 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$c28); }
+              }
+              if (s0 === peg$FAILED) {
+                if (input.substr(peg$currPos, 3) === peg$c29) {
+                  s0 = peg$c29;
+                  peg$currPos += 3;
+                } else {
+                  s0 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$c30); }
+                }
+                if (s0 === peg$FAILED) {
+                  if (input.substr(peg$currPos, 8) === peg$c31) {
+                    s0 = peg$c31;
+                    peg$currPos += 8;
+                  } else {
+                    s0 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c32); }
+                  }
+                  if (s0 === peg$FAILED) {
+                    if (input.substr(peg$currPos, 9) === peg$c33) {
+                      s0 = peg$c33;
+                      peg$currPos += 9;
+                    } else {
+                      s0 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$c34); }
+                    }
+                    if (s0 === peg$FAILED) {
+                      if (input.substr(peg$currPos, 5) === peg$c35) {
+                        s0 = peg$c35;
+                        peg$currPos += 5;
+                      } else {
+                        s0 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$c36); }
+                      }
+                      if (s0 === peg$FAILED) {
+                        if (input.substr(peg$currPos, 7) === peg$c37) {
+                          s0 = peg$c37;
+                          peg$currPos += 7;
+                        } else {
+                          s0 = peg$FAILED;
+                          if (peg$silentFails === 0) { peg$fail(peg$c38); }
+                        }
+                        if (s0 === peg$FAILED) {
+                          if (input.substr(peg$currPos, 9) === peg$c39) {
+                            s0 = peg$c39;
+                            peg$currPos += 9;
+                          } else {
+                            s0 = peg$FAILED;
+                            if (peg$silentFails === 0) { peg$fail(peg$c40); }
+                          }
+                          if (s0 === peg$FAILED) {
+                            if (input.substr(peg$currPos, 13) === peg$c41) {
+                              s0 = peg$c41;
+                              peg$currPos += 13;
+                            } else {
+                              s0 = peg$FAILED;
+                              if (peg$silentFails === 0) { peg$fail(peg$c42); }
+                            }
+                            if (s0 === peg$FAILED) {
+                              if (input.substr(peg$currPos, 5) === peg$c43) {
+                                s0 = peg$c43;
+                                peg$currPos += 5;
+                              } else {
+                                s0 = peg$FAILED;
+                                if (peg$silentFails === 0) { peg$fail(peg$c44); }
+                              }
+                              if (s0 === peg$FAILED) {
+                                if (input.substr(peg$currPos, 8) === peg$c45) {
+                                  s0 = peg$c45;
+                                  peg$currPos += 8;
+                                } else {
+                                  s0 = peg$FAILED;
+                                  if (peg$silentFails === 0) { peg$fail(peg$c46); }
+                                }
+                                if (s0 === peg$FAILED) {
+                                  if (input.substr(peg$currPos, 7) === peg$c47) {
+                                    s0 = peg$c47;
+                                    peg$currPos += 7;
+                                  } else {
+                                    s0 = peg$FAILED;
+                                    if (peg$silentFails === 0) { peg$fail(peg$c48); }
+                                  }
+                                  if (s0 === peg$FAILED) {
+                                    if (input.substr(peg$currPos, 8) === peg$c49) {
+                                      s0 = peg$c49;
+                                      peg$currPos += 8;
+                                    } else {
+                                      s0 = peg$FAILED;
+                                      if (peg$silentFails === 0) { peg$fail(peg$c50); }
+                                    }
+                                    if (s0 === peg$FAILED) {
+                                      if (input.substr(peg$currPos, 7) === peg$c51) {
+                                        s0 = peg$c51;
+                                        peg$currPos += 7;
+                                      } else {
+                                        s0 = peg$FAILED;
+                                        if (peg$silentFails === 0) { peg$fail(peg$c52); }
+                                      }
+                                      if (s0 === peg$FAILED) {
+                                        if (input.substr(peg$currPos, 12) === peg$c53) {
+                                          s0 = peg$c53;
+                                          peg$currPos += 12;
+                                        } else {
+                                          s0 = peg$FAILED;
+                                          if (peg$silentFails === 0) { peg$fail(peg$c54); }
+                                        }
+                                        if (s0 === peg$FAILED) {
+                                          if (input.substr(peg$currPos, 13) === peg$c55) {
+                                            s0 = peg$c55;
+                                            peg$currPos += 13;
+                                          } else {
+                                            s0 = peg$FAILED;
+                                            if (peg$silentFails === 0) { peg$fail(peg$c56); }
+                                          }
+                                          if (s0 === peg$FAILED) {
+                                            if (input.substr(peg$currPos, 13) === peg$c57) {
+                                              s0 = peg$c57;
+                                              peg$currPos += 13;
+                                            } else {
+                                              s0 = peg$FAILED;
+                                              if (peg$silentFails === 0) { peg$fail(peg$c58); }
+                                            }
+                                            if (s0 === peg$FAILED) {
+                                              if (input.substr(peg$currPos, 11) === peg$c59) {
+                                                s0 = peg$c59;
+                                                peg$currPos += 11;
+                                              } else {
+                                                s0 = peg$FAILED;
+                                                if (peg$silentFails === 0) { peg$fail(peg$c60); }
+                                              }
+                                              if (s0 === peg$FAILED) {
+                                                if (input.substr(peg$currPos, 12) === peg$c61) {
+                                                  s0 = peg$c61;
+                                                  peg$currPos += 12;
+                                                } else {
+                                                  s0 = peg$FAILED;
+                                                  if (peg$silentFails === 0) { peg$fail(peg$c62); }
+                                                }
+                                                if (s0 === peg$FAILED) {
+                                                  if (input.substr(peg$currPos, 8) === peg$c63) {
+                                                    s0 = peg$c63;
+                                                    peg$currPos += 8;
+                                                  } else {
+                                                    s0 = peg$FAILED;
+                                                    if (peg$silentFails === 0) { peg$fail(peg$c64); }
+                                                  }
+                                                  if (s0 === peg$FAILED) {
+                                                    if (input.substr(peg$currPos, 8) === peg$c65) {
+                                                      s0 = peg$c65;
+                                                      peg$currPos += 8;
+                                                    } else {
+                                                      s0 = peg$FAILED;
+                                                      if (peg$silentFails === 0) { peg$fail(peg$c66); }
+                                                    }
+                                                    if (s0 === peg$FAILED) {
+                                                      if (input.substr(peg$currPos, 7) === peg$c67) {
+                                                        s0 = peg$c67;
+                                                        peg$currPos += 7;
+                                                      } else {
+                                                        s0 = peg$FAILED;
+                                                        if (peg$silentFails === 0) { peg$fail(peg$c68); }
+                                                      }
+                                                      if (s0 === peg$FAILED) {
+                                                        if (input.substr(peg$currPos, 7) === peg$c69) {
+                                                          s0 = peg$c69;
+                                                          peg$currPos += 7;
+                                                        } else {
+                                                          s0 = peg$FAILED;
+                                                          if (peg$silentFails === 0) { peg$fail(peg$c70); }
+                                                        }
+                                                        if (s0 === peg$FAILED) {
+                                                          if (input.substr(peg$currPos, 9) === peg$c71) {
+                                                            s0 = peg$c71;
+                                                            peg$currPos += 9;
+                                                          } else {
+                                                            s0 = peg$FAILED;
+                                                            if (peg$silentFails === 0) { peg$fail(peg$c72); }
+                                                          }
+                                                          if (s0 === peg$FAILED) {
+                                                            if (input.substr(peg$currPos, 4) === peg$c73) {
+                                                              s0 = peg$c73;
+                                                              peg$currPos += 4;
+                                                            } else {
+                                                              s0 = peg$FAILED;
+                                                              if (peg$silentFails === 0) { peg$fail(peg$c74); }
+                                                            }
+                                                            if (s0 === peg$FAILED) {
+                                                              if (input.substr(peg$currPos, 6) === peg$c75) {
+                                                                s0 = peg$c75;
+                                                                peg$currPos += 6;
+                                                              } else {
+                                                                s0 = peg$FAILED;
+                                                                if (peg$silentFails === 0) { peg$fail(peg$c76); }
+                                                              }
+                                                              if (s0 === peg$FAILED) {
+                                                                if (input.substr(peg$currPos, 4) === peg$c77) {
+                                                                  s0 = peg$c77;
+                                                                  peg$currPos += 4;
+                                                                } else {
+                                                                  s0 = peg$FAILED;
+                                                                  if (peg$silentFails === 0) { peg$fail(peg$c78); }
+                                                                }
+                                                                if (s0 === peg$FAILED) {
+                                                                  if (input.substr(peg$currPos, 4) === peg$c1) {
+                                                                    s0 = peg$c1;
+                                                                    peg$currPos += 4;
+                                                                  } else {
+                                                                    s0 = peg$FAILED;
+                                                                    if (peg$silentFails === 0) { peg$fail(peg$c2); }
+                                                                  }
+                                                                  if (s0 === peg$FAILED) {
+                                                                    if (input.substr(peg$currPos, 9) === peg$c79) {
+                                                                      s0 = peg$c79;
+                                                                      peg$currPos += 9;
+                                                                    } else {
+                                                                      s0 = peg$FAILED;
+                                                                      if (peg$silentFails === 0) { peg$fail(peg$c80); }
+                                                                    }
+                                                                    if (s0 === peg$FAILED) {
+                                                                      if (input.substr(peg$currPos, 8) === peg$c81) {
+                                                                        s0 = peg$c81;
+                                                                        peg$currPos += 8;
+                                                                      } else {
+                                                                        s0 = peg$FAILED;
+                                                                        if (peg$silentFails === 0) { peg$fail(peg$c82); }
+                                                                      }
+                                                                      if (s0 === peg$FAILED) {
+                                                                        if (input.substr(peg$currPos, 4) === peg$c83) {
+                                                                          s0 = peg$c83;
+                                                                          peg$currPos += 4;
+                                                                        } else {
+                                                                          s0 = peg$FAILED;
+                                                                          if (peg$silentFails === 0) { peg$fail(peg$c84); }
+                                                                        }
+                                                                        if (s0 === peg$FAILED) {
+                                                                          if (input.substr(peg$currPos, 3) === peg$c85) {
+                                                                            s0 = peg$c85;
+                                                                            peg$currPos += 3;
+                                                                          } else {
+                                                                            s0 = peg$FAILED;
+                                                                            if (peg$silentFails === 0) { peg$fail(peg$c86); }
+                                                                          }
+                                                                          if (s0 === peg$FAILED) {
+                                                                            if (input.substr(peg$currPos, 6) === peg$c87) {
+                                                                              s0 = peg$c87;
+                                                                              peg$currPos += 6;
+                                                                            } else {
+                                                                              s0 = peg$FAILED;
+                                                                              if (peg$silentFails === 0) { peg$fail(peg$c88); }
+                                                                            }
+                                                                            if (s0 === peg$FAILED) {
+                                                                              if (input.substr(peg$currPos, 3) === peg$c89) {
+                                                                                s0 = peg$c89;
+                                                                                peg$currPos += 3;
+                                                                              } else {
+                                                                                s0 = peg$FAILED;
+                                                                                if (peg$silentFails === 0) { peg$fail(peg$c90); }
+                                                                              }
+                                                                              if (s0 === peg$FAILED) {
+                                                                                if (input.substr(peg$currPos, 9) === peg$c91) {
+                                                                                  s0 = peg$c91;
+                                                                                  peg$currPos += 9;
+                                                                                } else {
+                                                                                  s0 = peg$FAILED;
+                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c92); }
+                                                                                }
+                                                                                if (s0 === peg$FAILED) {
+                                                                                  if (input.substr(peg$currPos, 8) === peg$c93) {
+                                                                                    s0 = peg$c93;
+                                                                                    peg$currPos += 8;
+                                                                                  } else {
+                                                                                    s0 = peg$FAILED;
+                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c94); }
+                                                                                  }
+                                                                                  if (s0 === peg$FAILED) {
+                                                                                    if (input.substr(peg$currPos, 3) === peg$c95) {
+                                                                                      s0 = peg$c95;
+                                                                                      peg$currPos += 3;
+                                                                                    } else {
+                                                                                      s0 = peg$FAILED;
+                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c96); }
+                                                                                    }
+                                                                                    if (s0 === peg$FAILED) {
+                                                                                      if (input.substr(peg$currPos, 10) === peg$c97) {
+                                                                                        s0 = peg$c97;
+                                                                                        peg$currPos += 10;
+                                                                                      } else {
+                                                                                        s0 = peg$FAILED;
+                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c98); }
+                                                                                      }
+                                                                                      if (s0 === peg$FAILED) {
+                                                                                        if (input.substr(peg$currPos, 3) === peg$c99) {
+                                                                                          s0 = peg$c99;
+                                                                                          peg$currPos += 3;
+                                                                                        } else {
+                                                                                          s0 = peg$FAILED;
+                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c100); }
+                                                                                        }
+                                                                                        if (s0 === peg$FAILED) {
+                                                                                          if (input.substr(peg$currPos, 10) === peg$c101) {
+                                                                                            s0 = peg$c101;
+                                                                                            peg$currPos += 10;
+                                                                                          } else {
+                                                                                            s0 = peg$FAILED;
+                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c102); }
+                                                                                          }
+                                                                                          if (s0 === peg$FAILED) {
+                                                                                            if (input.substr(peg$currPos, 15) === peg$c103) {
+                                                                                              s0 = peg$c103;
+                                                                                              peg$currPos += 15;
+                                                                                            } else {
+                                                                                              s0 = peg$FAILED;
+                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c104); }
+                                                                                            }
+                                                                                            if (s0 === peg$FAILED) {
+                                                                                              if (input.substr(peg$currPos, 13) === peg$c105) {
+                                                                                                s0 = peg$c105;
+                                                                                                peg$currPos += 13;
+                                                                                              } else {
+                                                                                                s0 = peg$FAILED;
+                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c106); }
+                                                                                              }
+                                                                                              if (s0 === peg$FAILED) {
+                                                                                                if (input.substr(peg$currPos, 14) === peg$c107) {
+                                                                                                  s0 = peg$c107;
+                                                                                                  peg$currPos += 14;
+                                                                                                } else {
+                                                                                                  s0 = peg$FAILED;
+                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c108); }
+                                                                                                }
+                                                                                                if (s0 === peg$FAILED) {
+                                                                                                  if (input.substr(peg$currPos, 9) === peg$c109) {
+                                                                                                    s0 = peg$c109;
+                                                                                                    peg$currPos += 9;
+                                                                                                  } else {
+                                                                                                    s0 = peg$FAILED;
+                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c110); }
+                                                                                                  }
+                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                    if (input.substr(peg$currPos, 8) === peg$c111) {
+                                                                                                      s0 = peg$c111;
+                                                                                                      peg$currPos += 8;
+                                                                                                    } else {
+                                                                                                      s0 = peg$FAILED;
+                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c112); }
+                                                                                                    }
+                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                      if (input.substr(peg$currPos, 9) === peg$c113) {
+                                                                                                        s0 = peg$c113;
+                                                                                                        peg$currPos += 9;
+                                                                                                      } else {
+                                                                                                        s0 = peg$FAILED;
+                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c114); }
+                                                                                                      }
+                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                        if (input.substr(peg$currPos, 9) === peg$c115) {
+                                                                                                          s0 = peg$c115;
+                                                                                                          peg$currPos += 9;
+                                                                                                        } else {
+                                                                                                          s0 = peg$FAILED;
+                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c116); }
+                                                                                                        }
+                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                          if (input.substr(peg$currPos, 8) === peg$c117) {
+                                                                                                            s0 = peg$c117;
+                                                                                                            peg$currPos += 8;
+                                                                                                          } else {
+                                                                                                            s0 = peg$FAILED;
+                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c118); }
+                                                                                                          }
+                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                            if (input.substr(peg$currPos, 7) === peg$c119) {
+                                                                                                              s0 = peg$c119;
+                                                                                                              peg$currPos += 7;
+                                                                                                            } else {
+                                                                                                              s0 = peg$FAILED;
+                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c120); }
+                                                                                                            }
+                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                              if (input.substr(peg$currPos, 12) === peg$c121) {
+                                                                                                                s0 = peg$c121;
+                                                                                                                peg$currPos += 12;
+                                                                                                              } else {
+                                                                                                                s0 = peg$FAILED;
+                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c122); }
+                                                                                                              }
+                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                if (input.substr(peg$currPos, 11) === peg$c123) {
+                                                                                                                  s0 = peg$c123;
+                                                                                                                  peg$currPos += 11;
+                                                                                                                } else {
+                                                                                                                  s0 = peg$FAILED;
+                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c124); }
+                                                                                                                }
+                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                  if (input.substr(peg$currPos, 9) === peg$c125) {
+                                                                                                                    s0 = peg$c125;
+                                                                                                                    peg$currPos += 9;
+                                                                                                                  } else {
+                                                                                                                    s0 = peg$FAILED;
+                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c126); }
+                                                                                                                  }
+                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                    if (input.substr(peg$currPos, 6) === peg$c127) {
+                                                                                                                      s0 = peg$c127;
+                                                                                                                      peg$currPos += 6;
+                                                                                                                    } else {
+                                                                                                                      s0 = peg$FAILED;
+                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c128); }
+                                                                                                                    }
+                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                      if (input.substr(peg$currPos, 6) === peg$c129) {
+                                                                                                                        s0 = peg$c129;
+                                                                                                                        peg$currPos += 6;
+                                                                                                                      } else {
+                                                                                                                        s0 = peg$FAILED;
+                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c130); }
+                                                                                                                      }
+                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                        if (input.substr(peg$currPos, 9) === peg$c131) {
+                                                                                                                          s0 = peg$c131;
+                                                                                                                          peg$currPos += 9;
+                                                                                                                        } else {
+                                                                                                                          s0 = peg$FAILED;
+                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c132); }
+                                                                                                                        }
+                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                          if (input.substr(peg$currPos, 6) === peg$c133) {
+                                                                                                                            s0 = peg$c133;
+                                                                                                                            peg$currPos += 6;
+                                                                                                                          } else {
+                                                                                                                            s0 = peg$FAILED;
+                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c134); }
+                                                                                                                          }
+                                                                                                                        }
+                                                                                                                      }
+                                                                                                                    }
+                                                                                                                  }
+                                                                                                                }
+                                                                                                              }
+                                                                                                            }
+                                                                                                          }
+                                                                                                        }
+                                                                                                      }
+                                                                                                    }
+                                                                                                  }
+                                                                                                }
+                                                                                              }
+                                                                                            }
+                                                                                          }
+                                                                                        }
+                                                                                      }
+                                                                                    }
+                                                                                  }
+                                                                                }
+                                                                              }
+                                                                            }
+                                                                          }
+                                                                        }
+                                                                      }
+                                                                    }
+                                                                  }
+                                                                }
+                                                              }
+                                                            }
+                                                          }
+                                                        }
+                                                      }
+                                                    }
+                                                  }
+                                                }
+                                              }
+                                            }
+                                          }
+                                        }
+                                      }
+                                    }
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseForwardLightArrow() {
+    var s0, s1;
+
+    peg$silentFails++;
+    if (input.substr(peg$currPos, 2) === peg$c136) {
+      s0 = peg$c136;
+      peg$currPos += 2;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c137); }
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 8594) {
+        s1 = peg$c138;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c139); }
+      }
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c140();
+      }
+      s0 = s1;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c135); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseTwoWayLightArrow() {
+    var s0, s1;
+
+    peg$silentFails++;
+    if (input.substr(peg$currPos, 3) === peg$c142) {
+      s0 = peg$c142;
+      peg$currPos += 3;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c143); }
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 8596) {
+        s1 = peg$c144;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c145); }
+      }
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c146();
+      }
+      s0 = s1;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c141); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseBackLightArrow() {
+    var s0, s1;
+
+    peg$silentFails++;
+    if (input.substr(peg$currPos, 2) === peg$c148) {
+      s0 = peg$c148;
+      peg$currPos += 2;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c149); }
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 8592) {
+        s1 = peg$c150;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c151); }
+      }
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c152();
+      }
+      s0 = s1;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c147); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseForwardFatArrow() {
+    var s0, s1;
+
+    peg$silentFails++;
+    if (input.substr(peg$currPos, 2) === peg$c154) {
+      s0 = peg$c154;
+      peg$currPos += 2;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c155); }
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 8658) {
+        s1 = peg$c156;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c157); }
+      }
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c158();
+      }
+      s0 = s1;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c153); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseTwoWayFatArrow() {
+    var s0, s1;
+
+    peg$silentFails++;
+    if (input.substr(peg$currPos, 3) === peg$c160) {
+      s0 = peg$c160;
+      peg$currPos += 3;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c161); }
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 8660) {
+        s1 = peg$c162;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c163); }
+      }
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c164();
+      }
+      s0 = s1;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c159); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseBackFatArrow() {
+    var s0, s1;
+
+    peg$silentFails++;
+    if (input.substr(peg$currPos, 2) === peg$c166) {
+      s0 = peg$c166;
+      peg$currPos += 2;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c167); }
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 8656) {
+        s1 = peg$c168;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c169); }
+      }
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c170();
+      }
+      s0 = s1;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c165); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseForwardTildeArrow() {
+    var s0, s1;
+
+    peg$silentFails++;
+    if (input.substr(peg$currPos, 2) === peg$c172) {
+      s0 = peg$c172;
+      peg$currPos += 2;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c173); }
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 8603) {
+        s1 = peg$c174;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c175); }
+      }
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c176();
+      }
+      s0 = s1;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c171); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseTwoWayTildeArrow() {
+    var s0, s1;
+
+    peg$silentFails++;
+    if (input.substr(peg$currPos, 3) === peg$c178) {
+      s0 = peg$c178;
+      peg$currPos += 3;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c179); }
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 8622) {
+        s1 = peg$c180;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c181); }
+      }
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c182();
+      }
+      s0 = s1;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c177); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseBackTildeArrow() {
+    var s0, s1;
+
+    peg$silentFails++;
+    if (input.substr(peg$currPos, 2) === peg$c184) {
+      s0 = peg$c184;
+      peg$currPos += 2;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c185); }
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 8602) {
+        s1 = peg$c186;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c187); }
+      }
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c188();
+      }
+      s0 = s1;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c183); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseLightFatArrow() {
+    var s0, s1;
+
+    peg$silentFails++;
+    if (input.substr(peg$currPos, 4) === peg$c190) {
+      s0 = peg$c190;
+      peg$currPos += 4;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c191); }
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 2) === peg$c192) {
+        s1 = peg$c192;
+        peg$currPos += 2;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c193); }
+      }
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c194();
+      }
+      s0 = s1;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c189); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseLightTildeArrow() {
+    var s0, s1;
+
+    peg$silentFails++;
+    if (input.substr(peg$currPos, 4) === peg$c196) {
+      s0 = peg$c196;
+      peg$currPos += 4;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c197); }
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 2) === peg$c198) {
+        s1 = peg$c198;
+        peg$currPos += 2;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c199); }
+      }
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c200();
+      }
+      s0 = s1;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c195); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseFatLightArrow() {
+    var s0, s1;
+
+    peg$silentFails++;
+    if (input.substr(peg$currPos, 4) === peg$c202) {
+      s0 = peg$c202;
+      peg$currPos += 4;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c203); }
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 2) === peg$c204) {
+        s1 = peg$c204;
+        peg$currPos += 2;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c205); }
+      }
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c206();
+      }
+      s0 = s1;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c201); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseFatTildeArrow() {
+    var s0, s1;
+
+    peg$silentFails++;
+    if (input.substr(peg$currPos, 4) === peg$c208) {
+      s0 = peg$c208;
+      peg$currPos += 4;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c209); }
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 2) === peg$c210) {
+        s1 = peg$c210;
+        peg$currPos += 2;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c211); }
+      }
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c212();
+      }
+      s0 = s1;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c207); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseTildeLightArrow() {
+    var s0, s1;
+
+    peg$silentFails++;
+    if (input.substr(peg$currPos, 4) === peg$c214) {
+      s0 = peg$c214;
+      peg$currPos += 4;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c215); }
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 2) === peg$c216) {
+        s1 = peg$c216;
+        peg$currPos += 2;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c217); }
+      }
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c218();
+      }
+      s0 = s1;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c213); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseTildeFatArrow() {
+    var s0, s1;
+
+    peg$silentFails++;
+    if (input.substr(peg$currPos, 4) === peg$c220) {
+      s0 = peg$c220;
+      peg$currPos += 4;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c221); }
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 2) === peg$c222) {
+        s1 = peg$c222;
+        peg$currPos += 2;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c223); }
+      }
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c224();
+      }
+      s0 = s1;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c219); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseLightArrow() {
+    var s0, s1;
+
+    peg$silentFails++;
+    s0 = peg$parseForwardLightArrow();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseTwoWayLightArrow();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parseBackLightArrow();
+      }
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c225); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseFatArrow() {
+    var s0, s1;
+
+    peg$silentFails++;
+    s0 = peg$parseForwardFatArrow();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseTwoWayFatArrow();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parseBackFatArrow();
+      }
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c226); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseTildeArrow() {
+    var s0, s1;
+
+    peg$silentFails++;
+    s0 = peg$parseForwardTildeArrow();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseTwoWayTildeArrow();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parseBackTildeArrow();
+      }
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c227); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseMixedArrow() {
+    var s0, s1;
+
+    peg$silentFails++;
+    s0 = peg$parseLightFatArrow();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseLightTildeArrow();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parseFatLightArrow();
+        if (s0 === peg$FAILED) {
+          s0 = peg$parseFatTildeArrow();
+          if (s0 === peg$FAILED) {
+            s0 = peg$parseTildeLightArrow();
+            if (s0 === peg$FAILED) {
+              s0 = peg$parseTildeFatArrow();
+            }
+          }
+        }
+      }
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c228); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseArrow() {
+    var s0, s1;
+
+    peg$silentFails++;
+    s0 = peg$parseMixedArrow();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseLightArrow();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parseFatArrow();
+        if (s0 === peg$FAILED) {
+          s0 = peg$parseTildeArrow();
+        }
+      }
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c229); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseBoolean() {
+    var s0, s1;
+
+    s0 = peg$currPos;
+    if (input.substr(peg$currPos, 4) === peg$c230) {
+      s1 = peg$c230;
+      peg$currPos += 4;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c231); }
+    }
+    if (s1 !== peg$FAILED) {
+      peg$savedPos = s0;
+      s1 = peg$c232();
+    }
+    s0 = s1;
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 5) === peg$c233) {
+        s1 = peg$c233;
+        peg$currPos += 5;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c234); }
+      }
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c235();
+      }
+      s0 = s1;
+    }
+
+    return s0;
+  }
+
+  function peg$parseCorners() {
+    var s0;
+
+    if (input.substr(peg$currPos, 7) === peg$c236) {
+      s0 = peg$c236;
+      peg$currPos += 7;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c237); }
+    }
+    if (s0 === peg$FAILED) {
+      if (input.substr(peg$currPos, 7) === peg$c238) {
+        s0 = peg$c238;
+        peg$currPos += 7;
+      } else {
+        s0 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c239); }
+      }
+      if (s0 === peg$FAILED) {
+        if (input.substr(peg$currPos, 5) === peg$c240) {
+          s0 = peg$c240;
+          peg$currPos += 5;
+        } else {
+          s0 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$c241); }
+        }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseLineStyle() {
+    var s0;
+
+    if (input.substr(peg$currPos, 5) === peg$c242) {
+      s0 = peg$c242;
+      peg$currPos += 5;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c243); }
+    }
+    if (s0 === peg$FAILED) {
+      if (input.substr(peg$currPos, 6) === peg$c244) {
+        s0 = peg$c244;
+        peg$currPos += 6;
+      } else {
+        s0 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c245); }
+      }
+      if (s0 === peg$FAILED) {
+        if (input.substr(peg$currPos, 6) === peg$c246) {
+          s0 = peg$c246;
+          peg$currPos += 6;
+        } else {
+          s0 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$c247); }
+        }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseChar() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    s0 = peg$parseUnescaped();
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = peg$parseEscape();
+      if (s1 !== peg$FAILED) {
+        if (input.charCodeAt(peg$currPos) === 34) {
+          s2 = peg$c248;
+          peg$currPos++;
+        } else {
+          s2 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$c249); }
+        }
+        if (s2 === peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 92) {
+            s2 = peg$c250;
+            peg$currPos++;
+          } else {
+            s2 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c251); }
+          }
+          if (s2 === peg$FAILED) {
+            if (input.charCodeAt(peg$currPos) === 47) {
+              s2 = peg$c252;
+              peg$currPos++;
+            } else {
+              s2 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$c253); }
+            }
+            if (s2 === peg$FAILED) {
+              s2 = peg$currPos;
+              if (input.charCodeAt(peg$currPos) === 98) {
+                s3 = peg$c254;
+                peg$currPos++;
+              } else {
+                s3 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$c255); }
+              }
+              if (s3 !== peg$FAILED) {
+                peg$savedPos = s2;
+                s3 = peg$c256();
+              }
+              s2 = s3;
+              if (s2 === peg$FAILED) {
+                s2 = peg$currPos;
+                if (input.charCodeAt(peg$currPos) === 102) {
+                  s3 = peg$c257;
+                  peg$currPos++;
+                } else {
+                  s3 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$c258); }
+                }
+                if (s3 !== peg$FAILED) {
+                  peg$savedPos = s2;
+                  s3 = peg$c259();
+                }
+                s2 = s3;
+                if (s2 === peg$FAILED) {
+                  s2 = peg$currPos;
+                  if (input.charCodeAt(peg$currPos) === 110) {
+                    s3 = peg$c260;
+                    peg$currPos++;
+                  } else {
+                    s3 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c261); }
+                  }
+                  if (s3 !== peg$FAILED) {
+                    peg$savedPos = s2;
+                    s3 = peg$c262();
+                  }
+                  s2 = s3;
+                  if (s2 === peg$FAILED) {
+                    s2 = peg$currPos;
+                    if (input.charCodeAt(peg$currPos) === 114) {
+                      s3 = peg$c263;
+                      peg$currPos++;
+                    } else {
+                      s3 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$c264); }
+                    }
+                    if (s3 !== peg$FAILED) {
+                      peg$savedPos = s2;
+                      s3 = peg$c265();
+                    }
+                    s2 = s3;
+                    if (s2 === peg$FAILED) {
+                      s2 = peg$currPos;
+                      if (input.charCodeAt(peg$currPos) === 116) {
+                        s3 = peg$c266;
+                        peg$currPos++;
+                      } else {
+                        s3 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$c267); }
+                      }
+                      if (s3 !== peg$FAILED) {
+                        peg$savedPos = s2;
+                        s3 = peg$c268();
+                      }
+                      s2 = s3;
+                      if (s2 === peg$FAILED) {
+                        s2 = peg$currPos;
+                        if (input.charCodeAt(peg$currPos) === 118) {
+                          s3 = peg$c269;
+                          peg$currPos++;
+                        } else {
+                          s3 = peg$FAILED;
+                          if (peg$silentFails === 0) { peg$fail(peg$c270); }
+                        }
+                        if (s3 !== peg$FAILED) {
+                          peg$savedPos = s2;
+                          s3 = peg$c271();
+                        }
+                        s2 = s3;
+                        if (s2 === peg$FAILED) {
+                          s2 = peg$currPos;
+                          if (input.charCodeAt(peg$currPos) === 117) {
+                            s3 = peg$c272;
+                            peg$currPos++;
+                          } else {
+                            s3 = peg$FAILED;
+                            if (peg$silentFails === 0) { peg$fail(peg$c273); }
+                          }
+                          if (s3 !== peg$FAILED) {
+                            s4 = peg$currPos;
+                            s5 = peg$currPos;
+                            s6 = peg$parseHexDigit();
+                            if (s6 !== peg$FAILED) {
+                              s7 = peg$parseHexDigit();
+                              if (s7 !== peg$FAILED) {
+                                s8 = peg$parseHexDigit();
+                                if (s8 !== peg$FAILED) {
+                                  s9 = peg$parseHexDigit();
+                                  if (s9 !== peg$FAILED) {
+                                    s6 = [s6, s7, s8, s9];
+                                    s5 = s6;
+                                  } else {
+                                    peg$currPos = s5;
+                                    s5 = peg$FAILED;
+                                  }
+                                } else {
+                                  peg$currPos = s5;
+                                  s5 = peg$FAILED;
+                                }
+                              } else {
+                                peg$currPos = s5;
+                                s5 = peg$FAILED;
+                              }
+                            } else {
+                              peg$currPos = s5;
+                              s5 = peg$FAILED;
+                            }
+                            if (s5 !== peg$FAILED) {
+                              s4 = input.substring(s4, peg$currPos);
+                            } else {
+                              s4 = s5;
+                            }
+                            if (s4 !== peg$FAILED) {
+                              peg$savedPos = s2;
+                              s3 = peg$c274(s4);
+                              s2 = s3;
+                            } else {
+                              peg$currPos = s2;
+                              s2 = peg$FAILED;
+                            }
+                          } else {
+                            peg$currPos = s2;
+                            s2 = peg$FAILED;
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+        if (s2 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s1 = peg$c275(s2);
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseNull() {
+    var s0, s1;
+
+    s0 = peg$currPos;
+    if (input.substr(peg$currPos, 4) === peg$c276) {
+      s1 = peg$c276;
+      peg$currPos += 4;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c277); }
+    }
+    if (s1 !== peg$FAILED) {
+      peg$savedPos = s0;
+      s1 = peg$c278();
+    }
+    s0 = s1;
+
+    return s0;
+  }
+
+  function peg$parseUndefined() {
+    var s0, s1;
+
+    s0 = peg$currPos;
+    if (input.substr(peg$currPos, 9) === peg$c279) {
+      s1 = peg$c279;
+      peg$currPos += 9;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c280); }
+    }
+    if (s1 !== peg$FAILED) {
+      peg$savedPos = s0;
+      s1 = peg$c281();
+    }
+    s0 = s1;
+
+    return s0;
+  }
+
+  function peg$parseEscape() {
+    var s0;
+
+    if (input.charCodeAt(peg$currPos) === 92) {
+      s0 = peg$c250;
+      peg$currPos++;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c251); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseQuoteMark() {
+    var s0;
+
+    if (input.charCodeAt(peg$currPos) === 34) {
+      s0 = peg$c248;
+      peg$currPos++;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c249); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseUnescaped() {
+    var s0;
+
+    if (peg$c282.test(input.charAt(peg$currPos))) {
+      s0 = input.charAt(peg$currPos);
+      peg$currPos++;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c283); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseActionLabelChar() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    s0 = peg$parseActionLabelUnescaped();
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = peg$parseEscape();
+      if (s1 !== peg$FAILED) {
+        if (input.charCodeAt(peg$currPos) === 39) {
+          s2 = peg$c284;
+          peg$currPos++;
+        } else {
+          s2 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$c285); }
+        }
+        if (s2 === peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 92) {
+            s2 = peg$c250;
+            peg$currPos++;
+          } else {
+            s2 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c251); }
+          }
+          if (s2 === peg$FAILED) {
+            if (input.charCodeAt(peg$currPos) === 47) {
+              s2 = peg$c252;
+              peg$currPos++;
+            } else {
+              s2 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$c253); }
+            }
+            if (s2 === peg$FAILED) {
+              s2 = peg$currPos;
+              if (input.charCodeAt(peg$currPos) === 98) {
+                s3 = peg$c254;
+                peg$currPos++;
+              } else {
+                s3 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$c255); }
+              }
+              if (s3 !== peg$FAILED) {
+                peg$savedPos = s2;
+                s3 = peg$c256();
+              }
+              s2 = s3;
+              if (s2 === peg$FAILED) {
+                s2 = peg$currPos;
+                if (input.charCodeAt(peg$currPos) === 102) {
+                  s3 = peg$c257;
+                  peg$currPos++;
+                } else {
+                  s3 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$c258); }
+                }
+                if (s3 !== peg$FAILED) {
+                  peg$savedPos = s2;
+                  s3 = peg$c259();
+                }
+                s2 = s3;
+                if (s2 === peg$FAILED) {
+                  s2 = peg$currPos;
+                  if (input.charCodeAt(peg$currPos) === 110) {
+                    s3 = peg$c260;
+                    peg$currPos++;
+                  } else {
+                    s3 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c261); }
+                  }
+                  if (s3 !== peg$FAILED) {
+                    peg$savedPos = s2;
+                    s3 = peg$c262();
+                  }
+                  s2 = s3;
+                  if (s2 === peg$FAILED) {
+                    s2 = peg$currPos;
+                    if (input.charCodeAt(peg$currPos) === 114) {
+                      s3 = peg$c263;
+                      peg$currPos++;
+                    } else {
+                      s3 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$c264); }
+                    }
+                    if (s3 !== peg$FAILED) {
+                      peg$savedPos = s2;
+                      s3 = peg$c265();
+                    }
+                    s2 = s3;
+                    if (s2 === peg$FAILED) {
+                      s2 = peg$currPos;
+                      if (input.charCodeAt(peg$currPos) === 116) {
+                        s3 = peg$c266;
+                        peg$currPos++;
+                      } else {
+                        s3 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$c267); }
+                      }
+                      if (s3 !== peg$FAILED) {
+                        peg$savedPos = s2;
+                        s3 = peg$c268();
+                      }
+                      s2 = s3;
+                      if (s2 === peg$FAILED) {
+                        s2 = peg$currPos;
+                        if (input.charCodeAt(peg$currPos) === 118) {
+                          s3 = peg$c269;
+                          peg$currPos++;
+                        } else {
+                          s3 = peg$FAILED;
+                          if (peg$silentFails === 0) { peg$fail(peg$c270); }
+                        }
+                        if (s3 !== peg$FAILED) {
+                          peg$savedPos = s2;
+                          s3 = peg$c271();
+                        }
+                        s2 = s3;
+                        if (s2 === peg$FAILED) {
+                          s2 = peg$currPos;
+                          if (input.charCodeAt(peg$currPos) === 117) {
+                            s3 = peg$c272;
+                            peg$currPos++;
+                          } else {
+                            s3 = peg$FAILED;
+                            if (peg$silentFails === 0) { peg$fail(peg$c273); }
+                          }
+                          if (s3 !== peg$FAILED) {
+                            s4 = peg$currPos;
+                            s5 = peg$currPos;
+                            s6 = peg$parseHexDigit();
+                            if (s6 !== peg$FAILED) {
+                              s7 = peg$parseHexDigit();
+                              if (s7 !== peg$FAILED) {
+                                s8 = peg$parseHexDigit();
+                                if (s8 !== peg$FAILED) {
+                                  s9 = peg$parseHexDigit();
+                                  if (s9 !== peg$FAILED) {
+                                    s6 = [s6, s7, s8, s9];
+                                    s5 = s6;
+                                  } else {
+                                    peg$currPos = s5;
+                                    s5 = peg$FAILED;
+                                  }
+                                } else {
+                                  peg$currPos = s5;
+                                  s5 = peg$FAILED;
+                                }
+                              } else {
+                                peg$currPos = s5;
+                                s5 = peg$FAILED;
+                              }
+                            } else {
+                              peg$currPos = s5;
+                              s5 = peg$FAILED;
+                            }
+                            if (s5 !== peg$FAILED) {
+                              s4 = input.substring(s4, peg$currPos);
+                            } else {
+                              s4 = s5;
+                            }
+                            if (s4 !== peg$FAILED) {
+                              peg$savedPos = s2;
+                              s3 = peg$c274(s4);
+                              s2 = s3;
+                            } else {
+                              peg$currPos = s2;
+                              s2 = peg$FAILED;
+                            }
+                          } else {
+                            peg$currPos = s2;
+                            s2 = peg$FAILED;
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+        if (s2 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s1 = peg$c275(s2);
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseActionLabelQuoteMark() {
+    var s0;
+
+    if (input.charCodeAt(peg$currPos) === 39) {
+      s0 = peg$c284;
+      peg$currPos++;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c285); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseActionLabelUnescaped() {
+    var s0;
+
+    if (peg$c286.test(input.charAt(peg$currPos))) {
+      s0 = input.charAt(peg$currPos);
+      peg$currPos++;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c287); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseActionLabel() {
+    var s0, s1, s2, s3;
+
+    peg$silentFails++;
+    s0 = peg$currPos;
+    s1 = peg$parseActionLabelQuoteMark();
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$parseActionLabelChar();
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$parseActionLabelChar();
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseActionLabelQuoteMark();
+        if (s3 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s1 = peg$c289(s2);
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c288); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseLineTerminator() {
+    var s0;
+
+    if (peg$c290.test(input.charAt(peg$currPos))) {
+      s0 = input.charAt(peg$currPos);
+      peg$currPos++;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c291); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseWhitespace() {
+    var s0, s1;
+
+    s0 = [];
+    if (peg$c292.test(input.charAt(peg$currPos))) {
+      s1 = input.charAt(peg$currPos);
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c293); }
+    }
+    if (s1 !== peg$FAILED) {
+      while (s1 !== peg$FAILED) {
+        s0.push(s1);
+        if (peg$c292.test(input.charAt(peg$currPos))) {
+          s1 = input.charAt(peg$currPos);
+          peg$currPos++;
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$c293); }
+        }
+      }
+    } else {
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseBlockCommentTail() {
+    var s0, s1, s2;
+
+    if (input.substr(peg$currPos, 2) === peg$c294) {
+      s0 = peg$c294;
+      peg$currPos += 2;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c295); }
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.length > peg$currPos) {
+        s1 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c296); }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$parseBlockCommentTail();
+        if (s2 !== peg$FAILED) {
+          s1 = [s1, s2];
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseBlockComment() {
+    var s0, s1, s2;
+
+    peg$silentFails++;
+    s0 = peg$currPos;
+    if (input.substr(peg$currPos, 2) === peg$c298) {
+      s1 = peg$c298;
+      peg$currPos += 2;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c299); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseBlockCommentTail();
+      if (s2 !== peg$FAILED) {
+        s1 = [s1, s2];
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c297); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseEOF() {
+    var s0, s1;
+
+    s0 = peg$currPos;
+    peg$silentFails++;
+    if (input.length > peg$currPos) {
+      s1 = input.charAt(peg$currPos);
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c296); }
+    }
+    peg$silentFails--;
+    if (s1 === peg$FAILED) {
+      s0 = void 0;
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseLineCommentTail() {
+    var s0, s1, s2;
+
+    s0 = peg$parseLineTerminator();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseEOF();
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        if (input.length > peg$currPos) {
+          s1 = input.charAt(peg$currPos);
+          peg$currPos++;
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$c296); }
+        }
+        if (s1 !== peg$FAILED) {
+          s2 = peg$parseLineCommentTail();
+          if (s2 !== peg$FAILED) {
+            s1 = [s1, s2];
+            s0 = s1;
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseLineComment() {
+    var s0, s1, s2;
+
+    peg$silentFails++;
+    s0 = peg$currPos;
+    if (input.substr(peg$currPos, 2) === peg$c301) {
+      s1 = peg$c301;
+      peg$currPos += 2;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c302); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseLineCommentTail();
+      if (s2 !== peg$FAILED) {
+        s1 = [s1, s2];
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c300); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseWS() {
+    var s0, s1, s2;
+
+    peg$silentFails++;
+    s0 = peg$currPos;
+    s1 = peg$parseBlockComment();
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseWS();
+      if (s2 === peg$FAILED) {
+        s2 = null;
+      }
+      if (s2 !== peg$FAILED) {
+        s1 = [s1, s2];
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = peg$parseLineComment();
+      if (s1 !== peg$FAILED) {
+        s2 = peg$parseWS();
+        if (s2 === peg$FAILED) {
+          s2 = null;
+        }
+        if (s2 !== peg$FAILED) {
+          s1 = [s1, s2];
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        s1 = [];
+        if (peg$c304.test(input.charAt(peg$currPos))) {
+          s2 = input.charAt(peg$currPos);
+          peg$currPos++;
+        } else {
+          s2 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$c305); }
+        }
+        if (s2 !== peg$FAILED) {
+          while (s2 !== peg$FAILED) {
+            s1.push(s2);
+            if (peg$c304.test(input.charAt(peg$currPos))) {
+              s2 = input.charAt(peg$currPos);
+              peg$currPos++;
+            } else {
+              s2 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$c305); }
+            }
+          }
+        } else {
+          s1 = peg$FAILED;
+        }
+        if (s1 !== peg$FAILED) {
+          s2 = peg$parseWS();
+          if (s2 === peg$FAILED) {
+            s2 = null;
+          }
+          if (s2 !== peg$FAILED) {
+            s1 = [s1, s2];
+            s0 = s1;
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      }
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c303); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseString() {
+    var s0, s1, s2, s3;
+
+    peg$silentFails++;
+    s0 = peg$currPos;
+    s1 = peg$parseQuoteMark();
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$parseChar();
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$parseChar();
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseQuoteMark();
+        if (s3 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s1 = peg$c289(s2);
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c306); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseAtomFirstLetter() {
+    var s0;
+
+    if (peg$c307.test(input.charAt(peg$currPos))) {
+      s0 = input.charAt(peg$currPos);
+      peg$currPos++;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c308); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseAtomLetter() {
+    var s0;
+
+    if (peg$c309.test(input.charAt(peg$currPos))) {
+      s0 = input.charAt(peg$currPos);
+      peg$currPos++;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c310); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseAtom() {
+    var s0, s1, s2, s3;
+
+    peg$silentFails++;
+    s0 = peg$currPos;
+    s1 = peg$parseAtomFirstLetter();
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$parseAtomLetter();
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$parseAtomLetter();
+      }
+      if (s2 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c312(s1, s2);
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c311); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseLabel() {
+    var s0, s1;
+
+    peg$silentFails++;
+    s0 = peg$parseAtom();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseString();
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c313); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseIntegerLiteral() {
+    var s0, s1, s2, s3;
+
+    if (input.charCodeAt(peg$currPos) === 48) {
+      s0 = peg$c314;
+      peg$currPos++;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c315); }
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = peg$parseNonZeroDigit();
+      if (s1 !== peg$FAILED) {
+        s2 = [];
+        s3 = peg$parseDecimalDigit();
+        while (s3 !== peg$FAILED) {
+          s2.push(s3);
+          s3 = peg$parseDecimalDigit();
+        }
+        if (s2 !== peg$FAILED) {
+          s1 = [s1, s2];
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseDecimalDigit() {
+    var s0;
+
+    if (peg$c316.test(input.charAt(peg$currPos))) {
+      s0 = input.charAt(peg$currPos);
+      peg$currPos++;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c317); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseNonZeroDigit() {
+    var s0;
+
+    if (peg$c318.test(input.charAt(peg$currPos))) {
+      s0 = input.charAt(peg$currPos);
+      peg$currPos++;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c319); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseHexDigit() {
+    var s0;
+
+    if (peg$c320.test(input.charAt(peg$currPos))) {
+      s0 = input.charAt(peg$currPos);
+      peg$currPos++;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c321); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseBinaryDigit() {
+    var s0;
+
+    if (peg$c322.test(input.charAt(peg$currPos))) {
+      s0 = input.charAt(peg$currPos);
+      peg$currPos++;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c323); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseOctalDigit() {
+    var s0;
+
+    if (peg$c322.test(input.charAt(peg$currPos))) {
+      s0 = input.charAt(peg$currPos);
+      peg$currPos++;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c323); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseNonNegNumber() {
+    var s0, s1, s2, s3, s4;
+
+    peg$silentFails++;
+    s0 = peg$currPos;
+    s1 = peg$parseIntegerLiteral();
+    if (s1 !== peg$FAILED) {
+      if (input.charCodeAt(peg$currPos) === 46) {
+        s2 = peg$c325;
+        peg$currPos++;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c326); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = [];
+        s4 = peg$parseDecimalDigit();
+        while (s4 !== peg$FAILED) {
+          s3.push(s4);
+          s4 = peg$parseDecimalDigit();
+        }
+        if (s3 !== peg$FAILED) {
+          s4 = peg$parseWS();
+          if (s4 === peg$FAILED) {
+            s4 = null;
+          }
+          if (s4 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s1 = peg$c327();
+            s0 = s1;
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = peg$parseIntegerLiteral();
+      if (s1 !== peg$FAILED) {
+        s2 = peg$parseWS();
+        if (s2 === peg$FAILED) {
+          s2 = null;
+        }
+        if (s2 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s1 = peg$c327();
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c324); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseJsNumericLiteral() {
+    var s0, s1;
+
+    peg$silentFails++;
+    s0 = peg$currPos;
+    s1 = peg$parseJsHexIntegerLiteral();
+    if (s1 !== peg$FAILED) {
+      peg$savedPos = s0;
+      s1 = peg$c329(s1);
+    }
+    s0 = s1;
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = peg$parseJsBinaryIntegerLiteral();
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c329(s1);
+      }
+      s0 = s1;
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        s1 = peg$parseNonJsOctalIntegerLiteral();
+        if (s1 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s1 = peg$c329(s1);
+        }
+        s0 = s1;
+        if (s0 === peg$FAILED) {
+          s0 = peg$currPos;
+          s1 = peg$parseJsDecimalLiteral();
+          if (s1 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s1 = peg$c329(s1);
+          }
+          s0 = s1;
+          if (s0 === peg$FAILED) {
+            s0 = peg$currPos;
+            if (input.substr(peg$currPos, 3) === peg$c330) {
+              s1 = peg$c330;
+              peg$currPos += 3;
+            } else {
+              s1 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$c331); }
+            }
+            if (s1 !== peg$FAILED) {
+              peg$savedPos = s0;
+              s1 = peg$c332();
+            }
+            s0 = s1;
+            if (s0 === peg$FAILED) {
+              s0 = peg$currPos;
+              if (input.substr(peg$currPos, 16) === peg$c333) {
+                s1 = peg$c333;
+                peg$currPos += 16;
+              } else {
+                s1 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$c334); }
+              }
+              if (s1 !== peg$FAILED) {
+                peg$savedPos = s0;
+                s1 = peg$c335();
+              }
+              s0 = s1;
+              if (s0 === peg$FAILED) {
+                s0 = peg$currPos;
+                if (input.substr(peg$currPos, 11) === peg$c336) {
+                  s1 = peg$c336;
+                  peg$currPos += 11;
+                } else {
+                  s1 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$c337); }
+                }
+                if (s1 !== peg$FAILED) {
+                  peg$savedPos = s0;
+                  s1 = peg$c335();
+                }
+                s0 = s1;
+                if (s0 === peg$FAILED) {
+                  s0 = peg$currPos;
+                  if (input.substr(peg$currPos, 11) === peg$c338) {
+                    s1 = peg$c338;
+                    peg$currPos += 11;
+                  } else {
+                    s1 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c339); }
+                  }
+                  if (s1 !== peg$FAILED) {
+                    peg$savedPos = s0;
+                    s1 = peg$c335();
+                  }
+                  s0 = s1;
+                  if (s0 === peg$FAILED) {
+                    s0 = peg$currPos;
+                    if (input.substr(peg$currPos, 6) === peg$c340) {
+                      s1 = peg$c340;
+                      peg$currPos += 6;
+                    } else {
+                      s1 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$c341); }
+                    }
+                    if (s1 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c335();
+                    }
+                    s0 = s1;
+                    if (s0 === peg$FAILED) {
+                      s0 = peg$currPos;
+                      if (input.substr(peg$currPos, 9) === peg$c342) {
+                        s1 = peg$c342;
+                        peg$currPos += 9;
+                      } else {
+                        s1 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$c343); }
+                      }
+                      if (s1 !== peg$FAILED) {
+                        peg$savedPos = s0;
+                        s1 = peg$c335();
+                      }
+                      s0 = s1;
+                      if (s0 === peg$FAILED) {
+                        s0 = peg$currPos;
+                        if (input.substr(peg$currPos, 4) === peg$c344) {
+                          s1 = peg$c344;
+                          peg$currPos += 4;
+                        } else {
+                          s1 = peg$FAILED;
+                          if (peg$silentFails === 0) { peg$fail(peg$c345); }
+                        }
+                        if (s1 !== peg$FAILED) {
+                          peg$savedPos = s0;
+                          s1 = peg$c335();
+                        }
+                        s0 = s1;
+                        if (s0 === peg$FAILED) {
+                          s0 = peg$currPos;
+                          if (input.substr(peg$currPos, 2) === peg$c346) {
+                            s1 = peg$c346;
+                            peg$currPos += 2;
+                          } else {
+                            s1 = peg$FAILED;
+                            if (peg$silentFails === 0) { peg$fail(peg$c347); }
+                          }
+                          if (s1 !== peg$FAILED) {
+                            peg$savedPos = s0;
+                            s1 = peg$c335();
+                          }
+                          s0 = s1;
+                          if (s0 === peg$FAILED) {
+                            s0 = peg$currPos;
+                            if (input.substr(peg$currPos, 9) === peg$c348) {
+                              s1 = peg$c348;
+                              peg$currPos += 9;
+                            } else {
+                              s1 = peg$FAILED;
+                              if (peg$silentFails === 0) { peg$fail(peg$c349); }
+                            }
+                            if (s1 !== peg$FAILED) {
+                              peg$savedPos = s0;
+                              s1 = peg$c350();
+                            }
+                            s0 = s1;
+                            if (s0 === peg$FAILED) {
+                              s0 = peg$currPos;
+                              if (input.substr(peg$currPos, 8) === peg$c351) {
+                                s1 = peg$c351;
+                                peg$currPos += 8;
+                              } else {
+                                s1 = peg$FAILED;
+                                if (peg$silentFails === 0) { peg$fail(peg$c352); }
+                              }
+                              if (s1 !== peg$FAILED) {
+                                peg$savedPos = s0;
+                                s1 = peg$c350();
+                              }
+                              s0 = s1;
+                              if (s0 === peg$FAILED) {
+                                s0 = peg$currPos;
+                                if (input.substr(peg$currPos, 4) === peg$c353) {
+                                  s1 = peg$c353;
+                                  peg$currPos += 4;
+                                } else {
+                                  s1 = peg$FAILED;
+                                  if (peg$silentFails === 0) { peg$fail(peg$c354); }
+                                }
+                                if (s1 !== peg$FAILED) {
+                                  peg$savedPos = s0;
+                                  s1 = peg$c350();
+                                }
+                                s0 = s1;
+                                if (s0 === peg$FAILED) {
+                                  s0 = peg$currPos;
+                                  if (input.substr(peg$currPos, 3) === peg$c355) {
+                                    s1 = peg$c355;
+                                    peg$currPos += 3;
+                                  } else {
+                                    s1 = peg$FAILED;
+                                    if (peg$silentFails === 0) { peg$fail(peg$c356); }
+                                  }
+                                  if (s1 !== peg$FAILED) {
+                                    peg$savedPos = s0;
+                                    s1 = peg$c350();
+                                  }
+                                  s0 = s1;
+                                  if (s0 === peg$FAILED) {
+                                    s0 = peg$currPos;
+                                    if (input.charCodeAt(peg$currPos) === 8734) {
+                                      s1 = peg$c357;
+                                      peg$currPos++;
+                                    } else {
+                                      s1 = peg$FAILED;
+                                      if (peg$silentFails === 0) { peg$fail(peg$c358); }
+                                    }
+                                    if (s1 !== peg$FAILED) {
+                                      peg$savedPos = s0;
+                                      s1 = peg$c350();
+                                    }
+                                    s0 = s1;
+                                    if (s0 === peg$FAILED) {
+                                      s0 = peg$currPos;
+                                      if (input.substr(peg$currPos, 7) === peg$c359) {
+                                        s1 = peg$c359;
+                                        peg$currPos += 7;
+                                      } else {
+                                        s1 = peg$FAILED;
+                                        if (peg$silentFails === 0) { peg$fail(peg$c360); }
+                                      }
+                                      if (s1 !== peg$FAILED) {
+                                        peg$savedPos = s0;
+                                        s1 = peg$c361();
+                                      }
+                                      s0 = s1;
+                                      if (s0 === peg$FAILED) {
+                                        s0 = peg$currPos;
+                                        if (input.substr(peg$currPos, 2) === peg$c362) {
+                                          s1 = peg$c362;
+                                          peg$currPos += 2;
+                                        } else {
+                                          s1 = peg$FAILED;
+                                          if (peg$silentFails === 0) { peg$fail(peg$c363); }
+                                        }
+                                        if (s1 !== peg$FAILED) {
+                                          peg$savedPos = s0;
+                                          s1 = peg$c361();
+                                        }
+                                        s0 = s1;
+                                        if (s0 === peg$FAILED) {
+                                          s0 = peg$currPos;
+                                          if (input.charCodeAt(peg$currPos) === 949) {
+                                            s1 = peg$c364;
+                                            peg$currPos++;
+                                          } else {
+                                            s1 = peg$FAILED;
+                                            if (peg$silentFails === 0) { peg$fail(peg$c365); }
+                                          }
+                                          if (s1 !== peg$FAILED) {
+                                            peg$savedPos = s0;
+                                            s1 = peg$c361();
+                                          }
+                                          s0 = s1;
+                                          if (s0 === peg$FAILED) {
+                                            s0 = peg$currPos;
+                                            if (input.substr(peg$currPos, 2) === peg$c366) {
+                                              s1 = peg$c366;
+                                              peg$currPos += 2;
+                                            } else {
+                                              s1 = peg$FAILED;
+                                              if (peg$silentFails === 0) { peg$fail(peg$c367); }
+                                            }
+                                            if (s1 !== peg$FAILED) {
+                                              peg$savedPos = s0;
+                                              s1 = peg$c368();
+                                            }
+                                            s0 = s1;
+                                            if (s0 === peg$FAILED) {
+                                              s0 = peg$currPos;
+                                              if (input.substr(peg$currPos, 2) === peg$c369) {
+                                                s1 = peg$c369;
+                                                peg$currPos += 2;
+                                              } else {
+                                                s1 = peg$FAILED;
+                                                if (peg$silentFails === 0) { peg$fail(peg$c370); }
+                                              }
+                                              if (s1 !== peg$FAILED) {
+                                                peg$savedPos = s0;
+                                                s1 = peg$c368();
+                                              }
+                                              s0 = s1;
+                                              if (s0 === peg$FAILED) {
+                                                s0 = peg$currPos;
+                                                if (input.charCodeAt(peg$currPos) === 960) {
+                                                  s1 = peg$c371;
+                                                  peg$currPos++;
+                                                } else {
+                                                  s1 = peg$FAILED;
+                                                  if (peg$silentFails === 0) { peg$fail(peg$c372); }
+                                                }
+                                                if (s1 !== peg$FAILED) {
+                                                  peg$savedPos = s0;
+                                                  s1 = peg$c368();
+                                                }
+                                                s0 = s1;
+                                                if (s0 === peg$FAILED) {
+                                                  s0 = peg$currPos;
+                                                  if (input.substr(peg$currPos, 11) === peg$c373) {
+                                                    s1 = peg$c373;
+                                                    peg$currPos += 11;
+                                                  } else {
+                                                    s1 = peg$FAILED;
+                                                    if (peg$silentFails === 0) { peg$fail(peg$c374); }
+                                                  }
+                                                  if (s1 !== peg$FAILED) {
+                                                    peg$savedPos = s0;
+                                                    s1 = peg$c375();
+                                                  }
+                                                  s0 = s1;
+                                                  if (s0 === peg$FAILED) {
+                                                    s0 = peg$currPos;
+                                                    if (input.charCodeAt(peg$currPos) === 69) {
+                                                      s1 = peg$c376;
+                                                      peg$currPos++;
+                                                    } else {
+                                                      s1 = peg$FAILED;
+                                                      if (peg$silentFails === 0) { peg$fail(peg$c377); }
+                                                    }
+                                                    if (s1 !== peg$FAILED) {
+                                                      peg$savedPos = s0;
+                                                      s1 = peg$c375();
+                                                    }
+                                                    s0 = s1;
+                                                    if (s0 === peg$FAILED) {
+                                                      s0 = peg$currPos;
+                                                      if (input.charCodeAt(peg$currPos) === 101) {
+                                                        s1 = peg$c378;
+                                                        peg$currPos++;
+                                                      } else {
+                                                        s1 = peg$FAILED;
+                                                        if (peg$silentFails === 0) { peg$fail(peg$c379); }
+                                                      }
+                                                      if (s1 !== peg$FAILED) {
+                                                        peg$savedPos = s0;
+                                                        s1 = peg$c375();
+                                                      }
+                                                      s0 = s1;
+                                                      if (s0 === peg$FAILED) {
+                                                        s0 = peg$currPos;
+                                                        if (input.charCodeAt(peg$currPos) === 400) {
+                                                          s1 = peg$c380;
+                                                          peg$currPos++;
+                                                        } else {
+                                                          s1 = peg$FAILED;
+                                                          if (peg$silentFails === 0) { peg$fail(peg$c381); }
+                                                        }
+                                                        if (s1 !== peg$FAILED) {
+                                                          peg$savedPos = s0;
+                                                          s1 = peg$c375();
+                                                        }
+                                                        s0 = s1;
+                                                        if (s0 === peg$FAILED) {
+                                                          s0 = peg$currPos;
+                                                          if (input.charCodeAt(peg$currPos) === 8455) {
+                                                            s1 = peg$c382;
+                                                            peg$currPos++;
+                                                          } else {
+                                                            s1 = peg$FAILED;
+                                                            if (peg$silentFails === 0) { peg$fail(peg$c383); }
+                                                          }
+                                                          if (s1 !== peg$FAILED) {
+                                                            peg$savedPos = s0;
+                                                            s1 = peg$c375();
+                                                          }
+                                                          s0 = s1;
+                                                          if (s0 === peg$FAILED) {
+                                                            s0 = peg$currPos;
+                                                            if (input.substr(peg$currPos, 5) === peg$c384) {
+                                                              s1 = peg$c384;
+                                                              peg$currPos += 5;
+                                                            } else {
+                                                              s1 = peg$FAILED;
+                                                              if (peg$silentFails === 0) { peg$fail(peg$c385); }
+                                                            }
+                                                            if (s1 !== peg$FAILED) {
+                                                              peg$savedPos = s0;
+                                                              s1 = peg$c386();
+                                                            }
+                                                            s0 = s1;
+                                                            if (s0 === peg$FAILED) {
+                                                              s0 = peg$currPos;
+                                                              if (input.substr(peg$currPos, 8) === peg$c387) {
+                                                                s1 = peg$c387;
+                                                                peg$currPos += 8;
+                                                              } else {
+                                                                s1 = peg$FAILED;
+                                                                if (peg$silentFails === 0) { peg$fail(peg$c388); }
+                                                              }
+                                                              if (s1 !== peg$FAILED) {
+                                                                peg$savedPos = s0;
+                                                                s1 = peg$c389();
+                                                              }
+                                                              s0 = s1;
+                                                              if (s0 === peg$FAILED) {
+                                                                s0 = peg$currPos;
+                                                                if (input.substr(peg$currPos, 3) === peg$c390) {
+                                                                  s1 = peg$c390;
+                                                                  peg$currPos += 3;
+                                                                } else {
+                                                                  s1 = peg$FAILED;
+                                                                  if (peg$silentFails === 0) { peg$fail(peg$c391); }
+                                                                }
+                                                                if (s1 !== peg$FAILED) {
+                                                                  peg$savedPos = s0;
+                                                                  s1 = peg$c392();
+                                                                }
+                                                                s0 = s1;
+                                                                if (s0 === peg$FAILED) {
+                                                                  s0 = peg$currPos;
+                                                                  if (input.substr(peg$currPos, 7) === peg$c393) {
+                                                                    s1 = peg$c393;
+                                                                    peg$currPos += 7;
+                                                                  } else {
+                                                                    s1 = peg$FAILED;
+                                                                    if (peg$silentFails === 0) { peg$fail(peg$c394); }
+                                                                  }
+                                                                  if (s1 !== peg$FAILED) {
+                                                                    peg$savedPos = s0;
+                                                                    s1 = peg$c392();
+                                                                  }
+                                                                  s0 = s1;
+                                                                  if (s0 === peg$FAILED) {
+                                                                    s0 = peg$currPos;
+                                                                    if (input.substr(peg$currPos, 4) === peg$c395) {
+                                                                      s1 = peg$c395;
+                                                                      peg$currPos += 4;
+                                                                    } else {
+                                                                      s1 = peg$FAILED;
+                                                                      if (peg$silentFails === 0) { peg$fail(peg$c396); }
+                                                                    }
+                                                                    if (s1 !== peg$FAILED) {
+                                                                      peg$savedPos = s0;
+                                                                      s1 = peg$c397();
+                                                                    }
+                                                                    s0 = s1;
+                                                                    if (s0 === peg$FAILED) {
+                                                                      s0 = peg$currPos;
+                                                                      if (input.substr(peg$currPos, 8) === peg$c398) {
+                                                                        s1 = peg$c398;
+                                                                        peg$currPos += 8;
+                                                                      } else {
+                                                                        s1 = peg$FAILED;
+                                                                        if (peg$silentFails === 0) { peg$fail(peg$c399); }
+                                                                      }
+                                                                      if (s1 !== peg$FAILED) {
+                                                                        peg$savedPos = s0;
+                                                                        s1 = peg$c397();
+                                                                      }
+                                                                      s0 = s1;
+                                                                      if (s0 === peg$FAILED) {
+                                                                        s0 = peg$currPos;
+                                                                        if (input.substr(peg$currPos, 5) === peg$c400) {
+                                                                          s1 = peg$c400;
+                                                                          peg$currPos += 5;
+                                                                        } else {
+                                                                          s1 = peg$FAILED;
+                                                                          if (peg$silentFails === 0) { peg$fail(peg$c401); }
+                                                                        }
+                                                                        if (s1 !== peg$FAILED) {
+                                                                          peg$savedPos = s0;
+                                                                          s1 = peg$c402();
+                                                                        }
+                                                                        s0 = s1;
+                                                                        if (s0 === peg$FAILED) {
+                                                                          s0 = peg$currPos;
+                                                                          if (input.substr(peg$currPos, 6) === peg$c403) {
+                                                                            s1 = peg$c403;
+                                                                            peg$currPos += 6;
+                                                                          } else {
+                                                                            s1 = peg$FAILED;
+                                                                            if (peg$silentFails === 0) { peg$fail(peg$c404); }
+                                                                          }
+                                                                          if (s1 !== peg$FAILED) {
+                                                                            peg$savedPos = s0;
+                                                                            s1 = peg$c405();
+                                                                          }
+                                                                          s0 = s1;
+                                                                          if (s0 === peg$FAILED) {
+                                                                            s0 = peg$currPos;
+                                                                            if (input.substr(peg$currPos, 10) === peg$c406) {
+                                                                              s1 = peg$c406;
+                                                                              peg$currPos += 10;
+                                                                            } else {
+                                                                              s1 = peg$FAILED;
+                                                                              if (peg$silentFails === 0) { peg$fail(peg$c407); }
+                                                                            }
+                                                                            if (s1 !== peg$FAILED) {
+                                                                              peg$savedPos = s0;
+                                                                              s1 = peg$c408();
+                                                                            }
+                                                                            s0 = s1;
+                                                                            if (s0 === peg$FAILED) {
+                                                                              s0 = peg$currPos;
+                                                                              if (input.substr(peg$currPos, 10) === peg$c409) {
+                                                                                s1 = peg$c409;
+                                                                                peg$currPos += 10;
+                                                                              } else {
+                                                                                s1 = peg$FAILED;
+                                                                                if (peg$silentFails === 0) { peg$fail(peg$c410); }
+                                                                              }
+                                                                              if (s1 !== peg$FAILED) {
+                                                                                peg$savedPos = s0;
+                                                                                s1 = peg$c411();
+                                                                              }
+                                                                              s0 = s1;
+                                                                              if (s0 === peg$FAILED) {
+                                                                                s0 = peg$currPos;
+                                                                                if (input.substr(peg$currPos, 9) === peg$c412) {
+                                                                                  s1 = peg$c412;
+                                                                                  peg$currPos += 9;
+                                                                                } else {
+                                                                                  s1 = peg$FAILED;
+                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c413); }
+                                                                                }
+                                                                                if (s1 !== peg$FAILED) {
+                                                                                  peg$savedPos = s0;
+                                                                                  s1 = peg$c414();
+                                                                                }
+                                                                                s0 = s1;
+                                                                                if (s0 === peg$FAILED) {
+                                                                                  s0 = peg$currPos;
+                                                                                  if (input.substr(peg$currPos, 9) === peg$c415) {
+                                                                                    s1 = peg$c415;
+                                                                                    peg$currPos += 9;
+                                                                                  } else {
+                                                                                    s1 = peg$FAILED;
+                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c416); }
+                                                                                  }
+                                                                                  if (s1 !== peg$FAILED) {
+                                                                                    peg$savedPos = s0;
+                                                                                    s1 = peg$c417();
+                                                                                  }
+                                                                                  s0 = s1;
+                                                                                  if (s0 === peg$FAILED) {
+                                                                                    s0 = peg$currPos;
+                                                                                    if (input.substr(peg$currPos, 3) === peg$c418) {
+                                                                                      s1 = peg$c418;
+                                                                                      peg$currPos += 3;
+                                                                                    } else {
+                                                                                      s1 = peg$FAILED;
+                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c419); }
+                                                                                    }
+                                                                                    if (s1 !== peg$FAILED) {
+                                                                                      peg$savedPos = s0;
+                                                                                      s1 = peg$c420();
+                                                                                    }
+                                                                                    s0 = s1;
+                                                                                    if (s0 === peg$FAILED) {
+                                                                                      s0 = peg$currPos;
+                                                                                      if (input.substr(peg$currPos, 2) === peg$c421) {
+                                                                                        s1 = peg$c421;
+                                                                                        peg$currPos += 2;
+                                                                                      } else {
+                                                                                        s1 = peg$FAILED;
+                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c422); }
+                                                                                      }
+                                                                                      if (s1 !== peg$FAILED) {
+                                                                                        peg$savedPos = s0;
+                                                                                        s1 = peg$c420();
+                                                                                      }
+                                                                                      s0 = s1;
+                                                                                      if (s0 === peg$FAILED) {
+                                                                                        s0 = peg$currPos;
+                                                                                        if (input.substr(peg$currPos, 2) === peg$c423) {
+                                                                                          s1 = peg$c423;
+                                                                                          peg$currPos += 2;
+                                                                                        } else {
+                                                                                          s1 = peg$FAILED;
+                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c424); }
+                                                                                        }
+                                                                                        if (s1 !== peg$FAILED) {
+                                                                                          peg$savedPos = s0;
+                                                                                          s1 = peg$c420();
+                                                                                        }
+                                                                                        s0 = s1;
+                                                                                        if (s0 === peg$FAILED) {
+                                                                                          s0 = peg$currPos;
+                                                                                          if (input.charCodeAt(peg$currPos) === 981) {
+                                                                                            s1 = peg$c425;
+                                                                                            peg$currPos++;
+                                                                                          } else {
+                                                                                            s1 = peg$FAILED;
+                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c426); }
+                                                                                          }
+                                                                                          if (s1 !== peg$FAILED) {
+                                                                                            peg$savedPos = s0;
+                                                                                            s1 = peg$c420();
+                                                                                          }
+                                                                                          s0 = s1;
+                                                                                          if (s0 === peg$FAILED) {
+                                                                                            s0 = peg$currPos;
+                                                                                            if (input.charCodeAt(peg$currPos) === 966) {
+                                                                                              s1 = peg$c427;
+                                                                                              peg$currPos++;
+                                                                                            } else {
+                                                                                              s1 = peg$FAILED;
+                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c428); }
+                                                                                            }
+                                                                                            if (s1 !== peg$FAILED) {
+                                                                                              peg$savedPos = s0;
+                                                                                              s1 = peg$c420();
+                                                                                            }
+                                                                                            s0 = s1;
+                                                                                            if (s0 === peg$FAILED) {
+                                                                                              s0 = peg$currPos;
+                                                                                              if (input.substr(peg$currPos, 13) === peg$c429) {
+                                                                                                s1 = peg$c429;
+                                                                                                peg$currPos += 13;
+                                                                                              } else {
+                                                                                                s1 = peg$FAILED;
+                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c430); }
+                                                                                              }
+                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                peg$savedPos = s0;
+                                                                                                s1 = peg$c431();
+                                                                                              }
+                                                                                              s0 = s1;
+                                                                                              if (s0 === peg$FAILED) {
+                                                                                                s0 = peg$currPos;
+                                                                                                if (input.charCodeAt(peg$currPos) === 947) {
+                                                                                                  s1 = peg$c432;
+                                                                                                  peg$currPos++;
+                                                                                                } else {
+                                                                                                  s1 = peg$FAILED;
+                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c433); }
+                                                                                                }
+                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                  peg$savedPos = s0;
+                                                                                                  s1 = peg$c431();
+                                                                                                }
+                                                                                                s0 = s1;
+                                                                                                if (s0 === peg$FAILED) {
+                                                                                                  s0 = peg$currPos;
+                                                                                                  if (input.substr(peg$currPos, 2) === peg$c434) {
+                                                                                                    s1 = peg$c434;
+                                                                                                    peg$currPos += 2;
+                                                                                                  } else {
+                                                                                                    s1 = peg$FAILED;
+                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c435); }
+                                                                                                  }
+                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                    peg$savedPos = s0;
+                                                                                                    s1 = peg$c431();
+                                                                                                  }
+                                                                                                  s0 = s1;
+                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                    s0 = peg$currPos;
+                                                                                                    if (input.charCodeAt(peg$currPos) === 947) {
+                                                                                                      s1 = peg$c432;
+                                                                                                      peg$currPos++;
+                                                                                                    } else {
+                                                                                                      s1 = peg$FAILED;
+                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c433); }
+                                                                                                    }
+                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                      peg$savedPos = s0;
+                                                                                                      s1 = peg$c431();
+                                                                                                    }
+                                                                                                    s0 = s1;
+                                                                                                  }
+                                                                                                }
+                                                                                              }
+                                                                                            }
+                                                                                          }
+                                                                                        }
+                                                                                      }
+                                                                                    }
+                                                                                  }
+                                                                                }
+                                                                              }
+                                                                            }
+                                                                          }
+                                                                        }
+                                                                      }
+                                                                    }
+                                                                  }
+                                                                }
+                                                              }
+                                                            }
+                                                          }
+                                                        }
+                                                      }
+                                                    }
+                                                  }
+                                                }
+                                              }
+                                            }
+                                          }
+                                        }
+                                      }
+                                    }
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c328); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseJsDecimalLiteral() {
+    var s0, s1, s2, s3, s4;
+
+    s0 = peg$currPos;
+    s1 = peg$parseJsDecimalIntegerLiteral();
+    if (s1 !== peg$FAILED) {
+      if (input.charCodeAt(peg$currPos) === 46) {
+        s2 = peg$c325;
+        peg$currPos++;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c326); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = [];
+        s4 = peg$parseDecimalDigit();
+        while (s4 !== peg$FAILED) {
+          s3.push(s4);
+          s4 = peg$parseDecimalDigit();
+        }
+        if (s3 !== peg$FAILED) {
+          s4 = peg$parseJsNExponentPart();
+          if (s4 === peg$FAILED) {
+            s4 = null;
+          }
+          if (s4 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s1 = peg$c327();
+            s0 = s1;
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 46) {
+        s1 = peg$c325;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c326); }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = [];
+        s3 = peg$parseDecimalDigit();
+        if (s3 !== peg$FAILED) {
+          while (s3 !== peg$FAILED) {
+            s2.push(s3);
+            s3 = peg$parseDecimalDigit();
+          }
+        } else {
+          s2 = peg$FAILED;
+        }
+        if (s2 !== peg$FAILED) {
+          s3 = peg$parseJsNExponentPart();
+          if (s3 === peg$FAILED) {
+            s3 = null;
+          }
+          if (s3 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s1 = peg$c327();
+            s0 = s1;
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        s1 = peg$parseJsDecimalIntegerLiteral();
+        if (s1 !== peg$FAILED) {
+          s2 = peg$parseJsNExponentPart();
+          if (s2 === peg$FAILED) {
+            s2 = null;
+          }
+          if (s2 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s1 = peg$c327();
+            s0 = s1;
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseJsDecimalIntegerLiteral() {
+    var s0, s1, s2, s3;
+
+    if (input.charCodeAt(peg$currPos) === 48) {
+      s0 = peg$c314;
+      peg$currPos++;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c315); }
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = peg$parseNonZeroDigit();
+      if (s1 !== peg$FAILED) {
+        s2 = [];
+        s3 = peg$parseDecimalDigit();
+        while (s3 !== peg$FAILED) {
+          s2.push(s3);
+          s3 = peg$parseDecimalDigit();
+        }
+        if (s2 !== peg$FAILED) {
+          s1 = [s1, s2];
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseJsNExponentPart() {
+    var s0, s1, s2;
+
+    s0 = peg$currPos;
+    s1 = peg$parseJsNExponentIndicator();
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseJsNSignedInteger();
+      if (s2 !== peg$FAILED) {
+        s1 = [s1, s2];
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseJsNExponentIndicator() {
+    var s0;
+
+    if (input.substr(peg$currPos, 1).toLowerCase() === peg$c378) {
+      s0 = input.charAt(peg$currPos);
+      peg$currPos++;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c436); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseJsNSignedInteger() {
+    var s0, s1, s2, s3;
+
+    s0 = peg$currPos;
+    if (peg$c437.test(input.charAt(peg$currPos))) {
+      s1 = input.charAt(peg$currPos);
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c438); }
+    }
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$parseDecimalDigit();
+      if (s3 !== peg$FAILED) {
+        while (s3 !== peg$FAILED) {
+          s2.push(s3);
+          s3 = peg$parseDecimalDigit();
+        }
+      } else {
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        s1 = [s1, s2];
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseJsHexIntegerLiteral() {
+    var s0, s1, s2, s3, s4;
+
+    s0 = peg$currPos;
+    if (input.substr(peg$currPos, 2).toLowerCase() === peg$c439) {
+      s1 = input.substr(peg$currPos, 2);
+      peg$currPos += 2;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c440); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      s3 = [];
+      s4 = peg$parseHexDigit();
+      if (s4 !== peg$FAILED) {
+        while (s4 !== peg$FAILED) {
+          s3.push(s4);
+          s4 = peg$parseHexDigit();
+        }
+      } else {
+        s3 = peg$FAILED;
+      }
+      if (s3 !== peg$FAILED) {
+        s2 = input.substring(s2, peg$currPos);
+      } else {
+        s2 = s3;
+      }
+      if (s2 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c441(s2);
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseJsBinaryIntegerLiteral() {
+    var s0, s1, s2, s3, s4;
+
+    s0 = peg$currPos;
+    if (input.substr(peg$currPos, 2).toLowerCase() === peg$c442) {
+      s1 = input.substr(peg$currPos, 2);
+      peg$currPos += 2;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c443); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      s3 = [];
+      s4 = peg$parseBinaryDigit();
+      if (s4 !== peg$FAILED) {
+        while (s4 !== peg$FAILED) {
+          s3.push(s4);
+          s4 = peg$parseBinaryDigit();
+        }
+      } else {
+        s3 = peg$FAILED;
+      }
+      if (s3 !== peg$FAILED) {
+        s2 = input.substring(s2, peg$currPos);
+      } else {
+        s2 = s3;
+      }
+      if (s2 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c444(s2);
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseNonJsOctalIntegerLiteral() {
+    var s0, s1, s2, s3, s4;
+
+    s0 = peg$currPos;
+    if (input.substr(peg$currPos, 2).toLowerCase() === peg$c445) {
+      s1 = input.substr(peg$currPos, 2);
+      peg$currPos += 2;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c446); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      s3 = [];
+      s4 = peg$parseOctalDigit();
+      if (s4 !== peg$FAILED) {
+        while (s4 !== peg$FAILED) {
+          s3.push(s4);
+          s4 = peg$parseOctalDigit();
+        }
+      } else {
+        s3 = peg$FAILED;
+      }
+      if (s3 !== peg$FAILED) {
+        s2 = input.substring(s2, peg$currPos);
+      } else {
+        s2 = s3;
+      }
+      if (s2 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c447(s2);
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseSemVer() {
+    var s0, s1, s2, s3, s4, s5;
+
+    s0 = peg$currPos;
+    s1 = peg$parseIntegerLiteral();
+    if (s1 !== peg$FAILED) {
+      if (input.charCodeAt(peg$currPos) === 46) {
+        s2 = peg$c325;
+        peg$currPos++;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c326); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseIntegerLiteral();
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 46) {
+            s4 = peg$c325;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c326); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseIntegerLiteral();
+            if (s5 !== peg$FAILED) {
+              peg$savedPos = s0;
+              s1 = peg$c448(s1, s3, s5);
+              s0 = s1;
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseSemVerOper() {
+    var s0;
+
+    if (input.charCodeAt(peg$currPos) === 94) {
+      s0 = peg$c449;
+      peg$currPos++;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c450); }
+    }
+    if (s0 === peg$FAILED) {
+      if (input.charCodeAt(peg$currPos) === 126) {
+        s0 = peg$c451;
+        peg$currPos++;
+      } else {
+        s0 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c452); }
+      }
+      if (s0 === peg$FAILED) {
+        if (input.substr(peg$currPos, 2) === peg$c453) {
+          s0 = peg$c453;
+          peg$currPos += 2;
+        } else {
+          s0 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$c454); }
+        }
+        if (s0 === peg$FAILED) {
+          if (input.substr(peg$currPos, 2) === peg$c166) {
+            s0 = peg$c166;
+            peg$currPos += 2;
+          } else {
+            s0 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c167); }
+          }
+          if (s0 === peg$FAILED) {
+            if (input.charCodeAt(peg$currPos) === 60) {
+              s0 = peg$c455;
+              peg$currPos++;
+            } else {
+              s0 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$c456); }
+            }
+            if (s0 === peg$FAILED) {
+              if (input.charCodeAt(peg$currPos) === 62) {
+                s0 = peg$c457;
+                peg$currPos++;
+              } else {
+                s0 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$c458); }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseSemVerRule() {
+    var s0, s1, s2;
+
+    s0 = peg$currPos;
+    s1 = peg$parseSemVerOper();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseSemVer();
+      if (s2 !== peg$FAILED) {
+        s1 = [s1, s2];
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseSemVerRange() {
+    var s0, s1, s2;
+
+    s0 = peg$currPos;
+    s1 = peg$parseSemVerRule();
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseSemVerRule();
+      if (s2 === peg$FAILED) {
+        s2 = null;
+      }
+      if (s2 !== peg$FAILED) {
+        s1 = [s1, s2];
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseUrlProtocol() {
+    var s0;
+
+    if (input.substr(peg$currPos, 7) === peg$c459) {
+      s0 = peg$c459;
+      peg$currPos += 7;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c460); }
+    }
+    if (s0 === peg$FAILED) {
+      if (input.substr(peg$currPos, 8) === peg$c461) {
+        s0 = peg$c461;
+        peg$currPos += 8;
+      } else {
+        s0 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c462); }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseURL() {
+    var s0, s1, s2, s3;
+
+    s0 = peg$currPos;
+    s1 = peg$parseUrlProtocol();
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      if (peg$c463.test(input.charAt(peg$currPos))) {
+        s3 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c464); }
+      }
+      if (s3 !== peg$FAILED) {
+        while (s3 !== peg$FAILED) {
+          s2.push(s3);
+          if (peg$c463.test(input.charAt(peg$currPos))) {
+            s3 = input.charAt(peg$currPos);
+            peg$currPos++;
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c464); }
+          }
+        }
+      } else {
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c465(s1);
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseSvgColorLabel() {
+    var s0, s1;
+
+    s0 = peg$currPos;
+    if (input.substr(peg$currPos, 9) === peg$c466) {
+      s1 = peg$c466;
+      peg$currPos += 9;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c467); }
+    }
+    if (s1 !== peg$FAILED) {
+      peg$savedPos = s0;
+      s1 = peg$c468();
+    }
+    s0 = s1;
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 9) === peg$c469) {
+        s1 = peg$c469;
+        peg$currPos += 9;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c470); }
+      }
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c468();
+      }
+      s0 = s1;
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        if (input.substr(peg$currPos, 12) === peg$c471) {
+          s1 = peg$c471;
+          peg$currPos += 12;
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$c472); }
+        }
+        if (s1 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s1 = peg$c473();
+        }
+        s0 = s1;
+        if (s0 === peg$FAILED) {
+          s0 = peg$currPos;
+          if (input.substr(peg$currPos, 12) === peg$c474) {
+            s1 = peg$c474;
+            peg$currPos += 12;
+          } else {
+            s1 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c475); }
+          }
+          if (s1 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s1 = peg$c473();
+          }
+          s0 = s1;
+          if (s0 === peg$FAILED) {
+            s0 = peg$currPos;
+            if (input.substr(peg$currPos, 10) === peg$c476) {
+              s1 = peg$c476;
+              peg$currPos += 10;
+            } else {
+              s1 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$c477); }
+            }
+            if (s1 !== peg$FAILED) {
+              peg$savedPos = s0;
+              s1 = peg$c478();
+            }
+            s0 = s1;
+            if (s0 === peg$FAILED) {
+              s0 = peg$currPos;
+              if (input.substr(peg$currPos, 10) === peg$c479) {
+                s1 = peg$c479;
+                peg$currPos += 10;
+              } else {
+                s1 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$c480); }
+              }
+              if (s1 !== peg$FAILED) {
+                peg$savedPos = s0;
+                s1 = peg$c478();
+              }
+              s0 = s1;
+              if (s0 === peg$FAILED) {
+                s0 = peg$currPos;
+                if (input.substr(peg$currPos, 4) === peg$c481) {
+                  s1 = peg$c481;
+                  peg$currPos += 4;
+                } else {
+                  s1 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$c482); }
+                }
+                if (s1 !== peg$FAILED) {
+                  peg$savedPos = s0;
+                  s1 = peg$c483();
+                }
+                s0 = s1;
+                if (s0 === peg$FAILED) {
+                  s0 = peg$currPos;
+                  if (input.substr(peg$currPos, 4) === peg$c484) {
+                    s1 = peg$c484;
+                    peg$currPos += 4;
+                  } else {
+                    s1 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c485); }
+                  }
+                  if (s1 !== peg$FAILED) {
+                    peg$savedPos = s0;
+                    s1 = peg$c483();
+                  }
+                  s0 = s1;
+                  if (s0 === peg$FAILED) {
+                    s0 = peg$currPos;
+                    if (input.substr(peg$currPos, 5) === peg$c486) {
+                      s1 = peg$c486;
+                      peg$currPos += 5;
+                    } else {
+                      s1 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$c487); }
+                    }
+                    if (s1 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c488();
+                    }
+                    s0 = s1;
+                    if (s0 === peg$FAILED) {
+                      s0 = peg$currPos;
+                      if (input.substr(peg$currPos, 5) === peg$c489) {
+                        s1 = peg$c489;
+                        peg$currPos += 5;
+                      } else {
+                        s1 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$c490); }
+                      }
+                      if (s1 !== peg$FAILED) {
+                        peg$savedPos = s0;
+                        s1 = peg$c488();
+                      }
+                      s0 = s1;
+                      if (s0 === peg$FAILED) {
+                        s0 = peg$currPos;
+                        if (input.substr(peg$currPos, 5) === peg$c491) {
+                          s1 = peg$c491;
+                          peg$currPos += 5;
+                        } else {
+                          s1 = peg$FAILED;
+                          if (peg$silentFails === 0) { peg$fail(peg$c492); }
+                        }
+                        if (s1 !== peg$FAILED) {
+                          peg$savedPos = s0;
+                          s1 = peg$c493();
+                        }
+                        s0 = s1;
+                        if (s0 === peg$FAILED) {
+                          s0 = peg$currPos;
+                          if (input.substr(peg$currPos, 5) === peg$c494) {
+                            s1 = peg$c494;
+                            peg$currPos += 5;
+                          } else {
+                            s1 = peg$FAILED;
+                            if (peg$silentFails === 0) { peg$fail(peg$c495); }
+                          }
+                          if (s1 !== peg$FAILED) {
+                            peg$savedPos = s0;
+                            s1 = peg$c493();
+                          }
+                          s0 = s1;
+                          if (s0 === peg$FAILED) {
+                            s0 = peg$currPos;
+                            if (input.substr(peg$currPos, 6) === peg$c496) {
+                              s1 = peg$c496;
+                              peg$currPos += 6;
+                            } else {
+                              s1 = peg$FAILED;
+                              if (peg$silentFails === 0) { peg$fail(peg$c497); }
+                            }
+                            if (s1 !== peg$FAILED) {
+                              peg$savedPos = s0;
+                              s1 = peg$c498();
+                            }
+                            s0 = s1;
+                            if (s0 === peg$FAILED) {
+                              s0 = peg$currPos;
+                              if (input.substr(peg$currPos, 6) === peg$c499) {
+                                s1 = peg$c499;
+                                peg$currPos += 6;
+                              } else {
+                                s1 = peg$FAILED;
+                                if (peg$silentFails === 0) { peg$fail(peg$c500); }
+                              }
+                              if (s1 !== peg$FAILED) {
+                                peg$savedPos = s0;
+                                s1 = peg$c498();
+                              }
+                              s0 = s1;
+                              if (s0 === peg$FAILED) {
+                                s0 = peg$currPos;
+                                if (input.substr(peg$currPos, 5) === peg$c501) {
+                                  s1 = peg$c501;
+                                  peg$currPos += 5;
+                                } else {
+                                  s1 = peg$FAILED;
+                                  if (peg$silentFails === 0) { peg$fail(peg$c502); }
+                                }
+                                if (s1 !== peg$FAILED) {
+                                  peg$savedPos = s0;
+                                  s1 = peg$c503();
+                                }
+                                s0 = s1;
+                                if (s0 === peg$FAILED) {
+                                  s0 = peg$currPos;
+                                  if (input.substr(peg$currPos, 5) === peg$c504) {
+                                    s1 = peg$c504;
+                                    peg$currPos += 5;
+                                  } else {
+                                    s1 = peg$FAILED;
+                                    if (peg$silentFails === 0) { peg$fail(peg$c505); }
+                                  }
+                                  if (s1 !== peg$FAILED) {
+                                    peg$savedPos = s0;
+                                    s1 = peg$c503();
+                                  }
+                                  s0 = s1;
+                                  if (s0 === peg$FAILED) {
+                                    s0 = peg$currPos;
+                                    if (input.substr(peg$currPos, 14) === peg$c506) {
+                                      s1 = peg$c506;
+                                      peg$currPos += 14;
+                                    } else {
+                                      s1 = peg$FAILED;
+                                      if (peg$silentFails === 0) { peg$fail(peg$c507); }
+                                    }
+                                    if (s1 !== peg$FAILED) {
+                                      peg$savedPos = s0;
+                                      s1 = peg$c508();
+                                    }
+                                    s0 = s1;
+                                    if (s0 === peg$FAILED) {
+                                      s0 = peg$currPos;
+                                      if (input.substr(peg$currPos, 14) === peg$c509) {
+                                        s1 = peg$c509;
+                                        peg$currPos += 14;
+                                      } else {
+                                        s1 = peg$FAILED;
+                                        if (peg$silentFails === 0) { peg$fail(peg$c510); }
+                                      }
+                                      if (s1 !== peg$FAILED) {
+                                        peg$savedPos = s0;
+                                        s1 = peg$c508();
+                                      }
+                                      s0 = s1;
+                                      if (s0 === peg$FAILED) {
+                                        s0 = peg$currPos;
+                                        if (input.substr(peg$currPos, 10) === peg$c511) {
+                                          s1 = peg$c511;
+                                          peg$currPos += 10;
+                                        } else {
+                                          s1 = peg$FAILED;
+                                          if (peg$silentFails === 0) { peg$fail(peg$c512); }
+                                        }
+                                        if (s1 !== peg$FAILED) {
+                                          peg$savedPos = s0;
+                                          s1 = peg$c513();
+                                        }
+                                        s0 = s1;
+                                        if (s0 === peg$FAILED) {
+                                          s0 = peg$currPos;
+                                          if (input.substr(peg$currPos, 10) === peg$c514) {
+                                            s1 = peg$c514;
+                                            peg$currPos += 10;
+                                          } else {
+                                            s1 = peg$FAILED;
+                                            if (peg$silentFails === 0) { peg$fail(peg$c515); }
+                                          }
+                                          if (s1 !== peg$FAILED) {
+                                            peg$savedPos = s0;
+                                            s1 = peg$c513();
+                                          }
+                                          s0 = s1;
+                                          if (s0 === peg$FAILED) {
+                                            s0 = peg$currPos;
+                                            if (input.substr(peg$currPos, 4) === peg$c516) {
+                                              s1 = peg$c516;
+                                              peg$currPos += 4;
+                                            } else {
+                                              s1 = peg$FAILED;
+                                              if (peg$silentFails === 0) { peg$fail(peg$c517); }
+                                            }
+                                            if (s1 !== peg$FAILED) {
+                                              peg$savedPos = s0;
+                                              s1 = peg$c518();
+                                            }
+                                            s0 = s1;
+                                            if (s0 === peg$FAILED) {
+                                              s0 = peg$currPos;
+                                              if (input.substr(peg$currPos, 4) === peg$c519) {
+                                                s1 = peg$c519;
+                                                peg$currPos += 4;
+                                              } else {
+                                                s1 = peg$FAILED;
+                                                if (peg$silentFails === 0) { peg$fail(peg$c520); }
+                                              }
+                                              if (s1 !== peg$FAILED) {
+                                                peg$savedPos = s0;
+                                                s1 = peg$c518();
+                                              }
+                                              s0 = s1;
+                                              if (s0 === peg$FAILED) {
+                                                s0 = peg$currPos;
+                                                if (input.substr(peg$currPos, 5) === peg$c521) {
+                                                  s1 = peg$c521;
+                                                  peg$currPos += 5;
+                                                } else {
+                                                  s1 = peg$FAILED;
+                                                  if (peg$silentFails === 0) { peg$fail(peg$c522); }
+                                                }
+                                                if (s1 !== peg$FAILED) {
+                                                  peg$savedPos = s0;
+                                                  s1 = peg$c523();
+                                                }
+                                                s0 = s1;
+                                                if (s0 === peg$FAILED) {
+                                                  s0 = peg$currPos;
+                                                  if (input.substr(peg$currPos, 5) === peg$c524) {
+                                                    s1 = peg$c524;
+                                                    peg$currPos += 5;
+                                                  } else {
+                                                    s1 = peg$FAILED;
+                                                    if (peg$silentFails === 0) { peg$fail(peg$c525); }
+                                                  }
+                                                  if (s1 !== peg$FAILED) {
+                                                    peg$savedPos = s0;
+                                                    s1 = peg$c523();
+                                                  }
+                                                  s0 = s1;
+                                                  if (s0 === peg$FAILED) {
+                                                    s0 = peg$currPos;
+                                                    if (input.substr(peg$currPos, 9) === peg$c526) {
+                                                      s1 = peg$c526;
+                                                      peg$currPos += 9;
+                                                    } else {
+                                                      s1 = peg$FAILED;
+                                                      if (peg$silentFails === 0) { peg$fail(peg$c527); }
+                                                    }
+                                                    if (s1 !== peg$FAILED) {
+                                                      peg$savedPos = s0;
+                                                      s1 = peg$c528();
+                                                    }
+                                                    s0 = s1;
+                                                    if (s0 === peg$FAILED) {
+                                                      s0 = peg$currPos;
+                                                      if (input.substr(peg$currPos, 9) === peg$c529) {
+                                                        s1 = peg$c529;
+                                                        peg$currPos += 9;
+                                                      } else {
+                                                        s1 = peg$FAILED;
+                                                        if (peg$silentFails === 0) { peg$fail(peg$c530); }
+                                                      }
+                                                      if (s1 !== peg$FAILED) {
+                                                        peg$savedPos = s0;
+                                                        s1 = peg$c528();
+                                                      }
+                                                      s0 = s1;
+                                                      if (s0 === peg$FAILED) {
+                                                        s0 = peg$currPos;
+                                                        if (input.substr(peg$currPos, 9) === peg$c531) {
+                                                          s1 = peg$c531;
+                                                          peg$currPos += 9;
+                                                        } else {
+                                                          s1 = peg$FAILED;
+                                                          if (peg$silentFails === 0) { peg$fail(peg$c532); }
+                                                        }
+                                                        if (s1 !== peg$FAILED) {
+                                                          peg$savedPos = s0;
+                                                          s1 = peg$c533();
+                                                        }
+                                                        s0 = s1;
+                                                        if (s0 === peg$FAILED) {
+                                                          s0 = peg$currPos;
+                                                          if (input.substr(peg$currPos, 9) === peg$c534) {
+                                                            s1 = peg$c534;
+                                                            peg$currPos += 9;
+                                                          } else {
+                                                            s1 = peg$FAILED;
+                                                            if (peg$silentFails === 0) { peg$fail(peg$c535); }
+                                                          }
+                                                          if (s1 !== peg$FAILED) {
+                                                            peg$savedPos = s0;
+                                                            s1 = peg$c533();
+                                                          }
+                                                          s0 = s1;
+                                                          if (s0 === peg$FAILED) {
+                                                            s0 = peg$currPos;
+                                                            if (input.substr(peg$currPos, 10) === peg$c536) {
+                                                              s1 = peg$c536;
+                                                              peg$currPos += 10;
+                                                            } else {
+                                                              s1 = peg$FAILED;
+                                                              if (peg$silentFails === 0) { peg$fail(peg$c537); }
+                                                            }
+                                                            if (s1 !== peg$FAILED) {
+                                                              peg$savedPos = s0;
+                                                              s1 = peg$c538();
+                                                            }
+                                                            s0 = s1;
+                                                            if (s0 === peg$FAILED) {
+                                                              s0 = peg$currPos;
+                                                              if (input.substr(peg$currPos, 10) === peg$c539) {
+                                                                s1 = peg$c539;
+                                                                peg$currPos += 10;
+                                                              } else {
+                                                                s1 = peg$FAILED;
+                                                                if (peg$silentFails === 0) { peg$fail(peg$c540); }
+                                                              }
+                                                              if (s1 !== peg$FAILED) {
+                                                                peg$savedPos = s0;
+                                                                s1 = peg$c538();
+                                                              }
+                                                              s0 = s1;
+                                                              if (s0 === peg$FAILED) {
+                                                                s0 = peg$currPos;
+                                                                if (input.substr(peg$currPos, 9) === peg$c541) {
+                                                                  s1 = peg$c541;
+                                                                  peg$currPos += 9;
+                                                                } else {
+                                                                  s1 = peg$FAILED;
+                                                                  if (peg$silentFails === 0) { peg$fail(peg$c542); }
+                                                                }
+                                                                if (s1 !== peg$FAILED) {
+                                                                  peg$savedPos = s0;
+                                                                  s1 = peg$c543();
+                                                                }
+                                                                s0 = s1;
+                                                                if (s0 === peg$FAILED) {
+                                                                  s0 = peg$currPos;
+                                                                  if (input.substr(peg$currPos, 9) === peg$c544) {
+                                                                    s1 = peg$c544;
+                                                                    peg$currPos += 9;
+                                                                  } else {
+                                                                    s1 = peg$FAILED;
+                                                                    if (peg$silentFails === 0) { peg$fail(peg$c545); }
+                                                                  }
+                                                                  if (s1 !== peg$FAILED) {
+                                                                    peg$savedPos = s0;
+                                                                    s1 = peg$c543();
+                                                                  }
+                                                                  s0 = s1;
+                                                                  if (s0 === peg$FAILED) {
+                                                                    s0 = peg$currPos;
+                                                                    if (input.substr(peg$currPos, 5) === peg$c546) {
+                                                                      s1 = peg$c546;
+                                                                      peg$currPos += 5;
+                                                                    } else {
+                                                                      s1 = peg$FAILED;
+                                                                      if (peg$silentFails === 0) { peg$fail(peg$c547); }
+                                                                    }
+                                                                    if (s1 !== peg$FAILED) {
+                                                                      peg$savedPos = s0;
+                                                                      s1 = peg$c548();
+                                                                    }
+                                                                    s0 = s1;
+                                                                    if (s0 === peg$FAILED) {
+                                                                      s0 = peg$currPos;
+                                                                      if (input.substr(peg$currPos, 5) === peg$c549) {
+                                                                        s1 = peg$c549;
+                                                                        peg$currPos += 5;
+                                                                      } else {
+                                                                        s1 = peg$FAILED;
+                                                                        if (peg$silentFails === 0) { peg$fail(peg$c550); }
+                                                                      }
+                                                                      if (s1 !== peg$FAILED) {
+                                                                        peg$savedPos = s0;
+                                                                        s1 = peg$c548();
+                                                                      }
+                                                                      s0 = s1;
+                                                                      if (s0 === peg$FAILED) {
+                                                                        s0 = peg$currPos;
+                                                                        if (input.substr(peg$currPos, 14) === peg$c551) {
+                                                                          s1 = peg$c551;
+                                                                          peg$currPos += 14;
+                                                                        } else {
+                                                                          s1 = peg$FAILED;
+                                                                          if (peg$silentFails === 0) { peg$fail(peg$c552); }
+                                                                        }
+                                                                        if (s1 !== peg$FAILED) {
+                                                                          peg$savedPos = s0;
+                                                                          s1 = peg$c553();
+                                                                        }
+                                                                        s0 = s1;
+                                                                        if (s0 === peg$FAILED) {
+                                                                          s0 = peg$currPos;
+                                                                          if (input.substr(peg$currPos, 14) === peg$c554) {
+                                                                            s1 = peg$c554;
+                                                                            peg$currPos += 14;
+                                                                          } else {
+                                                                            s1 = peg$FAILED;
+                                                                            if (peg$silentFails === 0) { peg$fail(peg$c555); }
+                                                                          }
+                                                                          if (s1 !== peg$FAILED) {
+                                                                            peg$savedPos = s0;
+                                                                            s1 = peg$c553();
+                                                                          }
+                                                                          s0 = s1;
+                                                                          if (s0 === peg$FAILED) {
+                                                                            s0 = peg$currPos;
+                                                                            if (input.substr(peg$currPos, 8) === peg$c556) {
+                                                                              s1 = peg$c556;
+                                                                              peg$currPos += 8;
+                                                                            } else {
+                                                                              s1 = peg$FAILED;
+                                                                              if (peg$silentFails === 0) { peg$fail(peg$c557); }
+                                                                            }
+                                                                            if (s1 !== peg$FAILED) {
+                                                                              peg$savedPos = s0;
+                                                                              s1 = peg$c558();
+                                                                            }
+                                                                            s0 = s1;
+                                                                            if (s0 === peg$FAILED) {
+                                                                              s0 = peg$currPos;
+                                                                              if (input.substr(peg$currPos, 8) === peg$c559) {
+                                                                                s1 = peg$c559;
+                                                                                peg$currPos += 8;
+                                                                              } else {
+                                                                                s1 = peg$FAILED;
+                                                                                if (peg$silentFails === 0) { peg$fail(peg$c560); }
+                                                                              }
+                                                                              if (s1 !== peg$FAILED) {
+                                                                                peg$savedPos = s0;
+                                                                                s1 = peg$c558();
+                                                                              }
+                                                                              s0 = s1;
+                                                                              if (s0 === peg$FAILED) {
+                                                                                s0 = peg$currPos;
+                                                                                if (input.substr(peg$currPos, 7) === peg$c561) {
+                                                                                  s1 = peg$c561;
+                                                                                  peg$currPos += 7;
+                                                                                } else {
+                                                                                  s1 = peg$FAILED;
+                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c562); }
+                                                                                }
+                                                                                if (s1 !== peg$FAILED) {
+                                                                                  peg$savedPos = s0;
+                                                                                  s1 = peg$c563();
+                                                                                }
+                                                                                s0 = s1;
+                                                                                if (s0 === peg$FAILED) {
+                                                                                  s0 = peg$currPos;
+                                                                                  if (input.substr(peg$currPos, 7) === peg$c564) {
+                                                                                    s1 = peg$c564;
+                                                                                    peg$currPos += 7;
+                                                                                  } else {
+                                                                                    s1 = peg$FAILED;
+                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c565); }
+                                                                                  }
+                                                                                  if (s1 !== peg$FAILED) {
+                                                                                    peg$savedPos = s0;
+                                                                                    s1 = peg$c563();
+                                                                                  }
+                                                                                  s0 = s1;
+                                                                                  if (s0 === peg$FAILED) {
+                                                                                    s0 = peg$currPos;
+                                                                                    if (input.substr(peg$currPos, 4) === peg$c566) {
+                                                                                      s1 = peg$c566;
+                                                                                      peg$currPos += 4;
+                                                                                    } else {
+                                                                                      s1 = peg$FAILED;
+                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c567); }
+                                                                                    }
+                                                                                    if (s1 !== peg$FAILED) {
+                                                                                      peg$savedPos = s0;
+                                                                                      s1 = peg$c483();
+                                                                                    }
+                                                                                    s0 = s1;
+                                                                                    if (s0 === peg$FAILED) {
+                                                                                      s0 = peg$currPos;
+                                                                                      if (input.substr(peg$currPos, 4) === peg$c568) {
+                                                                                        s1 = peg$c568;
+                                                                                        peg$currPos += 4;
+                                                                                      } else {
+                                                                                        s1 = peg$FAILED;
+                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c569); }
+                                                                                      }
+                                                                                      if (s1 !== peg$FAILED) {
+                                                                                        peg$savedPos = s0;
+                                                                                        s1 = peg$c483();
+                                                                                      }
+                                                                                      s0 = s1;
+                                                                                      if (s0 === peg$FAILED) {
+                                                                                        s0 = peg$currPos;
+                                                                                        if (input.substr(peg$currPos, 8) === peg$c570) {
+                                                                                          s1 = peg$c570;
+                                                                                          peg$currPos += 8;
+                                                                                        } else {
+                                                                                          s1 = peg$FAILED;
+                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c571); }
+                                                                                        }
+                                                                                        if (s1 !== peg$FAILED) {
+                                                                                          peg$savedPos = s0;
+                                                                                          s1 = peg$c572();
+                                                                                        }
+                                                                                        s0 = s1;
+                                                                                        if (s0 === peg$FAILED) {
+                                                                                          s0 = peg$currPos;
+                                                                                          if (input.substr(peg$currPos, 8) === peg$c573) {
+                                                                                            s1 = peg$c573;
+                                                                                            peg$currPos += 8;
+                                                                                          } else {
+                                                                                            s1 = peg$FAILED;
+                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c574); }
+                                                                                          }
+                                                                                          if (s1 !== peg$FAILED) {
+                                                                                            peg$savedPos = s0;
+                                                                                            s1 = peg$c572();
+                                                                                          }
+                                                                                          s0 = s1;
+                                                                                          if (s0 === peg$FAILED) {
+                                                                                            s0 = peg$currPos;
+                                                                                            if (input.substr(peg$currPos, 8) === peg$c575) {
+                                                                                              s1 = peg$c575;
+                                                                                              peg$currPos += 8;
+                                                                                            } else {
+                                                                                              s1 = peg$FAILED;
+                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c576); }
+                                                                                            }
+                                                                                            if (s1 !== peg$FAILED) {
+                                                                                              peg$savedPos = s0;
+                                                                                              s1 = peg$c577();
+                                                                                            }
+                                                                                            s0 = s1;
+                                                                                            if (s0 === peg$FAILED) {
+                                                                                              s0 = peg$currPos;
+                                                                                              if (input.substr(peg$currPos, 8) === peg$c578) {
+                                                                                                s1 = peg$c578;
+                                                                                                peg$currPos += 8;
+                                                                                              } else {
+                                                                                                s1 = peg$FAILED;
+                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c579); }
+                                                                                              }
+                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                peg$savedPos = s0;
+                                                                                                s1 = peg$c577();
+                                                                                              }
+                                                                                              s0 = s1;
+                                                                                              if (s0 === peg$FAILED) {
+                                                                                                s0 = peg$currPos;
+                                                                                                if (input.substr(peg$currPos, 13) === peg$c580) {
+                                                                                                  s1 = peg$c580;
+                                                                                                  peg$currPos += 13;
+                                                                                                } else {
+                                                                                                  s1 = peg$FAILED;
+                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c581); }
+                                                                                                }
+                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                  peg$savedPos = s0;
+                                                                                                  s1 = peg$c582();
+                                                                                                }
+                                                                                                s0 = s1;
+                                                                                                if (s0 === peg$FAILED) {
+                                                                                                  s0 = peg$currPos;
+                                                                                                  if (input.substr(peg$currPos, 13) === peg$c583) {
+                                                                                                    s1 = peg$c583;
+                                                                                                    peg$currPos += 13;
+                                                                                                  } else {
+                                                                                                    s1 = peg$FAILED;
+                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c584); }
+                                                                                                  }
+                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                    peg$savedPos = s0;
+                                                                                                    s1 = peg$c582();
+                                                                                                  }
+                                                                                                  s0 = s1;
+                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                    s0 = peg$currPos;
+                                                                                                    if (input.substr(peg$currPos, 8) === peg$c585) {
+                                                                                                      s1 = peg$c585;
+                                                                                                      peg$currPos += 8;
+                                                                                                    } else {
+                                                                                                      s1 = peg$FAILED;
+                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c586); }
+                                                                                                    }
+                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                      peg$savedPos = s0;
+                                                                                                      s1 = peg$c587();
+                                                                                                    }
+                                                                                                    s0 = s1;
+                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                      s0 = peg$currPos;
+                                                                                                      if (input.substr(peg$currPos, 8) === peg$c588) {
+                                                                                                        s1 = peg$c588;
+                                                                                                        peg$currPos += 8;
+                                                                                                      } else {
+                                                                                                        s1 = peg$FAILED;
+                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c589); }
+                                                                                                      }
+                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                        peg$savedPos = s0;
+                                                                                                        s1 = peg$c587();
+                                                                                                      }
+                                                                                                      s0 = s1;
+                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                        s0 = peg$currPos;
+                                                                                                        if (input.substr(peg$currPos, 8) === peg$c590) {
+                                                                                                          s1 = peg$c590;
+                                                                                                          peg$currPos += 8;
+                                                                                                        } else {
+                                                                                                          s1 = peg$FAILED;
+                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c591); }
+                                                                                                        }
+                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                          peg$savedPos = s0;
+                                                                                                          s1 = peg$c587();
+                                                                                                        }
+                                                                                                        s0 = s1;
+                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                          s0 = peg$currPos;
+                                                                                                          if (input.substr(peg$currPos, 8) === peg$c592) {
+                                                                                                            s1 = peg$c592;
+                                                                                                            peg$currPos += 8;
+                                                                                                          } else {
+                                                                                                            s1 = peg$FAILED;
+                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c593); }
+                                                                                                          }
+                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                            peg$savedPos = s0;
+                                                                                                            s1 = peg$c587();
+                                                                                                          }
+                                                                                                          s0 = s1;
+                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                            s0 = peg$currPos;
+                                                                                                            if (input.substr(peg$currPos, 9) === peg$c594) {
+                                                                                                              s1 = peg$c594;
+                                                                                                              peg$currPos += 9;
+                                                                                                            } else {
+                                                                                                              s1 = peg$FAILED;
+                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c595); }
+                                                                                                            }
+                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                              peg$savedPos = s0;
+                                                                                                              s1 = peg$c596();
+                                                                                                            }
+                                                                                                            s0 = s1;
+                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                              s0 = peg$currPos;
+                                                                                                              if (input.substr(peg$currPos, 9) === peg$c597) {
+                                                                                                                s1 = peg$c597;
+                                                                                                                peg$currPos += 9;
+                                                                                                              } else {
+                                                                                                                s1 = peg$FAILED;
+                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c598); }
+                                                                                                              }
+                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                peg$savedPos = s0;
+                                                                                                                s1 = peg$c596();
+                                                                                                              }
+                                                                                                              s0 = s1;
+                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                s0 = peg$currPos;
+                                                                                                                if (input.substr(peg$currPos, 9) === peg$c599) {
+                                                                                                                  s1 = peg$c599;
+                                                                                                                  peg$currPos += 9;
+                                                                                                                } else {
+                                                                                                                  s1 = peg$FAILED;
+                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c600); }
+                                                                                                                }
+                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                  peg$savedPos = s0;
+                                                                                                                  s1 = peg$c601();
+                                                                                                                }
+                                                                                                                s0 = s1;
+                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                  s0 = peg$currPos;
+                                                                                                                  if (input.substr(peg$currPos, 9) === peg$c602) {
+                                                                                                                    s1 = peg$c602;
+                                                                                                                    peg$currPos += 9;
+                                                                                                                  } else {
+                                                                                                                    s1 = peg$FAILED;
+                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c603); }
+                                                                                                                  }
+                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                    peg$savedPos = s0;
+                                                                                                                    s1 = peg$c601();
+                                                                                                                  }
+                                                                                                                  s0 = s1;
+                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                    s0 = peg$currPos;
+                                                                                                                    if (input.substr(peg$currPos, 11) === peg$c604) {
+                                                                                                                      s1 = peg$c604;
+                                                                                                                      peg$currPos += 11;
+                                                                                                                    } else {
+                                                                                                                      s1 = peg$FAILED;
+                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c605); }
+                                                                                                                    }
+                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                      peg$savedPos = s0;
+                                                                                                                      s1 = peg$c606();
+                                                                                                                    }
+                                                                                                                    s0 = s1;
+                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                      s0 = peg$currPos;
+                                                                                                                      if (input.substr(peg$currPos, 11) === peg$c607) {
+                                                                                                                        s1 = peg$c607;
+                                                                                                                        peg$currPos += 11;
+                                                                                                                      } else {
+                                                                                                                        s1 = peg$FAILED;
+                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c608); }
+                                                                                                                      }
+                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                        peg$savedPos = s0;
+                                                                                                                        s1 = peg$c606();
+                                                                                                                      }
+                                                                                                                      s0 = s1;
+                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                        s0 = peg$currPos;
+                                                                                                                        if (input.substr(peg$currPos, 14) === peg$c609) {
+                                                                                                                          s1 = peg$c609;
+                                                                                                                          peg$currPos += 14;
+                                                                                                                        } else {
+                                                                                                                          s1 = peg$FAILED;
+                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c610); }
+                                                                                                                        }
+                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                          peg$savedPos = s0;
+                                                                                                                          s1 = peg$c611();
+                                                                                                                        }
+                                                                                                                        s0 = s1;
+                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                          s0 = peg$currPos;
+                                                                                                                          if (input.substr(peg$currPos, 14) === peg$c612) {
+                                                                                                                            s1 = peg$c612;
+                                                                                                                            peg$currPos += 14;
+                                                                                                                          } else {
+                                                                                                                            s1 = peg$FAILED;
+                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c613); }
+                                                                                                                          }
+                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                            peg$savedPos = s0;
+                                                                                                                            s1 = peg$c611();
+                                                                                                                          }
+                                                                                                                          s0 = s1;
+                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                            s0 = peg$currPos;
+                                                                                                                            if (input.substr(peg$currPos, 10) === peg$c614) {
+                                                                                                                              s1 = peg$c614;
+                                                                                                                              peg$currPos += 10;
+                                                                                                                            } else {
+                                                                                                                              s1 = peg$FAILED;
+                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c615); }
+                                                                                                                            }
+                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                              peg$savedPos = s0;
+                                                                                                                              s1 = peg$c616();
+                                                                                                                            }
+                                                                                                                            s0 = s1;
+                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                              s0 = peg$currPos;
+                                                                                                                              if (input.substr(peg$currPos, 10) === peg$c617) {
+                                                                                                                                s1 = peg$c617;
+                                                                                                                                peg$currPos += 10;
+                                                                                                                              } else {
+                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c618); }
+                                                                                                                              }
+                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                peg$savedPos = s0;
+                                                                                                                                s1 = peg$c616();
+                                                                                                                              }
+                                                                                                                              s0 = s1;
+                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                s0 = peg$currPos;
+                                                                                                                                if (input.substr(peg$currPos, 10) === peg$c619) {
+                                                                                                                                  s1 = peg$c619;
+                                                                                                                                  peg$currPos += 10;
+                                                                                                                                } else {
+                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c620); }
+                                                                                                                                }
+                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                  s1 = peg$c621();
+                                                                                                                                }
+                                                                                                                                s0 = s1;
+                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                  if (input.substr(peg$currPos, 10) === peg$c622) {
+                                                                                                                                    s1 = peg$c622;
+                                                                                                                                    peg$currPos += 10;
+                                                                                                                                  } else {
+                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c623); }
+                                                                                                                                  }
+                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                    s1 = peg$c621();
+                                                                                                                                  }
+                                                                                                                                  s0 = s1;
+                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                    if (input.substr(peg$currPos, 7) === peg$c624) {
+                                                                                                                                      s1 = peg$c624;
+                                                                                                                                      peg$currPos += 7;
+                                                                                                                                    } else {
+                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c625); }
+                                                                                                                                    }
+                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                      s1 = peg$c626();
+                                                                                                                                    }
+                                                                                                                                    s0 = s1;
+                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                      if (input.substr(peg$currPos, 7) === peg$c627) {
+                                                                                                                                        s1 = peg$c627;
+                                                                                                                                        peg$currPos += 7;
+                                                                                                                                      } else {
+                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c628); }
+                                                                                                                                      }
+                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                        s1 = peg$c626();
+                                                                                                                                      }
+                                                                                                                                      s0 = s1;
+                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                        if (input.substr(peg$currPos, 10) === peg$c629) {
+                                                                                                                                          s1 = peg$c629;
+                                                                                                                                          peg$currPos += 10;
+                                                                                                                                        } else {
+                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c630); }
+                                                                                                                                        }
+                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                          s1 = peg$c631();
+                                                                                                                                        }
+                                                                                                                                        s0 = s1;
+                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                          if (input.substr(peg$currPos, 10) === peg$c632) {
+                                                                                                                                            s1 = peg$c632;
+                                                                                                                                            peg$currPos += 10;
+                                                                                                                                          } else {
+                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c633); }
+                                                                                                                                          }
+                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                            s1 = peg$c631();
+                                                                                                                                          }
+                                                                                                                                          s0 = s1;
+                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                            if (input.substr(peg$currPos, 12) === peg$c634) {
+                                                                                                                                              s1 = peg$c634;
+                                                                                                                                              peg$currPos += 12;
+                                                                                                                                            } else {
+                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c635); }
+                                                                                                                                            }
+                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                              s1 = peg$c636();
+                                                                                                                                            }
+                                                                                                                                            s0 = s1;
+                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                              if (input.substr(peg$currPos, 12) === peg$c637) {
+                                                                                                                                                s1 = peg$c637;
+                                                                                                                                                peg$currPos += 12;
+                                                                                                                                              } else {
+                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c638); }
+                                                                                                                                              }
+                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                s1 = peg$c636();
+                                                                                                                                              }
+                                                                                                                                              s0 = s1;
+                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                if (input.substr(peg$currPos, 13) === peg$c639) {
+                                                                                                                                                  s1 = peg$c639;
+                                                                                                                                                  peg$currPos += 13;
+                                                                                                                                                } else {
+                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c640); }
+                                                                                                                                                }
+                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                  s1 = peg$c641();
+                                                                                                                                                }
+                                                                                                                                                s0 = s1;
+                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                  if (input.substr(peg$currPos, 13) === peg$c642) {
+                                                                                                                                                    s1 = peg$c642;
+                                                                                                                                                    peg$currPos += 13;
+                                                                                                                                                  } else {
+                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c643); }
+                                                                                                                                                  }
+                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                    s1 = peg$c641();
+                                                                                                                                                  }
+                                                                                                                                                  s0 = s1;
+                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                    if (input.substr(peg$currPos, 13) === peg$c644) {
+                                                                                                                                                      s1 = peg$c644;
+                                                                                                                                                      peg$currPos += 13;
+                                                                                                                                                    } else {
+                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c645); }
+                                                                                                                                                    }
+                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                      s1 = peg$c646();
+                                                                                                                                                    }
+                                                                                                                                                    s0 = s1;
+                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                      if (input.substr(peg$currPos, 13) === peg$c647) {
+                                                                                                                                                        s1 = peg$c647;
+                                                                                                                                                        peg$currPos += 13;
+                                                                                                                                                      } else {
+                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c648); }
+                                                                                                                                                      }
+                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                        s1 = peg$c646();
+                                                                                                                                                      }
+                                                                                                                                                      s0 = s1;
+                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                        if (input.substr(peg$currPos, 13) === peg$c649) {
+                                                                                                                                                          s1 = peg$c649;
+                                                                                                                                                          peg$currPos += 13;
+                                                                                                                                                        } else {
+                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c650); }
+                                                                                                                                                        }
+                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                          s1 = peg$c646();
+                                                                                                                                                        }
+                                                                                                                                                        s0 = s1;
+                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                          if (input.substr(peg$currPos, 13) === peg$c651) {
+                                                                                                                                                            s1 = peg$c651;
+                                                                                                                                                            peg$currPos += 13;
+                                                                                                                                                          } else {
+                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c652); }
+                                                                                                                                                          }
+                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                            s1 = peg$c646();
+                                                                                                                                                          }
+                                                                                                                                                          s0 = s1;
+                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                            if (input.substr(peg$currPos, 13) === peg$c653) {
+                                                                                                                                                              s1 = peg$c653;
+                                                                                                                                                              peg$currPos += 13;
+                                                                                                                                                            } else {
+                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c654); }
+                                                                                                                                                            }
+                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                              s1 = peg$c655();
+                                                                                                                                                            }
+                                                                                                                                                            s0 = s1;
+                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                              if (input.substr(peg$currPos, 13) === peg$c656) {
+                                                                                                                                                                s1 = peg$c656;
+                                                                                                                                                                peg$currPos += 13;
+                                                                                                                                                              } else {
+                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c657); }
+                                                                                                                                                              }
+                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                s1 = peg$c655();
+                                                                                                                                                              }
+                                                                                                                                                              s0 = s1;
+                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                if (input.substr(peg$currPos, 10) === peg$c658) {
+                                                                                                                                                                  s1 = peg$c658;
+                                                                                                                                                                  peg$currPos += 10;
+                                                                                                                                                                } else {
+                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c659); }
+                                                                                                                                                                }
+                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                  s1 = peg$c660();
+                                                                                                                                                                }
+                                                                                                                                                                s0 = s1;
+                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                  if (input.substr(peg$currPos, 10) === peg$c661) {
+                                                                                                                                                                    s1 = peg$c661;
+                                                                                                                                                                    peg$currPos += 10;
+                                                                                                                                                                  } else {
+                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c662); }
+                                                                                                                                                                  }
+                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                    s1 = peg$c660();
+                                                                                                                                                                  }
+                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                    if (input.substr(peg$currPos, 8) === peg$c663) {
+                                                                                                                                                                      s1 = peg$c663;
+                                                                                                                                                                      peg$currPos += 8;
+                                                                                                                                                                    } else {
+                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c664); }
+                                                                                                                                                                    }
+                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                      s1 = peg$c665();
+                                                                                                                                                                    }
+                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                      if (input.substr(peg$currPos, 8) === peg$c666) {
+                                                                                                                                                                        s1 = peg$c666;
+                                                                                                                                                                        peg$currPos += 8;
+                                                                                                                                                                      } else {
+                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c667); }
+                                                                                                                                                                      }
+                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                        s1 = peg$c665();
+                                                                                                                                                                      }
+                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                        if (input.substr(peg$currPos, 11) === peg$c668) {
+                                                                                                                                                                          s1 = peg$c668;
+                                                                                                                                                                          peg$currPos += 11;
+                                                                                                                                                                        } else {
+                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c669); }
+                                                                                                                                                                        }
+                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                          s1 = peg$c670();
+                                                                                                                                                                        }
+                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                          if (input.substr(peg$currPos, 11) === peg$c671) {
+                                                                                                                                                                            s1 = peg$c671;
+                                                                                                                                                                            peg$currPos += 11;
+                                                                                                                                                                          } else {
+                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c672); }
+                                                                                                                                                                          }
+                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                            s1 = peg$c670();
+                                                                                                                                                                          }
+                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                            if (input.substr(peg$currPos, 7) === peg$c673) {
+                                                                                                                                                                              s1 = peg$c673;
+                                                                                                                                                                              peg$currPos += 7;
+                                                                                                                                                                            } else {
+                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c674); }
+                                                                                                                                                                            }
+                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                              s1 = peg$c675();
+                                                                                                                                                                            }
+                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                              if (input.substr(peg$currPos, 7) === peg$c676) {
+                                                                                                                                                                                s1 = peg$c676;
+                                                                                                                                                                                peg$currPos += 7;
+                                                                                                                                                                              } else {
+                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c677); }
+                                                                                                                                                                              }
+                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                s1 = peg$c675();
+                                                                                                                                                                              }
+                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                                if (input.substr(peg$currPos, 7) === peg$c678) {
+                                                                                                                                                                                  s1 = peg$c678;
+                                                                                                                                                                                  peg$currPos += 7;
+                                                                                                                                                                                } else {
+                                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c679); }
+                                                                                                                                                                                }
+                                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                                  s1 = peg$c675();
+                                                                                                                                                                                }
+                                                                                                                                                                                s0 = s1;
+                                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                                  if (input.substr(peg$currPos, 7) === peg$c680) {
+                                                                                                                                                                                    s1 = peg$c680;
+                                                                                                                                                                                    peg$currPos += 7;
+                                                                                                                                                                                  } else {
+                                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c681); }
+                                                                                                                                                                                  }
+                                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                                    s1 = peg$c675();
+                                                                                                                                                                                  }
+                                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                                    if (input.substr(peg$currPos, 10) === peg$c682) {
+                                                                                                                                                                                      s1 = peg$c682;
+                                                                                                                                                                                      peg$currPos += 10;
+                                                                                                                                                                                    } else {
+                                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c683); }
+                                                                                                                                                                                    }
+                                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                                      s1 = peg$c684();
+                                                                                                                                                                                    }
+                                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                                      if (input.substr(peg$currPos, 10) === peg$c685) {
+                                                                                                                                                                                        s1 = peg$c685;
+                                                                                                                                                                                        peg$currPos += 10;
+                                                                                                                                                                                      } else {
+                                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c686); }
+                                                                                                                                                                                      }
+                                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                                        s1 = peg$c684();
+                                                                                                                                                                                      }
+                                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                                        if (input.substr(peg$currPos, 9) === peg$c687) {
+                                                                                                                                                                                          s1 = peg$c687;
+                                                                                                                                                                                          peg$currPos += 9;
+                                                                                                                                                                                        } else {
+                                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c688); }
+                                                                                                                                                                                        }
+                                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                                          s1 = peg$c689();
+                                                                                                                                                                                        }
+                                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                                          if (input.substr(peg$currPos, 9) === peg$c690) {
+                                                                                                                                                                                            s1 = peg$c690;
+                                                                                                                                                                                            peg$currPos += 9;
+                                                                                                                                                                                          } else {
+                                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c691); }
+                                                                                                                                                                                          }
+                                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                                            s1 = peg$c689();
+                                                                                                                                                                                          }
+                                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                                            if (input.substr(peg$currPos, 11) === peg$c692) {
+                                                                                                                                                                                              s1 = peg$c692;
+                                                                                                                                                                                              peg$currPos += 11;
+                                                                                                                                                                                            } else {
+                                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c693); }
+                                                                                                                                                                                            }
+                                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                                              s1 = peg$c694();
+                                                                                                                                                                                            }
+                                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                                              if (input.substr(peg$currPos, 11) === peg$c695) {
+                                                                                                                                                                                                s1 = peg$c695;
+                                                                                                                                                                                                peg$currPos += 11;
+                                                                                                                                                                                              } else {
+                                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c696); }
+                                                                                                                                                                                              }
+                                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                                s1 = peg$c694();
+                                                                                                                                                                                              }
+                                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                                                if (input.substr(peg$currPos, 11) === peg$c697) {
+                                                                                                                                                                                                  s1 = peg$c697;
+                                                                                                                                                                                                  peg$currPos += 11;
+                                                                                                                                                                                                } else {
+                                                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c698); }
+                                                                                                                                                                                                }
+                                                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                                                  s1 = peg$c699();
+                                                                                                                                                                                                }
+                                                                                                                                                                                                s0 = s1;
+                                                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                                                  if (input.substr(peg$currPos, 11) === peg$c700) {
+                                                                                                                                                                                                    s1 = peg$c700;
+                                                                                                                                                                                                    peg$currPos += 11;
+                                                                                                                                                                                                  } else {
+                                                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c701); }
+                                                                                                                                                                                                  }
+                                                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                                                    s1 = peg$c699();
+                                                                                                                                                                                                  }
+                                                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                                                    if (input.substr(peg$currPos, 7) === peg$c702) {
+                                                                                                                                                                                                      s1 = peg$c702;
+                                                                                                                                                                                                      peg$currPos += 7;
+                                                                                                                                                                                                    } else {
+                                                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c703); }
+                                                                                                                                                                                                    }
+                                                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                                                      s1 = peg$c704();
+                                                                                                                                                                                                    }
+                                                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                                                      if (input.substr(peg$currPos, 7) === peg$c705) {
+                                                                                                                                                                                                        s1 = peg$c705;
+                                                                                                                                                                                                        peg$currPos += 7;
+                                                                                                                                                                                                      } else {
+                                                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c706); }
+                                                                                                                                                                                                      }
+                                                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                                                        s1 = peg$c704();
+                                                                                                                                                                                                      }
+                                                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                                                        if (input.substr(peg$currPos, 9) === peg$c707) {
+                                                                                                                                                                                                          s1 = peg$c707;
+                                                                                                                                                                                                          peg$currPos += 9;
+                                                                                                                                                                                                        } else {
+                                                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c708); }
+                                                                                                                                                                                                        }
+                                                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                                                          s1 = peg$c709();
+                                                                                                                                                                                                        }
+                                                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                                                          if (input.substr(peg$currPos, 9) === peg$c710) {
+                                                                                                                                                                                                            s1 = peg$c710;
+                                                                                                                                                                                                            peg$currPos += 9;
+                                                                                                                                                                                                          } else {
+                                                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c711); }
+                                                                                                                                                                                                          }
+                                                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                                                            s1 = peg$c709();
+                                                                                                                                                                                                          }
+                                                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                                                            if (input.substr(peg$currPos, 10) === peg$c712) {
+                                                                                                                                                                                                              s1 = peg$c712;
+                                                                                                                                                                                                              peg$currPos += 10;
+                                                                                                                                                                                                            } else {
+                                                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c713); }
+                                                                                                                                                                                                            }
+                                                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                                                              s1 = peg$c714();
+                                                                                                                                                                                                            }
+                                                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                                                              if (input.substr(peg$currPos, 10) === peg$c715) {
+                                                                                                                                                                                                                s1 = peg$c715;
+                                                                                                                                                                                                                peg$currPos += 10;
+                                                                                                                                                                                                              } else {
+                                                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c716); }
+                                                                                                                                                                                                              }
+                                                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                                                s1 = peg$c714();
+                                                                                                                                                                                                              }
+                                                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                                                                if (input.substr(peg$currPos, 9) === peg$c717) {
+                                                                                                                                                                                                                  s1 = peg$c717;
+                                                                                                                                                                                                                  peg$currPos += 9;
+                                                                                                                                                                                                                } else {
+                                                                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c718); }
+                                                                                                                                                                                                                }
+                                                                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                                                                  s1 = peg$c719();
+                                                                                                                                                                                                                }
+                                                                                                                                                                                                                s0 = s1;
+                                                                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                                                                  if (input.substr(peg$currPos, 9) === peg$c720) {
+                                                                                                                                                                                                                    s1 = peg$c720;
+                                                                                                                                                                                                                    peg$currPos += 9;
+                                                                                                                                                                                                                  } else {
+                                                                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c721); }
+                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                                                                    s1 = peg$c719();
+                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                                                                    if (input.substr(peg$currPos, 4) === peg$c722) {
+                                                                                                                                                                                                                      s1 = peg$c722;
+                                                                                                                                                                                                                      peg$currPos += 4;
+                                                                                                                                                                                                                    } else {
+                                                                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c723); }
+                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                                                                      s1 = peg$c724();
+                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                                                                      if (input.substr(peg$currPos, 4) === peg$c725) {
+                                                                                                                                                                                                                        s1 = peg$c725;
+                                                                                                                                                                                                                        peg$currPos += 4;
+                                                                                                                                                                                                                      } else {
+                                                                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c726); }
+                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                                                                        s1 = peg$c724();
+                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                                                                        if (input.substr(peg$currPos, 4) === peg$c727) {
+                                                                                                                                                                                                                          s1 = peg$c727;
+                                                                                                                                                                                                                          peg$currPos += 4;
+                                                                                                                                                                                                                        } else {
+                                                                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c728); }
+                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                                                                          s1 = peg$c729();
+                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                                                                          if (input.substr(peg$currPos, 4) === peg$c730) {
+                                                                                                                                                                                                                            s1 = peg$c730;
+                                                                                                                                                                                                                            peg$currPos += 4;
+                                                                                                                                                                                                                          } else {
+                                                                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c731); }
+                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                                                                            s1 = peg$c729();
+                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                                                                            if (input.substr(peg$currPos, 4) === peg$c732) {
+                                                                                                                                                                                                                              s1 = peg$c732;
+                                                                                                                                                                                                                              peg$currPos += 4;
+                                                                                                                                                                                                                            } else {
+                                                                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c733); }
+                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                                                                              s1 = peg$c729();
+                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                                                                              if (input.substr(peg$currPos, 4) === peg$c734) {
+                                                                                                                                                                                                                                s1 = peg$c734;
+                                                                                                                                                                                                                                peg$currPos += 4;
+                                                                                                                                                                                                                              } else {
+                                                                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c735); }
+                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                                                                s1 = peg$c729();
+                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                                                                                if (input.substr(peg$currPos, 11) === peg$c736) {
+                                                                                                                                                                                                                                  s1 = peg$c736;
+                                                                                                                                                                                                                                  peg$currPos += 11;
+                                                                                                                                                                                                                                } else {
+                                                                                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c737); }
+                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                                                                                  s1 = peg$c738();
+                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                s0 = s1;
+                                                                                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                                                                                  if (input.substr(peg$currPos, 11) === peg$c739) {
+                                                                                                                                                                                                                                    s1 = peg$c739;
+                                                                                                                                                                                                                                    peg$currPos += 11;
+                                                                                                                                                                                                                                  } else {
+                                                                                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c740); }
+                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                                                                                    s1 = peg$c738();
+                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                                                                                    if (input.substr(peg$currPos, 5) === peg$c741) {
+                                                                                                                                                                                                                                      s1 = peg$c741;
+                                                                                                                                                                                                                                      peg$currPos += 5;
+                                                                                                                                                                                                                                    } else {
+                                                                                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c742); }
+                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                                                                                      s1 = peg$c743();
+                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                                                                                      if (input.substr(peg$currPos, 5) === peg$c744) {
+                                                                                                                                                                                                                                        s1 = peg$c744;
+                                                                                                                                                                                                                                        peg$currPos += 5;
+                                                                                                                                                                                                                                      } else {
+                                                                                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c745); }
+                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                                                                                        s1 = peg$c743();
+                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                                                                                        if (input.substr(peg$currPos, 8) === peg$c746) {
+                                                                                                                                                                                                                                          s1 = peg$c746;
+                                                                                                                                                                                                                                          peg$currPos += 8;
+                                                                                                                                                                                                                                        } else {
+                                                                                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c747); }
+                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                                                                                          s1 = peg$c748();
+                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                                                                                          if (input.substr(peg$currPos, 8) === peg$c749) {
+                                                                                                                                                                                                                                            s1 = peg$c749;
+                                                                                                                                                                                                                                            peg$currPos += 8;
+                                                                                                                                                                                                                                          } else {
+                                                                                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c750); }
+                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                                                                                            s1 = peg$c748();
+                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                                                                                            if (input.substr(peg$currPos, 7) === peg$c751) {
+                                                                                                                                                                                                                                              s1 = peg$c751;
+                                                                                                                                                                                                                                              peg$currPos += 7;
+                                                                                                                                                                                                                                            } else {
+                                                                                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c752); }
+                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                                                                                              s1 = peg$c753();
+                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                                                                                              if (input.substr(peg$currPos, 7) === peg$c754) {
+                                                                                                                                                                                                                                                s1 = peg$c754;
+                                                                                                                                                                                                                                                peg$currPos += 7;
+                                                                                                                                                                                                                                              } else {
+                                                                                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c755); }
+                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                                                                                s1 = peg$c753();
+                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                                                                                                if (input.substr(peg$currPos, 9) === peg$c756) {
+                                                                                                                                                                                                                                                  s1 = peg$c756;
+                                                                                                                                                                                                                                                  peg$currPos += 9;
+                                                                                                                                                                                                                                                } else {
+                                                                                                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c757); }
+                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                                                                                                  s1 = peg$c758();
+                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                s0 = s1;
+                                                                                                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                                                                                                  if (input.substr(peg$currPos, 9) === peg$c759) {
+                                                                                                                                                                                                                                                    s1 = peg$c759;
+                                                                                                                                                                                                                                                    peg$currPos += 9;
+                                                                                                                                                                                                                                                  } else {
+                                                                                                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c760); }
+                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                                                                                                    s1 = peg$c758();
+                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                                                                                                    if (input.substr(peg$currPos, 6) === peg$c761) {
+                                                                                                                                                                                                                                                      s1 = peg$c761;
+                                                                                                                                                                                                                                                      peg$currPos += 6;
+                                                                                                                                                                                                                                                    } else {
+                                                                                                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c762); }
+                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                                                                                                      s1 = peg$c763();
+                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                                                                                                      if (input.substr(peg$currPos, 6) === peg$c764) {
+                                                                                                                                                                                                                                                        s1 = peg$c764;
+                                                                                                                                                                                                                                                        peg$currPos += 6;
+                                                                                                                                                                                                                                                      } else {
+                                                                                                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c765); }
+                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                                                                                                        s1 = peg$c763();
+                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                                                                                                        if (input.substr(peg$currPos, 5) === peg$c766) {
+                                                                                                                                                                                                                                                          s1 = peg$c766;
+                                                                                                                                                                                                                                                          peg$currPos += 5;
+                                                                                                                                                                                                                                                        } else {
+                                                                                                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c767); }
+                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                                                                                                          s1 = peg$c768();
+                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                                                                                                          if (input.substr(peg$currPos, 5) === peg$c769) {
+                                                                                                                                                                                                                                                            s1 = peg$c769;
+                                                                                                                                                                                                                                                            peg$currPos += 5;
+                                                                                                                                                                                                                                                          } else {
+                                                                                                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c770); }
+                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                                                                                                            s1 = peg$c768();
+                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                                                                                                            if (input.substr(peg$currPos, 5) === peg$c771) {
+                                                                                                                                                                                                                                                              s1 = peg$c771;
+                                                                                                                                                                                                                                                              peg$currPos += 5;
+                                                                                                                                                                                                                                                            } else {
+                                                                                                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c772); }
+                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                                                                                                              s1 = peg$c773();
+                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                                                                                                              if (input.substr(peg$currPos, 5) === peg$c774) {
+                                                                                                                                                                                                                                                                s1 = peg$c774;
+                                                                                                                                                                                                                                                                peg$currPos += 5;
+                                                                                                                                                                                                                                                              } else {
+                                                                                                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c775); }
+                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                                                                                                s1 = peg$c773();
+                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                                                                                                                if (input.substr(peg$currPos, 13) === peg$c776) {
+                                                                                                                                                                                                                                                                  s1 = peg$c776;
+                                                                                                                                                                                                                                                                  peg$currPos += 13;
+                                                                                                                                                                                                                                                                } else {
+                                                                                                                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c777); }
+                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                                                                                                                  s1 = peg$c778();
+                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                s0 = s1;
+                                                                                                                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                                                                                                                  if (input.substr(peg$currPos, 13) === peg$c779) {
+                                                                                                                                                                                                                                                                    s1 = peg$c779;
+                                                                                                                                                                                                                                                                    peg$currPos += 13;
+                                                                                                                                                                                                                                                                  } else {
+                                                                                                                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c780); }
+                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                                                                                                                    s1 = peg$c778();
+                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                                                                                                                    if (input.substr(peg$currPos, 8) === peg$c781) {
+                                                                                                                                                                                                                                                                      s1 = peg$c781;
+                                                                                                                                                                                                                                                                      peg$currPos += 8;
+                                                                                                                                                                                                                                                                    } else {
+                                                                                                                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c782); }
+                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                                                                                                                      s1 = peg$c783();
+                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                                                                                                                      if (input.substr(peg$currPos, 8) === peg$c784) {
+                                                                                                                                                                                                                                                                        s1 = peg$c784;
+                                                                                                                                                                                                                                                                        peg$currPos += 8;
+                                                                                                                                                                                                                                                                      } else {
+                                                                                                                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c785); }
+                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                                                                                                                        s1 = peg$c783();
+                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                                                                                                                        if (input.substr(peg$currPos, 9) === peg$c786) {
+                                                                                                                                                                                                                                                                          s1 = peg$c786;
+                                                                                                                                                                                                                                                                          peg$currPos += 9;
+                                                                                                                                                                                                                                                                        } else {
+                                                                                                                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c787); }
+                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                                                                                                                          s1 = peg$c788();
+                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                                                                                                                          if (input.substr(peg$currPos, 9) === peg$c789) {
+                                                                                                                                                                                                                                                                            s1 = peg$c789;
+                                                                                                                                                                                                                                                                            peg$currPos += 9;
+                                                                                                                                                                                                                                                                          } else {
+                                                                                                                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c790); }
+                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                                                                                                                            s1 = peg$c788();
+                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                                                                                                                            if (input.substr(peg$currPos, 12) === peg$c791) {
+                                                                                                                                                                                                                                                                              s1 = peg$c791;
+                                                                                                                                                                                                                                                                              peg$currPos += 12;
+                                                                                                                                                                                                                                                                            } else {
+                                                                                                                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c792); }
+                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                                                                                                                              s1 = peg$c793();
+                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                                                                                                                              if (input.substr(peg$currPos, 12) === peg$c794) {
+                                                                                                                                                                                                                                                                                s1 = peg$c794;
+                                                                                                                                                                                                                                                                                peg$currPos += 12;
+                                                                                                                                                                                                                                                                              } else {
+                                                                                                                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c795); }
+                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                s1 = peg$c793();
+                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                if (input.substr(peg$currPos, 9) === peg$c796) {
+                                                                                                                                                                                                                                                                                  s1 = peg$c796;
+                                                                                                                                                                                                                                                                                  peg$currPos += 9;
+                                                                                                                                                                                                                                                                                } else {
+                                                                                                                                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c797); }
+                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                  s1 = peg$c798();
+                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                s0 = s1;
+                                                                                                                                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                  if (input.substr(peg$currPos, 9) === peg$c799) {
+                                                                                                                                                                                                                                                                                    s1 = peg$c799;
+                                                                                                                                                                                                                                                                                    peg$currPos += 9;
+                                                                                                                                                                                                                                                                                  } else {
+                                                                                                                                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c800); }
+                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                    s1 = peg$c798();
+                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                    if (input.substr(peg$currPos, 10) === peg$c801) {
+                                                                                                                                                                                                                                                                                      s1 = peg$c801;
+                                                                                                                                                                                                                                                                                      peg$currPos += 10;
+                                                                                                                                                                                                                                                                                    } else {
+                                                                                                                                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c802); }
+                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                      s1 = peg$c803();
+                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                      if (input.substr(peg$currPos, 10) === peg$c804) {
+                                                                                                                                                                                                                                                                                        s1 = peg$c804;
+                                                                                                                                                                                                                                                                                        peg$currPos += 10;
+                                                                                                                                                                                                                                                                                      } else {
+                                                                                                                                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c805); }
+                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                        s1 = peg$c803();
+                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                        if (input.substr(peg$currPos, 9) === peg$c806) {
+                                                                                                                                                                                                                                                                                          s1 = peg$c806;
+                                                                                                                                                                                                                                                                                          peg$currPos += 9;
+                                                                                                                                                                                                                                                                                        } else {
+                                                                                                                                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c807); }
+                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                          s1 = peg$c808();
+                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                          if (input.substr(peg$currPos, 9) === peg$c809) {
+                                                                                                                                                                                                                                                                                            s1 = peg$c809;
+                                                                                                                                                                                                                                                                                            peg$currPos += 9;
+                                                                                                                                                                                                                                                                                          } else {
+                                                                                                                                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c810); }
+                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                            s1 = peg$c808();
+                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                            if (input.substr(peg$currPos, 20) === peg$c811) {
+                                                                                                                                                                                                                                                                                              s1 = peg$c811;
+                                                                                                                                                                                                                                                                                              peg$currPos += 20;
+                                                                                                                                                                                                                                                                                            } else {
+                                                                                                                                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c812); }
+                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                              s1 = peg$c813();
+                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                              if (input.substr(peg$currPos, 20) === peg$c814) {
+                                                                                                                                                                                                                                                                                                s1 = peg$c814;
+                                                                                                                                                                                                                                                                                                peg$currPos += 20;
+                                                                                                                                                                                                                                                                                              } else {
+                                                                                                                                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c815); }
+                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                s1 = peg$c813();
+                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                if (input.substr(peg$currPos, 9) === peg$c816) {
+                                                                                                                                                                                                                                                                                                  s1 = peg$c816;
+                                                                                                                                                                                                                                                                                                  peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                } else {
+                                                                                                                                                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c817); }
+                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                  s1 = peg$c818();
+                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                s0 = s1;
+                                                                                                                                                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                  if (input.substr(peg$currPos, 9) === peg$c819) {
+                                                                                                                                                                                                                                                                                                    s1 = peg$c819;
+                                                                                                                                                                                                                                                                                                    peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                  } else {
+                                                                                                                                                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c820); }
+                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                    s1 = peg$c818();
+                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                    if (input.substr(peg$currPos, 9) === peg$c821) {
+                                                                                                                                                                                                                                                                                                      s1 = peg$c821;
+                                                                                                                                                                                                                                                                                                      peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                    } else {
+                                                                                                                                                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c822); }
+                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                      s1 = peg$c818();
+                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                      if (input.substr(peg$currPos, 9) === peg$c823) {
+                                                                                                                                                                                                                                                                                                        s1 = peg$c823;
+                                                                                                                                                                                                                                                                                                        peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                      } else {
+                                                                                                                                                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c824); }
+                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                        s1 = peg$c818();
+                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                        if (input.substr(peg$currPos, 10) === peg$c825) {
+                                                                                                                                                                                                                                                                                                          s1 = peg$c825;
+                                                                                                                                                                                                                                                                                                          peg$currPos += 10;
+                                                                                                                                                                                                                                                                                                        } else {
+                                                                                                                                                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c826); }
+                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                          s1 = peg$c827();
+                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                          if (input.substr(peg$currPos, 10) === peg$c828) {
+                                                                                                                                                                                                                                                                                                            s1 = peg$c828;
+                                                                                                                                                                                                                                                                                                            peg$currPos += 10;
+                                                                                                                                                                                                                                                                                                          } else {
+                                                                                                                                                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c829); }
+                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                            s1 = peg$c827();
+                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                            if (input.substr(peg$currPos, 9) === peg$c830) {
+                                                                                                                                                                                                                                                                                                              s1 = peg$c830;
+                                                                                                                                                                                                                                                                                                              peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                            } else {
+                                                                                                                                                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c831); }
+                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                              s1 = peg$c832();
+                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                              if (input.substr(peg$currPos, 9) === peg$c833) {
+                                                                                                                                                                                                                                                                                                                s1 = peg$c833;
+                                                                                                                                                                                                                                                                                                                peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                              } else {
+                                                                                                                                                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c834); }
+                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                s1 = peg$c832();
+                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                if (input.substr(peg$currPos, 11) === peg$c835) {
+                                                                                                                                                                                                                                                                                                                  s1 = peg$c835;
+                                                                                                                                                                                                                                                                                                                  peg$currPos += 11;
+                                                                                                                                                                                                                                                                                                                } else {
+                                                                                                                                                                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c836); }
+                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                  s1 = peg$c837();
+                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                s0 = s1;
+                                                                                                                                                                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                  if (input.substr(peg$currPos, 11) === peg$c838) {
+                                                                                                                                                                                                                                                                                                                    s1 = peg$c838;
+                                                                                                                                                                                                                                                                                                                    peg$currPos += 11;
+                                                                                                                                                                                                                                                                                                                  } else {
+                                                                                                                                                                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c839); }
+                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                    s1 = peg$c837();
+                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                    if (input.substr(peg$currPos, 13) === peg$c840) {
+                                                                                                                                                                                                                                                                                                                      s1 = peg$c840;
+                                                                                                                                                                                                                                                                                                                      peg$currPos += 13;
+                                                                                                                                                                                                                                                                                                                    } else {
+                                                                                                                                                                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c841); }
+                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                      s1 = peg$c842();
+                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                      if (input.substr(peg$currPos, 13) === peg$c843) {
+                                                                                                                                                                                                                                                                                                                        s1 = peg$c843;
+                                                                                                                                                                                                                                                                                                                        peg$currPos += 13;
+                                                                                                                                                                                                                                                                                                                      } else {
+                                                                                                                                                                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c844); }
+                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                        s1 = peg$c842();
+                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                        if (input.substr(peg$currPos, 12) === peg$c845) {
+                                                                                                                                                                                                                                                                                                                          s1 = peg$c845;
+                                                                                                                                                                                                                                                                                                                          peg$currPos += 12;
+                                                                                                                                                                                                                                                                                                                        } else {
+                                                                                                                                                                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c846); }
+                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                          s1 = peg$c847();
+                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                          if (input.substr(peg$currPos, 12) === peg$c848) {
+                                                                                                                                                                                                                                                                                                                            s1 = peg$c848;
+                                                                                                                                                                                                                                                                                                                            peg$currPos += 12;
+                                                                                                                                                                                                                                                                                                                          } else {
+                                                                                                                                                                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c849); }
+                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                            s1 = peg$c847();
+                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                            if (input.substr(peg$currPos, 14) === peg$c850) {
+                                                                                                                                                                                                                                                                                                                              s1 = peg$c850;
+                                                                                                                                                                                                                                                                                                                              peg$currPos += 14;
+                                                                                                                                                                                                                                                                                                                            } else {
+                                                                                                                                                                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c851); }
+                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                              s1 = peg$c852();
+                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                              if (input.substr(peg$currPos, 14) === peg$c853) {
+                                                                                                                                                                                                                                                                                                                                s1 = peg$c853;
+                                                                                                                                                                                                                                                                                                                                peg$currPos += 14;
+                                                                                                                                                                                                                                                                                                                              } else {
+                                                                                                                                                                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c854); }
+                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                s1 = peg$c852();
+                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                if (input.substr(peg$currPos, 14) === peg$c855) {
+                                                                                                                                                                                                                                                                                                                                  s1 = peg$c855;
+                                                                                                                                                                                                                                                                                                                                  peg$currPos += 14;
+                                                                                                                                                                                                                                                                                                                                } else {
+                                                                                                                                                                                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c856); }
+                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                  s1 = peg$c852();
+                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                s0 = s1;
+                                                                                                                                                                                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                  if (input.substr(peg$currPos, 14) === peg$c857) {
+                                                                                                                                                                                                                                                                                                                                    s1 = peg$c857;
+                                                                                                                                                                                                                                                                                                                                    peg$currPos += 14;
+                                                                                                                                                                                                                                                                                                                                  } else {
+                                                                                                                                                                                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c858); }
+                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                    s1 = peg$c852();
+                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                    if (input.substr(peg$currPos, 14) === peg$c859) {
+                                                                                                                                                                                                                                                                                                                                      s1 = peg$c859;
+                                                                                                                                                                                                                                                                                                                                      peg$currPos += 14;
+                                                                                                                                                                                                                                                                                                                                    } else {
+                                                                                                                                                                                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c860); }
+                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                      s1 = peg$c861();
+                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                      if (input.substr(peg$currPos, 14) === peg$c862) {
+                                                                                                                                                                                                                                                                                                                                        s1 = peg$c862;
+                                                                                                                                                                                                                                                                                                                                        peg$currPos += 14;
+                                                                                                                                                                                                                                                                                                                                      } else {
+                                                                                                                                                                                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c863); }
+                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                        s1 = peg$c861();
+                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                        if (input.substr(peg$currPos, 11) === peg$c864) {
+                                                                                                                                                                                                                                                                                                                                          s1 = peg$c864;
+                                                                                                                                                                                                                                                                                                                                          peg$currPos += 11;
+                                                                                                                                                                                                                                                                                                                                        } else {
+                                                                                                                                                                                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c865); }
+                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                          s1 = peg$c866();
+                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                          if (input.substr(peg$currPos, 11) === peg$c867) {
+                                                                                                                                                                                                                                                                                                                                            s1 = peg$c867;
+                                                                                                                                                                                                                                                                                                                                            peg$currPos += 11;
+                                                                                                                                                                                                                                                                                                                                          } else {
+                                                                                                                                                                                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c868); }
+                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                            s1 = peg$c866();
+                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                            if (input.substr(peg$currPos, 9) === peg$c869) {
+                                                                                                                                                                                                                                                                                                                                              s1 = peg$c869;
+                                                                                                                                                                                                                                                                                                                                              peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                            } else {
+                                                                                                                                                                                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c870); }
+                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                              s1 = peg$c871();
+                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                              if (input.substr(peg$currPos, 9) === peg$c872) {
+                                                                                                                                                                                                                                                                                                                                                s1 = peg$c872;
+                                                                                                                                                                                                                                                                                                                                                peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                              } else {
+                                                                                                                                                                                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c873); }
+                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                s1 = peg$c871();
+                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                                                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                if (input.substr(peg$currPos, 4) === peg$c874) {
+                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c874;
+                                                                                                                                                                                                                                                                                                                                                  peg$currPos += 4;
+                                                                                                                                                                                                                                                                                                                                                } else {
+                                                                                                                                                                                                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c875); }
+                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c876();
+                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                  if (input.substr(peg$currPos, 4) === peg$c877) {
+                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c877;
+                                                                                                                                                                                                                                                                                                                                                    peg$currPos += 4;
+                                                                                                                                                                                                                                                                                                                                                  } else {
+                                                                                                                                                                                                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c878); }
+                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c876();
+                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                    if (input.substr(peg$currPos, 5) === peg$c879) {
+                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c879;
+                                                                                                                                                                                                                                                                                                                                                      peg$currPos += 5;
+                                                                                                                                                                                                                                                                                                                                                    } else {
+                                                                                                                                                                                                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c880); }
+                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c881();
+                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                      if (input.substr(peg$currPos, 5) === peg$c882) {
+                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c882;
+                                                                                                                                                                                                                                                                                                                                                        peg$currPos += 5;
+                                                                                                                                                                                                                                                                                                                                                      } else {
+                                                                                                                                                                                                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c883); }
+                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c881();
+                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                        if (input.substr(peg$currPos, 7) === peg$c884) {
+                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c884;
+                                                                                                                                                                                                                                                                                                                                                          peg$currPos += 7;
+                                                                                                                                                                                                                                                                                                                                                        } else {
+                                                                                                                                                                                                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c885); }
+                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c704();
+                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                          if (input.substr(peg$currPos, 7) === peg$c886) {
+                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c886;
+                                                                                                                                                                                                                                                                                                                                                            peg$currPos += 7;
+                                                                                                                                                                                                                                                                                                                                                          } else {
+                                                                                                                                                                                                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c887); }
+                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c704();
+                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                            if (input.substr(peg$currPos, 6) === peg$c888) {
+                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c888;
+                                                                                                                                                                                                                                                                                                                                                              peg$currPos += 6;
+                                                                                                                                                                                                                                                                                                                                                            } else {
+                                                                                                                                                                                                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c889); }
+                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c890();
+                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                              if (input.substr(peg$currPos, 6) === peg$c891) {
+                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c891;
+                                                                                                                                                                                                                                                                                                                                                                peg$currPos += 6;
+                                                                                                                                                                                                                                                                                                                                                              } else {
+                                                                                                                                                                                                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c892); }
+                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c890();
+                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                if (input.substr(peg$currPos, 16) === peg$c893) {
+                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c893;
+                                                                                                                                                                                                                                                                                                                                                                  peg$currPos += 16;
+                                                                                                                                                                                                                                                                                                                                                                } else {
+                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c894); }
+                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c895();
+                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                  if (input.substr(peg$currPos, 16) === peg$c896) {
+                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c896;
+                                                                                                                                                                                                                                                                                                                                                                    peg$currPos += 16;
+                                                                                                                                                                                                                                                                                                                                                                  } else {
+                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c897); }
+                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c895();
+                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                    if (input.substr(peg$currPos, 10) === peg$c898) {
+                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c898;
+                                                                                                                                                                                                                                                                                                                                                                      peg$currPos += 10;
+                                                                                                                                                                                                                                                                                                                                                                    } else {
+                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c899); }
+                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c900();
+                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                      if (input.substr(peg$currPos, 10) === peg$c901) {
+                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c901;
+                                                                                                                                                                                                                                                                                                                                                                        peg$currPos += 10;
+                                                                                                                                                                                                                                                                                                                                                                      } else {
+                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c902); }
+                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c900();
+                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                        if (input.substr(peg$currPos, 12) === peg$c903) {
+                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c903;
+                                                                                                                                                                                                                                                                                                                                                                          peg$currPos += 12;
+                                                                                                                                                                                                                                                                                                                                                                        } else {
+                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c904); }
+                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c905();
+                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                          if (input.substr(peg$currPos, 12) === peg$c906) {
+                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c906;
+                                                                                                                                                                                                                                                                                                                                                                            peg$currPos += 12;
+                                                                                                                                                                                                                                                                                                                                                                          } else {
+                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c907); }
+                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c905();
+                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                            if (input.substr(peg$currPos, 12) === peg$c908) {
+                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c908;
+                                                                                                                                                                                                                                                                                                                                                                              peg$currPos += 12;
+                                                                                                                                                                                                                                                                                                                                                                            } else {
+                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c909); }
+                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c910();
+                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                              if (input.substr(peg$currPos, 12) === peg$c911) {
+                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c911;
+                                                                                                                                                                                                                                                                                                                                                                                peg$currPos += 12;
+                                                                                                                                                                                                                                                                                                                                                                              } else {
+                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c912); }
+                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c910();
+                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                if (input.substr(peg$currPos, 14) === peg$c913) {
+                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c913;
+                                                                                                                                                                                                                                                                                                                                                                                  peg$currPos += 14;
+                                                                                                                                                                                                                                                                                                                                                                                } else {
+                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c914); }
+                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c915();
+                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                  if (input.substr(peg$currPos, 14) === peg$c916) {
+                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c916;
+                                                                                                                                                                                                                                                                                                                                                                                    peg$currPos += 14;
+                                                                                                                                                                                                                                                                                                                                                                                  } else {
+                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c917); }
+                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c915();
+                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                    if (input.substr(peg$currPos, 15) === peg$c918) {
+                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c918;
+                                                                                                                                                                                                                                                                                                                                                                                      peg$currPos += 15;
+                                                                                                                                                                                                                                                                                                                                                                                    } else {
+                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c919); }
+                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c920();
+                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                      if (input.substr(peg$currPos, 15) === peg$c921) {
+                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c921;
+                                                                                                                                                                                                                                                                                                                                                                                        peg$currPos += 15;
+                                                                                                                                                                                                                                                                                                                                                                                      } else {
+                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c922); }
+                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c920();
+                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                        if (input.substr(peg$currPos, 17) === peg$c923) {
+                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c923;
+                                                                                                                                                                                                                                                                                                                                                                                          peg$currPos += 17;
+                                                                                                                                                                                                                                                                                                                                                                                        } else {
+                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c924); }
+                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c925();
+                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                          if (input.substr(peg$currPos, 17) === peg$c926) {
+                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c926;
+                                                                                                                                                                                                                                                                                                                                                                                            peg$currPos += 17;
+                                                                                                                                                                                                                                                                                                                                                                                          } else {
+                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c927); }
+                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c925();
+                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                            if (input.substr(peg$currPos, 15) === peg$c928) {
+                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c928;
+                                                                                                                                                                                                                                                                                                                                                                                              peg$currPos += 15;
+                                                                                                                                                                                                                                                                                                                                                                                            } else {
+                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c929); }
+                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c930();
+                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                              if (input.substr(peg$currPos, 15) === peg$c931) {
+                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c931;
+                                                                                                                                                                                                                                                                                                                                                                                                peg$currPos += 15;
+                                                                                                                                                                                                                                                                                                                                                                                              } else {
+                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c932); }
+                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c930();
+                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                if (input.substr(peg$currPos, 15) === peg$c933) {
+                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c933;
+                                                                                                                                                                                                                                                                                                                                                                                                  peg$currPos += 15;
+                                                                                                                                                                                                                                                                                                                                                                                                } else {
+                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c934); }
+                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c935();
+                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                  if (input.substr(peg$currPos, 15) === peg$c936) {
+                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c936;
+                                                                                                                                                                                                                                                                                                                                                                                                    peg$currPos += 15;
+                                                                                                                                                                                                                                                                                                                                                                                                  } else {
+                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c937); }
+                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c935();
+                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                    if (input.substr(peg$currPos, 12) === peg$c938) {
+                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c938;
+                                                                                                                                                                                                                                                                                                                                                                                                      peg$currPos += 12;
+                                                                                                                                                                                                                                                                                                                                                                                                    } else {
+                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c939); }
+                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c940();
+                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                      if (input.substr(peg$currPos, 12) === peg$c941) {
+                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c941;
+                                                                                                                                                                                                                                                                                                                                                                                                        peg$currPos += 12;
+                                                                                                                                                                                                                                                                                                                                                                                                      } else {
+                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c942); }
+                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c940();
+                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                        if (input.substr(peg$currPos, 9) === peg$c943) {
+                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c943;
+                                                                                                                                                                                                                                                                                                                                                                                                          peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                                                                                        } else {
+                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c944); }
+                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c945();
+                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                          if (input.substr(peg$currPos, 9) === peg$c946) {
+                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c946;
+                                                                                                                                                                                                                                                                                                                                                                                                            peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                                                                                          } else {
+                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c947); }
+                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c945();
+                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                            if (input.substr(peg$currPos, 9) === peg$c948) {
+                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c948;
+                                                                                                                                                                                                                                                                                                                                                                                                              peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                                                                                            } else {
+                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c949); }
+                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c950();
+                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                              if (input.substr(peg$currPos, 9) === peg$c951) {
+                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c951;
+                                                                                                                                                                                                                                                                                                                                                                                                                peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                                                                                              } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c952); }
+                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c950();
+                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                if (input.substr(peg$currPos, 8) === peg$c953) {
+                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c953;
+                                                                                                                                                                                                                                                                                                                                                                                                                  peg$currPos += 8;
+                                                                                                                                                                                                                                                                                                                                                                                                                } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c954); }
+                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c955();
+                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                  if (input.substr(peg$currPos, 8) === peg$c956) {
+                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c956;
+                                                                                                                                                                                                                                                                                                                                                                                                                    peg$currPos += 8;
+                                                                                                                                                                                                                                                                                                                                                                                                                  } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c957); }
+                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c955();
+                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                    if (input.substr(peg$currPos, 11) === peg$c958) {
+                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c958;
+                                                                                                                                                                                                                                                                                                                                                                                                                      peg$currPos += 11;
+                                                                                                                                                                                                                                                                                                                                                                                                                    } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c959); }
+                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c960();
+                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                      if (input.substr(peg$currPos, 11) === peg$c961) {
+                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c961;
+                                                                                                                                                                                                                                                                                                                                                                                                                        peg$currPos += 11;
+                                                                                                                                                                                                                                                                                                                                                                                                                      } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c962); }
+                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c960();
+                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                        if (input.substr(peg$currPos, 4) === peg$c963) {
+                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c963;
+                                                                                                                                                                                                                                                                                                                                                                                                                          peg$currPos += 4;
+                                                                                                                                                                                                                                                                                                                                                                                                                        } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c964); }
+                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c965();
+                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                          if (input.substr(peg$currPos, 4) === peg$c966) {
+                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c966;
+                                                                                                                                                                                                                                                                                                                                                                                                                            peg$currPos += 4;
+                                                                                                                                                                                                                                                                                                                                                                                                                          } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c967); }
+                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c965();
+                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                            if (input.substr(peg$currPos, 7) === peg$c968) {
+                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c968;
+                                                                                                                                                                                                                                                                                                                                                                                                                              peg$currPos += 7;
+                                                                                                                                                                                                                                                                                                                                                                                                                            } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c969); }
+                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c970();
+                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                              if (input.substr(peg$currPos, 7) === peg$c971) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c971;
+                                                                                                                                                                                                                                                                                                                                                                                                                                peg$currPos += 7;
+                                                                                                                                                                                                                                                                                                                                                                                                                              } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c972); }
+                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c970();
+                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                if (input.substr(peg$currPos, 9) === peg$c973) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c973;
+                                                                                                                                                                                                                                                                                                                                                                                                                                  peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                                                                                                                } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c974); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c975();
+                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                  if (input.substr(peg$currPos, 9) === peg$c976) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c976;
+                                                                                                                                                                                                                                                                                                                                                                                                                                    peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                                                                                                                  } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c977); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c975();
+                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                    if (input.substr(peg$currPos, 5) === peg$c978) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c978;
+                                                                                                                                                                                                                                                                                                                                                                                                                                      peg$currPos += 5;
+                                                                                                                                                                                                                                                                                                                                                                                                                                    } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c979); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c980();
+                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                      if (input.substr(peg$currPos, 5) === peg$c981) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c981;
+                                                                                                                                                                                                                                                                                                                                                                                                                                        peg$currPos += 5;
+                                                                                                                                                                                                                                                                                                                                                                                                                                      } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c982); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c980();
+                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                        if (input.substr(peg$currPos, 9) === peg$c983) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c983;
+                                                                                                                                                                                                                                                                                                                                                                                                                                          peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                                                                                                                        } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c984); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c985();
+                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                          if (input.substr(peg$currPos, 9) === peg$c986) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c986;
+                                                                                                                                                                                                                                                                                                                                                                                                                                            peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                                                                                                                          } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c987); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c985();
+                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                            if (input.substr(peg$currPos, 6) === peg$c988) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c988;
+                                                                                                                                                                                                                                                                                                                                                                                                                                              peg$currPos += 6;
+                                                                                                                                                                                                                                                                                                                                                                                                                                            } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c989); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c990();
+                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                              if (input.substr(peg$currPos, 6) === peg$c991) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c991;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                peg$currPos += 6;
+                                                                                                                                                                                                                                                                                                                                                                                                                                              } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c992); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c990();
+                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                if (input.substr(peg$currPos, 6) === peg$c993) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c993;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                  peg$currPos += 6;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c994); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c995();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (input.substr(peg$currPos, 6) === peg$c996) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c996;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    peg$currPos += 6;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                  } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c997); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c995();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (input.substr(peg$currPos, 13) === peg$c998) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c998;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                      peg$currPos += 13;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c999); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c1000();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (input.substr(peg$currPos, 13) === peg$c1001) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c1001;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        peg$currPos += 13;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                      } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c1002); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c1000();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (input.substr(peg$currPos, 9) === peg$c1003) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c1003;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                          peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c1004); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c1005();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (input.substr(peg$currPos, 9) === peg$c1006) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c1006;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                          } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c1007); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c1005();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (input.substr(peg$currPos, 13) === peg$c1008) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c1008;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                              peg$currPos += 13;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c1009); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c1010();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (input.substr(peg$currPos, 13) === peg$c1011) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c1011;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                peg$currPos += 13;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                              } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c1012); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c1010();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (input.substr(peg$currPos, 13) === peg$c1013) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c1013;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                  peg$currPos += 13;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c1014); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c1015();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (input.substr(peg$currPos, 13) === peg$c1016) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c1016;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    peg$currPos += 13;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                  } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c1017); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c1015();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (input.substr(peg$currPos, 10) === peg$c1018) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c1018;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                      peg$currPos += 10;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c1019); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c1020();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (input.substr(peg$currPos, 10) === peg$c1021) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c1021;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        peg$currPos += 10;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                      } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c1022); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c1020();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (input.substr(peg$currPos, 9) === peg$c1023) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c1023;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                          peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c1024); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c1025();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (input.substr(peg$currPos, 9) === peg$c1026) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c1026;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                          } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c1027); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c1025();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (input.substr(peg$currPos, 4) === peg$c1028) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c1028;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                              peg$currPos += 4;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c1029); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c1030();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (input.substr(peg$currPos, 4) === peg$c1031) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c1031;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                peg$currPos += 4;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                              } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c1032); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c1030();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (input.substr(peg$currPos, 4) === peg$c1033) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c1033;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  peg$currPos += 4;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c1034); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c1035();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (input.substr(peg$currPos, 4) === peg$c1036) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c1036;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    peg$currPos += 4;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c1037); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c1035();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (input.substr(peg$currPos, 4) === peg$c1038) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c1038;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      peg$currPos += 4;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c1039); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c1040();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (input.substr(peg$currPos, 4) === peg$c1041) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c1041;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        peg$currPos += 4;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c1042); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c1040();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (input.substr(peg$currPos, 10) === peg$c1043) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c1043;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          peg$currPos += 10;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c1044); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c1045();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (input.substr(peg$currPos, 10) === peg$c1046) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c1046;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            peg$currPos += 10;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c1047); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c1045();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (input.substr(peg$currPos, 6) === peg$c1048) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c1048;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              peg$currPos += 6;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c1049); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c1050();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (input.substr(peg$currPos, 6) === peg$c1051) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c1051;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                peg$currPos += 6;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c1052); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c1050();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (input.substr(peg$currPos, 3) === peg$c1053) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c1053;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  peg$currPos += 3;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c1054); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c1055();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (input.substr(peg$currPos, 3) === peg$c1056) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c1056;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    peg$currPos += 3;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c1057); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c1055();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (input.substr(peg$currPos, 9) === peg$c1058) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c1058;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c1059); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c1060();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (input.substr(peg$currPos, 9) === peg$c1061) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c1061;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c1062); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c1060();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (input.substr(peg$currPos, 9) === peg$c1063) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c1063;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c1064); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c1065();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (input.substr(peg$currPos, 9) === peg$c1066) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c1066;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c1067); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c1065();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (input.substr(peg$currPos, 11) === peg$c1068) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c1068;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              peg$currPos += 11;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c1069); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c1070();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (input.substr(peg$currPos, 11) === peg$c1071) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c1071;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                peg$currPos += 11;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c1072); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c1070();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (input.substr(peg$currPos, 6) === peg$c1073) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c1073;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  peg$currPos += 6;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c1074); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c1075();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (input.substr(peg$currPos, 6) === peg$c1076) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c1076;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    peg$currPos += 6;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c1077); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c1075();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (input.substr(peg$currPos, 10) === peg$c1078) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c1078;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      peg$currPos += 10;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c1079); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c1080();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (input.substr(peg$currPos, 10) === peg$c1081) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c1081;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        peg$currPos += 10;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c1082); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c1080();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (input.substr(peg$currPos, 8) === peg$c1083) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c1083;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          peg$currPos += 8;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c1084); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c1085();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (input.substr(peg$currPos, 8) === peg$c1086) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c1086;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            peg$currPos += 8;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c1087); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c1085();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (input.substr(peg$currPos, 8) === peg$c1088) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c1088;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              peg$currPos += 8;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c1089); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c1090();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (input.substr(peg$currPos, 8) === peg$c1091) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c1091;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                peg$currPos += 8;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c1092); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c1090();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (input.substr(peg$currPos, 6) === peg$c1093) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c1093;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  peg$currPos += 6;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c1094); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c1095();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (input.substr(peg$currPos, 6) === peg$c1096) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c1096;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    peg$currPos += 6;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c1097); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c1095();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (input.substr(peg$currPos, 6) === peg$c1098) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c1098;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      peg$currPos += 6;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c1099); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c1100();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (input.substr(peg$currPos, 6) === peg$c1101) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c1101;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        peg$currPos += 6;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c1102); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c1100();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (input.substr(peg$currPos, 7) === peg$c1103) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c1103;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          peg$currPos += 7;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c1104); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c1105();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (input.substr(peg$currPos, 7) === peg$c1106) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c1106;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            peg$currPos += 7;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c1107); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c1105();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (input.substr(peg$currPos, 9) === peg$c1108) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c1108;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c1109); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c1110();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (input.substr(peg$currPos, 9) === peg$c1111) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c1111;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c1112); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c1110();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (input.substr(peg$currPos, 9) === peg$c1113) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c1113;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c1114); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c1115();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (input.substr(peg$currPos, 9) === peg$c1116) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c1116;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c1117); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c1115();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (input.substr(peg$currPos, 9) === peg$c1118) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c1118;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c1119); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c1115();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (input.substr(peg$currPos, 9) === peg$c1120) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c1120;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c1121); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c1115();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (input.substr(peg$currPos, 4) === peg$c1122) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c1122;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          peg$currPos += 4;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c1123); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c1124();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (input.substr(peg$currPos, 4) === peg$c1125) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c1125;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            peg$currPos += 4;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c1126); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c1124();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (input.substr(peg$currPos, 11) === peg$c1127) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c1127;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              peg$currPos += 11;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c1128); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c1129();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (input.substr(peg$currPos, 11) === peg$c1130) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c1130;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                peg$currPos += 11;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c1131); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c1129();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (input.substr(peg$currPos, 9) === peg$c1132) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c1132;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c1133); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c1134();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (input.substr(peg$currPos, 9) === peg$c1135) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c1135;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c1136); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c1134();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (input.substr(peg$currPos, 3) === peg$c1137) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c1137;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      peg$currPos += 3;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c1138); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c1139();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (input.substr(peg$currPos, 3) === peg$c1140) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c1140;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        peg$currPos += 3;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c1141); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c1139();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (input.substr(peg$currPos, 4) === peg$c1142) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c1142;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          peg$currPos += 4;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c1143); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c1144();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (input.substr(peg$currPos, 4) === peg$c1145) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c1145;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            peg$currPos += 4;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c1146); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c1144();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (input.substr(peg$currPos, 7) === peg$c1147) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c1147;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              peg$currPos += 7;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c1148); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c1149();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (input.substr(peg$currPos, 7) === peg$c1150) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c1150;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                peg$currPos += 7;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c1151); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c1149();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (input.substr(peg$currPos, 6) === peg$c1152) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c1152;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  peg$currPos += 6;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c1153); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c1154();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (input.substr(peg$currPos, 6) === peg$c1155) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c1155;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    peg$currPos += 6;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c1156); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c1154();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (input.substr(peg$currPos, 9) === peg$c1157) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c1157;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c1158); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c1159();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (input.substr(peg$currPos, 9) === peg$c1160) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c1160;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        peg$currPos += 9;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c1161); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c1159();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (input.substr(peg$currPos, 6) === peg$c1162) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c1162;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          peg$currPos += 6;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c1163); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c1164();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (input.substr(peg$currPos, 6) === peg$c1165) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c1165;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            peg$currPos += 6;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c1166); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c1164();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (input.substr(peg$currPos, 5) === peg$c1167) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c1167;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              peg$currPos += 5;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c1168); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c1169();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (input.substr(peg$currPos, 5) === peg$c1170) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c1170;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                peg$currPos += 5;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c1171); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c1169();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (input.substr(peg$currPos, 10) === peg$c1172) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c1172;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  peg$currPos += 10;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (peg$silentFails === 0) { peg$fail(peg$c1173); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s1 = peg$c1174();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (input.substr(peg$currPos, 10) === peg$c1175) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c1175;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    peg$currPos += 10;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (peg$silentFails === 0) { peg$fail(peg$c1176); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s1 = peg$c1174();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (input.substr(peg$currPos, 5) === peg$c1177) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c1177;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      peg$currPos += 5;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (peg$silentFails === 0) { peg$fail(peg$c1178); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s1 = peg$c1179();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (input.substr(peg$currPos, 5) === peg$c1180) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c1180;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        peg$currPos += 5;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (peg$silentFails === 0) { peg$fail(peg$c1181); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s1 = peg$c1179();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (input.substr(peg$currPos, 11) === peg$c1182) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c1182;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          peg$currPos += 11;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (peg$silentFails === 0) { peg$fail(peg$c1183); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s1 = peg$c1184();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (input.substr(peg$currPos, 11) === peg$c1185) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c1185;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            peg$currPos += 11;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (peg$silentFails === 0) { peg$fail(peg$c1186); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s1 = peg$c1184();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (input.substr(peg$currPos, 6) === peg$c1187) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c1187;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              peg$currPos += 6;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (peg$silentFails === 0) { peg$fail(peg$c1188); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s1 = peg$c1189();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (s0 === peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s0 = peg$currPos;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (input.substr(peg$currPos, 6) === peg$c1190) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c1190;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                peg$currPos += 6;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              } else {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$FAILED;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if (peg$silentFails === 0) { peg$fail(peg$c1191); }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (s1 !== peg$FAILED) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                peg$savedPos = s0;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s1 = peg$c1189();
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              s0 = s1;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                              }
+                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                          }
+                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                      }
+                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                  }
+                                                                                                                                                                                                                }
+                                                                                                                                                                                                              }
+                                                                                                                                                                                                            }
+                                                                                                                                                                                                          }
+                                                                                                                                                                                                        }
+                                                                                                                                                                                                      }
+                                                                                                                                                                                                    }
+                                                                                                                                                                                                  }
+                                                                                                                                                                                                }
+                                                                                                                                                                                              }
+                                                                                                                                                                                            }
+                                                                                                                                                                                          }
+                                                                                                                                                                                        }
+                                                                                                                                                                                      }
+                                                                                                                                                                                    }
+                                                                                                                                                                                  }
+                                                                                                                                                                                }
+                                                                                                                                                                              }
+                                                                                                                                                                            }
+                                                                                                                                                                          }
+                                                                                                                                                                        }
+                                                                                                                                                                      }
+                                                                                                                                                                    }
+                                                                                                                                                                  }
+                                                                                                                                                                }
+                                                                                                                                                              }
+                                                                                                                                                            }
+                                                                                                                                                          }
+                                                                                                                                                        }
+                                                                                                                                                      }
+                                                                                                                                                    }
+                                                                                                                                                  }
+                                                                                                                                                }
+                                                                                                                                              }
+                                                                                                                                            }
+                                                                                                                                          }
+                                                                                                                                        }
+                                                                                                                                      }
+                                                                                                                                    }
+                                                                                                                                  }
+                                                                                                                                }
+                                                                                                                              }
+                                                                                                                            }
+                                                                                                                          }
+                                                                                                                        }
+                                                                                                                      }
+                                                                                                                    }
+                                                                                                                  }
+                                                                                                                }
+                                                                                                              }
+                                                                                                            }
+                                                                                                          }
+                                                                                                        }
+                                                                                                      }
+                                                                                                    }
+                                                                                                  }
+                                                                                                }
+                                                                                              }
+                                                                                            }
+                                                                                          }
+                                                                                        }
+                                                                                      }
+                                                                                    }
+                                                                                  }
+                                                                                }
+                                                                              }
+                                                                            }
+                                                                          }
+                                                                        }
+                                                                      }
+                                                                    }
+                                                                  }
+                                                                }
+                                                              }
+                                                            }
+                                                          }
+                                                        }
+                                                      }
+                                                    }
+                                                  }
+                                                }
+                                              }
+                                            }
+                                          }
+                                        }
+                                      }
+                                    }
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseSvgColor() {
+    var s0, s1, s2;
+
+    s0 = peg$currPos;
+    s1 = peg$parseSvgColorLabel();
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseWS();
+      if (s2 === peg$FAILED) {
+        s2 = null;
+      }
+      if (s2 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c1192(s1);
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseRgb3() {
+    var s0, s1, s2, s3, s4, s5;
+
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 35) {
+      s1 = peg$c1193;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1194); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseHexDigit();
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseHexDigit();
+        if (s3 !== peg$FAILED) {
+          s4 = peg$parseHexDigit();
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              peg$savedPos = s0;
+              s1 = peg$c1195(s2, s3, s4);
+              s0 = s1;
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseRgb6() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8;
+
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 35) {
+      s1 = peg$c1193;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1194); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseHexDigit();
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseHexDigit();
+        if (s3 !== peg$FAILED) {
+          s4 = peg$parseHexDigit();
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseHexDigit();
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseHexDigit();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseHexDigit();
+                if (s7 !== peg$FAILED) {
+                  s8 = peg$parseWS();
+                  if (s8 === peg$FAILED) {
+                    s8 = null;
+                  }
+                  if (s8 !== peg$FAILED) {
+                    peg$savedPos = s0;
+                    s1 = peg$c1196(s2, s3, s4, s5, s6, s7);
+                    s0 = s1;
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseRgba4() {
+    var s0, s1, s2, s3, s4, s5, s6;
+
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 35) {
+      s1 = peg$c1193;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1194); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseHexDigit();
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseHexDigit();
+        if (s3 !== peg$FAILED) {
+          s4 = peg$parseHexDigit();
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseHexDigit();
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseWS();
+              if (s6 === peg$FAILED) {
+                s6 = null;
+              }
+              if (s6 !== peg$FAILED) {
+                peg$savedPos = s0;
+                s1 = peg$c1197(s2, s3, s4, s5);
+                s0 = s1;
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseRgba8() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
+
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 35) {
+      s1 = peg$c1193;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1194); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseHexDigit();
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseHexDigit();
+        if (s3 !== peg$FAILED) {
+          s4 = peg$parseHexDigit();
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseHexDigit();
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseHexDigit();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseHexDigit();
+                if (s7 !== peg$FAILED) {
+                  s8 = peg$parseHexDigit();
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseHexDigit();
+                    if (s9 !== peg$FAILED) {
+                      s10 = peg$parseWS();
+                      if (s10 === peg$FAILED) {
+                        s10 = null;
+                      }
+                      if (s10 !== peg$FAILED) {
+                        peg$savedPos = s0;
+                        s1 = peg$c1198(s2, s3, s4, s5, s6, s7, s8, s9);
+                        s0 = s1;
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseColor() {
+    var s0, s1;
+
+    peg$silentFails++;
+    s0 = peg$parseSvgColor();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseRgba8();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parseRgb6();
+        if (s0 === peg$FAILED) {
+          s0 = peg$parseRgba4();
+          if (s0 === peg$FAILED) {
+            s0 = peg$parseRgb3();
+          }
+        }
+      }
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1199); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseArrowItemKey() {
+    var s0;
+
+    if (input.substr(peg$currPos, 9) === peg$c1200) {
+      s0 = peg$c1200;
+      peg$currPos += 9;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1201); }
+    }
+    if (s0 === peg$FAILED) {
+      if (input.substr(peg$currPos, 10) === peg$c1202) {
+        s0 = peg$c1202;
+        peg$currPos += 10;
+      } else {
+        s0 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1203); }
+      }
+      if (s0 === peg$FAILED) {
+        if (input.substr(peg$currPos, 10) === peg$c1204) {
+          s0 = peg$c1204;
+          peg$currPos += 10;
+        } else {
+          s0 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$c1205); }
+        }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseArrowItem() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseArrowItemKey();
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseLabel();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1210(s2, s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseSingleEdgeColor() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    peg$silentFails++;
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 10) === peg$c1212) {
+        s2 = peg$c1212;
+        peg$currPos += 10;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1213); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseColor();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1214(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1211); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseTransitionLineStyle() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    peg$silentFails++;
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 10) === peg$c1216) {
+        s2 = peg$c1216;
+        peg$currPos += 10;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1217); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseLineStyle();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1218(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1215); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseArrowItems() {
+    var s0, s1;
+
+    s0 = peg$parseSingleEdgeColor();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseTransitionLineStyle();
+      if (s0 === peg$FAILED) {
+        s0 = [];
+        s1 = peg$parseArrowItem();
+        if (s1 !== peg$FAILED) {
+          while (s1 !== peg$FAILED) {
+            s0.push(s1);
+            s1 = peg$parseArrowItem();
+          }
+        } else {
+          s0 = peg$FAILED;
+        }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseArrowDesc() {
+    var s0, s1, s2, s3, s4, s5;
+
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 123) {
+      s1 = peg$c1219;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1220); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseWS();
+      if (s2 === peg$FAILED) {
+        s2 = null;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseArrowItems();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          s4 = peg$parseWS();
+          if (s4 === peg$FAILED) {
+            s4 = null;
+          }
+          if (s4 !== peg$FAILED) {
+            if (input.charCodeAt(peg$currPos) === 125) {
+              s5 = peg$c1221;
+              peg$currPos++;
+            } else {
+              s5 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$c1222); }
+            }
+            if (s5 !== peg$FAILED) {
+              peg$savedPos = s0;
+              s1 = peg$c1223(s3);
+              s0 = s1;
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseArrowProbability() {
+    var s0, s1, s2;
+
+    s0 = peg$currPos;
+    s1 = peg$parseNonNegNumber();
+    if (s1 !== peg$FAILED) {
+      if (input.charCodeAt(peg$currPos) === 37) {
+        s2 = peg$c1224;
+        peg$currPos++;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1225); }
+      }
+      if (s2 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c1226(s1);
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseLabelList() {
+    var s0, s1, s2, s3, s4, s5, s6;
+
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 91) {
+      s1 = peg$c11;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c12); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseWS();
+      if (s2 === peg$FAILED) {
+        s2 = null;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = [];
+        s4 = peg$currPos;
+        s5 = peg$parseLabel();
+        if (s5 !== peg$FAILED) {
+          s6 = peg$parseWS();
+          if (s6 === peg$FAILED) {
+            s6 = null;
+          }
+          if (s6 !== peg$FAILED) {
+            s5 = [s5, s6];
+            s4 = s5;
+          } else {
+            peg$currPos = s4;
+            s4 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s4;
+          s4 = peg$FAILED;
+        }
+        while (s4 !== peg$FAILED) {
+          s3.push(s4);
+          s4 = peg$currPos;
+          s5 = peg$parseLabel();
+          if (s5 !== peg$FAILED) {
+            s6 = peg$parseWS();
+            if (s6 === peg$FAILED) {
+              s6 = null;
+            }
+            if (s6 !== peg$FAILED) {
+              s5 = [s5, s6];
+              s4 = s5;
+            } else {
+              peg$currPos = s4;
+              s4 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s4;
+            s4 = peg$FAILED;
+          }
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 93) {
+            s4 = peg$c13;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c14); }
+          }
+          if (s4 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s1 = peg$c1227(s3);
+            s0 = s1;
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseLabelOrLabelList() {
+    var s0;
+
+    s0 = peg$parseLabelList();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseLabel();
+    }
+
+    return s0;
+  }
+
+  function peg$parseStripe() {
+    var s0, s1, s2, s3, s4;
+
+    s0 = peg$currPos;
+    if (input.substr(peg$currPos, 2) === peg$c1228) {
+      s1 = peg$c1228;
+      peg$currPos += 2;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1229); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseNonZeroDigit();
+      if (s2 !== peg$FAILED) {
+        s3 = [];
+        s4 = peg$parseDecimalDigit();
+        while (s4 !== peg$FAILED) {
+          s3.push(s4);
+          s4 = peg$parseDecimalDigit();
+        }
+        if (s3 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s1 = peg$c1230(s2, s3);
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 2) === peg$c1231) {
+        s1 = peg$c1231;
+        peg$currPos += 2;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1232); }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$parseNonZeroDigit();
+        if (s2 !== peg$FAILED) {
+          s3 = [];
+          s4 = peg$parseDecimalDigit();
+          while (s4 !== peg$FAILED) {
+            s3.push(s4);
+            s4 = peg$parseDecimalDigit();
+          }
+          if (s3 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s1 = peg$c1233(s2, s3);
+            s0 = s1;
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseCycle() {
+    var s0, s1, s2, s3, s4;
+
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 43) {
+      s1 = peg$c1234;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1235); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseNonZeroDigit();
+      if (s2 !== peg$FAILED) {
+        s3 = [];
+        s4 = peg$parseDecimalDigit();
+        while (s4 !== peg$FAILED) {
+          s3.push(s4);
+          s4 = peg$parseDecimalDigit();
+        }
+        if (s3 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s1 = peg$c1236(s2, s3);
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 45) {
+        s1 = peg$c1237;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1238); }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$parseNonZeroDigit();
+        if (s2 !== peg$FAILED) {
+          s3 = [];
+          s4 = peg$parseDecimalDigit();
+          while (s4 !== peg$FAILED) {
+            s3.push(s4);
+            s4 = peg$parseDecimalDigit();
+          }
+          if (s3 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s1 = peg$c1239(s2, s3);
+            s0 = s1;
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        if (input.substr(peg$currPos, 2) === peg$c1240) {
+          s1 = peg$c1240;
+          peg$currPos += 2;
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$c1241); }
+        }
+        if (s1 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s1 = peg$c1242();
+        }
+        s0 = s1;
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseArrowTarget() {
+    var s0;
+
+    s0 = peg$parseStripe();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseCycle();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parseLabelList();
+        if (s0 === peg$FAILED) {
+          s0 = peg$parseLabel();
+        }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseSubexp() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseActionLabel();
+      if (s2 === peg$FAILED) {
+        s2 = null;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          s4 = peg$parseArrowProbability();
+          if (s4 === peg$FAILED) {
+            s4 = null;
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseArrowDesc();
+              if (s6 === peg$FAILED) {
+                s6 = null;
+              }
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  s8 = peg$parseArrow();
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      s10 = peg$parseArrowDesc();
+                      if (s10 === peg$FAILED) {
+                        s10 = null;
+                      }
+                      if (s10 !== peg$FAILED) {
+                        s11 = peg$parseWS();
+                        if (s11 === peg$FAILED) {
+                          s11 = null;
+                        }
+                        if (s11 !== peg$FAILED) {
+                          s12 = peg$parseArrowProbability();
+                          if (s12 === peg$FAILED) {
+                            s12 = null;
+                          }
+                          if (s12 !== peg$FAILED) {
+                            s13 = peg$parseWS();
+                            if (s13 === peg$FAILED) {
+                              s13 = null;
+                            }
+                            if (s13 !== peg$FAILED) {
+                              s14 = peg$parseActionLabel();
+                              if (s14 === peg$FAILED) {
+                                s14 = null;
+                              }
+                              if (s14 !== peg$FAILED) {
+                                s15 = peg$parseWS();
+                                if (s15 === peg$FAILED) {
+                                  s15 = null;
+                                }
+                                if (s15 !== peg$FAILED) {
+                                  s16 = peg$parseArrowTarget();
+                                  if (s16 !== peg$FAILED) {
+                                    s17 = peg$parseWS();
+                                    if (s17 === peg$FAILED) {
+                                      s17 = null;
+                                    }
+                                    if (s17 !== peg$FAILED) {
+                                      s18 = peg$parseSubexp();
+                                      if (s18 === peg$FAILED) {
+                                        s18 = null;
+                                      }
+                                      if (s18 !== peg$FAILED) {
+                                        peg$savedPos = s0;
+                                        s1 = peg$c1243(s2, s4, s6, s8, s10, s12, s14, s16, s18);
+                                        s0 = s1;
+                                      } else {
+                                        peg$currPos = s0;
+                                        s0 = peg$FAILED;
+                                      }
+                                    } else {
+                                      peg$currPos = s0;
+                                      s0 = peg$FAILED;
+                                    }
+                                  } else {
+                                    peg$currPos = s0;
+                                    s0 = peg$FAILED;
+                                  }
+                                } else {
+                                  peg$currPos = s0;
+                                  s0 = peg$FAILED;
+                                }
+                              } else {
+                                peg$currPos = s0;
+                                s0 = peg$FAILED;
+                              }
+                            } else {
+                              peg$currPos = s0;
+                              s0 = peg$FAILED;
+                            }
+                          } else {
+                            peg$currPos = s0;
+                            s0 = peg$FAILED;
+                          }
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseExp() {
+    var s0, s1, s2, s3, s4, s5;
+
+    s0 = peg$currPos;
+    s1 = peg$parseArrowTarget();
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseSubexp();
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 59) {
+            s4 = peg$c1208;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              peg$savedPos = s0;
+              s1 = peg$c1244(s1, s2);
+              s0 = s1;
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseValidationKey() {
+    var s0;
+
+    if (input.substr(peg$currPos, 9) === peg$c1245) {
+      s0 = peg$c1245;
+      peg$currPos += 9;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1246); }
+    }
+    if (s0 === peg$FAILED) {
+      if (input.substr(peg$currPos, 4) === peg$c1247) {
+        s0 = peg$c1247;
+        peg$currPos += 4;
+      } else {
+        s0 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1248); }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseValidationItem() {
+    var s0, s1, s2, s3, s4;
+
+    s0 = peg$currPos;
+    s1 = peg$parseValidationKey();
+    if (s1 !== peg$FAILED) {
+      if (input.charCodeAt(peg$currPos) === 58) {
+        s2 = peg$c1206;
+        peg$currPos++;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseLabel();
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 59) {
+            s4 = peg$c1208;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+          }
+          if (s4 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s1 = peg$c1249(s1, s3);
+            s0 = s1;
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseValidationItems() {
+    var s0, s1;
+
+    s0 = [];
+    s1 = peg$parseValidationItem();
+    if (s1 !== peg$FAILED) {
+      while (s1 !== peg$FAILED) {
+        s0.push(s1);
+        s1 = peg$parseValidationItem();
+      }
+    } else {
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseConfigValidation() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 10) === peg$c1250) {
+        s2 = peg$c1250;
+        peg$currPos += 10;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1251); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              if (input.charCodeAt(peg$currPos) === 123) {
+                s6 = peg$c1219;
+                peg$currPos++;
+              } else {
+                s6 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$c1220); }
+              }
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  s8 = peg$parseValidationItems();
+                  if (s8 === peg$FAILED) {
+                    s8 = null;
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      if (input.substr(peg$currPos, 2) === peg$c1252) {
+                        s10 = peg$c1252;
+                        peg$currPos += 2;
+                      } else {
+                        s10 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$c1253); }
+                      }
+                      if (s10 !== peg$FAILED) {
+                        s11 = peg$parseWS();
+                        if (s11 === peg$FAILED) {
+                          s11 = null;
+                        }
+                        if (s11 !== peg$FAILED) {
+                          peg$savedPos = s0;
+                          s1 = peg$c1254(s8);
+                          s0 = s1;
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseGvizLayout() {
+    var s0;
+
+    if (input.substr(peg$currPos, 3) === peg$c1255) {
+      s0 = peg$c1255;
+      peg$currPos += 3;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1256); }
+    }
+    if (s0 === peg$FAILED) {
+      if (input.substr(peg$currPos, 5) === peg$c1257) {
+        s0 = peg$c1257;
+        peg$currPos += 5;
+      } else {
+        s0 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1258); }
+      }
+      if (s0 === peg$FAILED) {
+        if (input.substr(peg$currPos, 3) === peg$c1259) {
+          s0 = peg$c1259;
+          peg$currPos += 3;
+        } else {
+          s0 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$c1260); }
+        }
+        if (s0 === peg$FAILED) {
+          if (input.substr(peg$currPos, 5) === peg$c1261) {
+            s0 = peg$c1261;
+            peg$currPos += 5;
+          } else {
+            s0 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1262); }
+          }
+        }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseStateItems() {
+    var s0, s1;
+
+    s0 = [];
+    s1 = peg$parseStateDeclarationItem();
+    if (s1 !== peg$FAILED) {
+      while (s1 !== peg$FAILED) {
+        s0.push(s1);
+        s1 = peg$parseStateDeclarationItem();
+      }
+    } else {
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseConfigState() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 5) === peg$c1263) {
+        s2 = peg$c1263;
+        peg$currPos += 5;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1264); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              if (input.charCodeAt(peg$currPos) === 123) {
+                s6 = peg$c1219;
+                peg$currPos++;
+              } else {
+                s6 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$c1220); }
+              }
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  s8 = peg$parseStateItems();
+                  if (s8 === peg$FAILED) {
+                    s8 = null;
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      if (input.substr(peg$currPos, 2) === peg$c1252) {
+                        s10 = peg$c1252;
+                        peg$currPos += 2;
+                      } else {
+                        s10 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$c1253); }
+                      }
+                      if (s10 !== peg$FAILED) {
+                        s11 = peg$parseWS();
+                        if (s11 === peg$FAILED) {
+                          s11 = null;
+                        }
+                        if (s11 !== peg$FAILED) {
+                          peg$savedPos = s0;
+                          s1 = peg$c1265(s8);
+                          s0 = s1;
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseConfigStartState() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 11) === peg$c1266) {
+        s2 = peg$c1266;
+        peg$currPos += 11;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1267); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              if (input.charCodeAt(peg$currPos) === 123) {
+                s6 = peg$c1219;
+                peg$currPos++;
+              } else {
+                s6 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$c1220); }
+              }
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  s8 = peg$parseStateItems();
+                  if (s8 === peg$FAILED) {
+                    s8 = null;
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      if (input.substr(peg$currPos, 2) === peg$c1252) {
+                        s10 = peg$c1252;
+                        peg$currPos += 2;
+                      } else {
+                        s10 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$c1253); }
+                      }
+                      if (s10 !== peg$FAILED) {
+                        s11 = peg$parseWS();
+                        if (s11 === peg$FAILED) {
+                          s11 = null;
+                        }
+                        if (s11 !== peg$FAILED) {
+                          peg$savedPos = s0;
+                          s1 = peg$c1268(s8);
+                          s0 = s1;
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseConfigEndState() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 9) === peg$c1269) {
+        s2 = peg$c1269;
+        peg$currPos += 9;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1270); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              if (input.charCodeAt(peg$currPos) === 123) {
+                s6 = peg$c1219;
+                peg$currPos++;
+              } else {
+                s6 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$c1220); }
+              }
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  s8 = peg$parseStateItems();
+                  if (s8 === peg$FAILED) {
+                    s8 = null;
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      if (input.substr(peg$currPos, 2) === peg$c1252) {
+                        s10 = peg$c1252;
+                        peg$currPos += 2;
+                      } else {
+                        s10 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$c1253); }
+                      }
+                      if (s10 !== peg$FAILED) {
+                        s11 = peg$parseWS();
+                        if (s11 === peg$FAILED) {
+                          s11 = null;
+                        }
+                        if (s11 !== peg$FAILED) {
+                          peg$savedPos = s0;
+                          s1 = peg$c1271(s8);
+                          s0 = s1;
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseConfigActiveState() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 12) === peg$c1272) {
+        s2 = peg$c1272;
+        peg$currPos += 12;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1273); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              if (input.charCodeAt(peg$currPos) === 123) {
+                s6 = peg$c1219;
+                peg$currPos++;
+              } else {
+                s6 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$c1220); }
+              }
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  s8 = peg$parseStateItems();
+                  if (s8 === peg$FAILED) {
+                    s8 = null;
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      if (input.substr(peg$currPos, 2) === peg$c1252) {
+                        s10 = peg$c1252;
+                        peg$currPos += 2;
+                      } else {
+                        s10 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$c1253); }
+                      }
+                      if (s10 !== peg$FAILED) {
+                        s11 = peg$parseWS();
+                        if (s11 === peg$FAILED) {
+                          s11 = null;
+                        }
+                        if (s11 !== peg$FAILED) {
+                          peg$savedPos = s0;
+                          s1 = peg$c1274(s8);
+                          s0 = s1;
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseConfigTerminalState() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 14) === peg$c1275) {
+        s2 = peg$c1275;
+        peg$currPos += 14;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1276); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              if (input.charCodeAt(peg$currPos) === 123) {
+                s6 = peg$c1219;
+                peg$currPos++;
+              } else {
+                s6 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$c1220); }
+              }
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  s8 = peg$parseStateItems();
+                  if (s8 === peg$FAILED) {
+                    s8 = null;
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      if (input.substr(peg$currPos, 2) === peg$c1252) {
+                        s10 = peg$c1252;
+                        peg$currPos += 2;
+                      } else {
+                        s10 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$c1253); }
+                      }
+                      if (s10 !== peg$FAILED) {
+                        s11 = peg$parseWS();
+                        if (s11 === peg$FAILED) {
+                          s11 = null;
+                        }
+                        if (s11 !== peg$FAILED) {
+                          peg$savedPos = s0;
+                          s1 = peg$c1277(s8);
+                          s0 = s1;
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseConfigHookedState() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 12) === peg$c1278) {
+        s2 = peg$c1278;
+        peg$currPos += 12;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1279); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              if (input.charCodeAt(peg$currPos) === 123) {
+                s6 = peg$c1219;
+                peg$currPos++;
+              } else {
+                s6 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$c1220); }
+              }
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  s8 = peg$parseStateItems();
+                  if (s8 === peg$FAILED) {
+                    s8 = null;
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      if (input.substr(peg$currPos, 2) === peg$c1252) {
+                        s10 = peg$c1252;
+                        peg$currPos += 2;
+                      } else {
+                        s10 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$c1253); }
+                      }
+                      if (s10 !== peg$FAILED) {
+                        s11 = peg$parseWS();
+                        if (s11 === peg$FAILED) {
+                          s11 = null;
+                        }
+                        if (s11 !== peg$FAILED) {
+                          peg$savedPos = s0;
+                          s1 = peg$c1280(s8);
+                          s0 = s1;
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseConfigAnyState() {
+    var s0;
+
+    s0 = peg$parseConfigState();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseConfigStartState();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parseConfigEndState();
+        if (s0 === peg$FAILED) {
+          s0 = peg$parseConfigActiveState();
+          if (s0 === peg$FAILED) {
+            s0 = peg$parseConfigTerminalState();
+            if (s0 === peg$FAILED) {
+              s0 = peg$parseConfigHookedState();
+            }
+          }
+        }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseActionKey() {
+    var s0;
+
+    if (input.substr(peg$currPos, 9) === peg$c1245) {
+      s0 = peg$c1245;
+      peg$currPos += 9;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1246); }
+    }
+    if (s0 === peg$FAILED) {
+      if (input.substr(peg$currPos, 4) === peg$c1247) {
+        s0 = peg$c1247;
+        peg$currPos += 4;
+      } else {
+        s0 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1248); }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseActionItem() {
+    var s0, s1, s2, s3, s4;
+
+    s0 = peg$currPos;
+    s1 = peg$parseActionKey();
+    if (s1 !== peg$FAILED) {
+      if (input.charCodeAt(peg$currPos) === 58) {
+        s2 = peg$c1206;
+        peg$currPos++;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseLabel();
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 59) {
+            s4 = peg$c1208;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+          }
+          if (s4 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s1 = peg$c1281(s1, s3);
+            s0 = s1;
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseActionItems() {
+    var s0, s1;
+
+    s0 = [];
+    s1 = peg$parseActionItem();
+    if (s1 !== peg$FAILED) {
+      while (s1 !== peg$FAILED) {
+        s0.push(s1);
+        s1 = peg$parseActionItem();
+      }
+    } else {
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseConfigAction() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 6) === peg$c1282) {
+        s2 = peg$c1282;
+        peg$currPos += 6;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1283); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              if (input.charCodeAt(peg$currPos) === 123) {
+                s6 = peg$c1219;
+                peg$currPos++;
+              } else {
+                s6 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$c1220); }
+              }
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  s8 = peg$parseActionItems();
+                  if (s8 === peg$FAILED) {
+                    s8 = null;
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      if (input.substr(peg$currPos, 2) === peg$c1252) {
+                        s10 = peg$c1252;
+                        peg$currPos += 2;
+                      } else {
+                        s10 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$c1253); }
+                      }
+                      if (s10 !== peg$FAILED) {
+                        s11 = peg$parseWS();
+                        if (s11 === peg$FAILED) {
+                          s11 = null;
+                        }
+                        if (s11 !== peg$FAILED) {
+                          peg$savedPos = s0;
+                          s1 = peg$c1284(s8);
+                          s0 = s1;
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseTransitionKey() {
+    var s0;
+
+    if (input.substr(peg$currPos, 9) === peg$c1245) {
+      s0 = peg$c1245;
+      peg$currPos += 9;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1246); }
+    }
+    if (s0 === peg$FAILED) {
+      if (input.substr(peg$currPos, 4) === peg$c1247) {
+        s0 = peg$c1247;
+        peg$currPos += 4;
+      } else {
+        s0 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1248); }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseTransitionItem() {
+    var s0, s1, s2, s3, s4;
+
+    s0 = peg$currPos;
+    s1 = peg$parseTransitionKey();
+    if (s1 !== peg$FAILED) {
+      if (input.charCodeAt(peg$currPos) === 58) {
+        s2 = peg$c1206;
+        peg$currPos++;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseLabel();
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 59) {
+            s4 = peg$c1208;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+          }
+          if (s4 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s1 = peg$c1285(s1, s3);
+            s0 = s1;
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseTransitionItems() {
+    var s0, s1;
+
+    s0 = peg$parseGraphDefaultEdgeColor();
+    if (s0 === peg$FAILED) {
+      s0 = [];
+      s1 = peg$parseTransitionItem();
+      if (s1 !== peg$FAILED) {
+        while (s1 !== peg$FAILED) {
+          s0.push(s1);
+          s1 = peg$parseTransitionItem();
+        }
+      } else {
+        s0 = peg$FAILED;
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseGraphDefaultEdgeColor() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    peg$silentFails++;
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 10) === peg$c1212) {
+        s2 = peg$c1212;
+        peg$currPos += 10;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1213); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseColor();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1287(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1286); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseConfigTransition() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 10) === peg$c1288) {
+        s2 = peg$c1288;
+        peg$currPos += 10;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1289); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              if (input.charCodeAt(peg$currPos) === 123) {
+                s6 = peg$c1219;
+                peg$currPos++;
+              } else {
+                s6 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$c1220); }
+              }
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  s8 = peg$parseTransitionItems();
+                  if (s8 === peg$FAILED) {
+                    s8 = null;
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      if (input.substr(peg$currPos, 2) === peg$c1252) {
+                        s10 = peg$c1252;
+                        peg$currPos += 2;
+                      } else {
+                        s10 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$c1253); }
+                      }
+                      if (s10 !== peg$FAILED) {
+                        s11 = peg$parseWS();
+                        if (s11 === peg$FAILED) {
+                          s11 = null;
+                        }
+                        if (s11 !== peg$FAILED) {
+                          peg$savedPos = s0;
+                          s1 = peg$c1290(s8);
+                          s0 = s1;
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseConfigGraphLayout() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 12) === peg$c1291) {
+        s2 = peg$c1291;
+        peg$currPos += 12;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1292); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseGvizLayout();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1293(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseConfigStartNodes() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 12) === peg$c1294) {
+        s2 = peg$c1294;
+        peg$currPos += 12;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1295); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseLabelList();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1296(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseConfigEndNodes() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 10) === peg$c1297) {
+        s2 = peg$c1297;
+        peg$currPos += 10;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1298); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseLabelList();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1299(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseConfigGraphBgColor() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 14) === peg$c1300) {
+        s2 = peg$c1300;
+        peg$currPos += 14;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1301); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseColor();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1302(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseConfigAllowsOverride() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 15) === peg$c1303) {
+        s2 = peg$c1303;
+        peg$currPos += 15;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1304); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseOverrideT();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1305(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseOverrideT() {
+    var s0, s1;
+
+    s0 = peg$currPos;
+    if (input.substr(peg$currPos, 4) === peg$c230) {
+      s1 = peg$c230;
+      peg$currPos += 4;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c231); }
+    }
+    if (s1 !== peg$FAILED) {
+      peg$savedPos = s0;
+      s1 = peg$c1306();
+    }
+    s0 = s1;
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 5) === peg$c233) {
+        s1 = peg$c233;
+        peg$currPos += 5;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c234); }
+      }
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c1307();
+      }
+      s0 = s1;
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        if (input.substr(peg$currPos, 9) === peg$c279) {
+          s1 = peg$c279;
+          peg$currPos += 9;
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$c280); }
+        }
+        if (s1 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s1 = peg$c281();
+        }
+        s0 = s1;
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseConfig() {
+    var s0, s1;
+
+    peg$silentFails++;
+    s0 = peg$parseConfigGraphLayout();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseConfigStartNodes();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parseConfigEndNodes();
+        if (s0 === peg$FAILED) {
+          s0 = peg$parseConfigTransition();
+          if (s0 === peg$FAILED) {
+            s0 = peg$parseConfigAction();
+            if (s0 === peg$FAILED) {
+              s0 = peg$parseConfigAnyState();
+              if (s0 === peg$FAILED) {
+                s0 = peg$parseConfigValidation();
+                if (s0 === peg$FAILED) {
+                  s0 = peg$parseConfigGraphBgColor();
+                  if (s0 === peg$FAILED) {
+                    s0 = peg$parseConfigAllowsOverride();
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1308); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseLicenseOrLabelOrList() {
+    var s0;
+
+    if (input.substr(peg$currPos, 3) === peg$c1309) {
+      s0 = peg$c1309;
+      peg$currPos += 3;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1310); }
+    }
+    if (s0 === peg$FAILED) {
+      if (input.substr(peg$currPos, 12) === peg$c1311) {
+        s0 = peg$c1311;
+        peg$currPos += 12;
+      } else {
+        s0 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1312); }
+      }
+      if (s0 === peg$FAILED) {
+        if (input.substr(peg$currPos, 12) === peg$c1313) {
+          s0 = peg$c1313;
+          peg$currPos += 12;
+        } else {
+          s0 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$c1314); }
+        }
+        if (s0 === peg$FAILED) {
+          if (input.substr(peg$currPos, 10) === peg$c1315) {
+            s0 = peg$c1315;
+            peg$currPos += 10;
+          } else {
+            s0 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1316); }
+          }
+          if (s0 === peg$FAILED) {
+            if (input.substr(peg$currPos, 11) === peg$c1317) {
+              s0 = peg$c1317;
+              peg$currPos += 11;
+            } else {
+              s0 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$c1318); }
+            }
+            if (s0 === peg$FAILED) {
+              if (input.substr(peg$currPos, 13) === peg$c1319) {
+                s0 = peg$c1319;
+                peg$currPos += 13;
+              } else {
+                s0 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$c1320); }
+              }
+              if (s0 === peg$FAILED) {
+                if (input.substr(peg$currPos, 6) === peg$c1321) {
+                  s0 = peg$c1321;
+                  peg$currPos += 6;
+                } else {
+                  s0 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$c1322); }
+                }
+                if (s0 === peg$FAILED) {
+                  if (input.substr(peg$currPos, 6) === peg$c1323) {
+                    s0 = peg$c1323;
+                    peg$currPos += 6;
+                  } else {
+                    s0 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1324); }
+                  }
+                  if (s0 === peg$FAILED) {
+                    if (input.substr(peg$currPos, 9) === peg$c1325) {
+                      s0 = peg$c1325;
+                      peg$currPos += 9;
+                    } else {
+                      s0 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$c1326); }
+                    }
+                    if (s0 === peg$FAILED) {
+                      if (input.substr(peg$currPos, 9) === peg$c1327) {
+                        s0 = peg$c1327;
+                        peg$currPos += 9;
+                      } else {
+                        s0 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$c1328); }
+                      }
+                      if (s0 === peg$FAILED) {
+                        if (input.substr(peg$currPos, 7) === peg$c1329) {
+                          s0 = peg$c1329;
+                          peg$currPos += 7;
+                        } else {
+                          s0 = peg$FAILED;
+                          if (peg$silentFails === 0) { peg$fail(peg$c1330); }
+                        }
+                        if (s0 === peg$FAILED) {
+                          s0 = peg$parseLabel();
+                          if (s0 === peg$FAILED) {
+                            s0 = peg$parseLabelList();
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseDirection() {
+    var s0, s1;
+
+    peg$silentFails++;
+    if (input.substr(peg$currPos, 2) === peg$c1332) {
+      s0 = peg$c1332;
+      peg$currPos += 2;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1333); }
+    }
+    if (s0 === peg$FAILED) {
+      if (input.substr(peg$currPos, 5) === peg$c1334) {
+        s0 = peg$c1334;
+        peg$currPos += 5;
+      } else {
+        s0 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1335); }
+      }
+      if (s0 === peg$FAILED) {
+        if (input.substr(peg$currPos, 4) === peg$c1336) {
+          s0 = peg$c1336;
+          peg$currPos += 4;
+        } else {
+          s0 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$c1337); }
+        }
+        if (s0 === peg$FAILED) {
+          if (input.substr(peg$currPos, 4) === peg$c1338) {
+            s0 = peg$c1338;
+            peg$currPos += 4;
+          } else {
+            s0 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1339); }
+          }
+        }
+      }
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1331); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseHookDefinition() {
+    var s0, s1;
+
+    peg$silentFails++;
+    if (input.substr(peg$currPos, 4) === peg$c1341) {
+      s0 = peg$c1341;
+      peg$currPos += 4;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1342); }
+    }
+    if (s0 === peg$FAILED) {
+      if (input.substr(peg$currPos, 6) === peg$c1343) {
+        s0 = peg$c1343;
+        peg$currPos += 6;
+      } else {
+        s0 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1344); }
+      }
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1340); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseMachineAuthor() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 14) === peg$c1345) {
+        s2 = peg$c1345;
+        peg$currPos += 14;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1346); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseLabelOrLabelList();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1347(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseMachineContributor() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 19) === peg$c1348) {
+        s2 = peg$c1348;
+        peg$currPos += 19;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1349); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseLabelOrLabelList();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1350(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseMachineComment() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 15) === peg$c1351) {
+        s2 = peg$c1351;
+        peg$currPos += 15;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1352); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseLabelOrLabelList();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1353(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseMachineDefinition() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 18) === peg$c1354) {
+        s2 = peg$c1354;
+        peg$currPos += 18;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1355); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseURL();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1356(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseMachineName() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 12) === peg$c1357) {
+        s2 = peg$c1357;
+        peg$currPos += 12;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1358); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseLabel();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1359(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseMachineReference() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 17) === peg$c1360) {
+        s2 = peg$c1360;
+        peg$currPos += 17;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1361); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseLabelOrLabelList();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1362(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseMachineVersion() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 15) === peg$c1363) {
+        s2 = peg$c1363;
+        peg$currPos += 15;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1364); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseSemVer();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1365(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseMachineLicense() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 15) === peg$c1366) {
+        s2 = peg$c1366;
+        peg$currPos += 15;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1367); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseLicenseOrLabelOrList();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1368(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseMachineLanguage() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 16) === peg$c1369) {
+        s2 = peg$c1369;
+        peg$currPos += 16;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1370); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseLabel();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1371(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseFslVersion() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 11) === peg$c1372) {
+        s2 = peg$c1372;
+        peg$currPos += 11;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1373); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseSemVer();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1374(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseMachineTheme() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 5) === peg$c1375) {
+        s2 = peg$c1375;
+        peg$currPos += 5;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1376); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseThemeOrThemeList();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1377(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseMachineFlow() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 4) === peg$c1378) {
+        s2 = peg$c1378;
+        peg$currPos += 4;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1379); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseDirection();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1380(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseMachineHookDefinition() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 5) === peg$c1381) {
+        s2 = peg$c1381;
+        peg$currPos += 5;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1382); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseHookDefinition();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1383(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseDotPreamble() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 12) === peg$c1384) {
+        s2 = peg$c1384;
+        peg$currPos += 12;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1385); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseString();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1386(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseMachineAttribute() {
+    var s0, s1;
+
+    peg$silentFails++;
+    s0 = peg$parseFslVersion();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseMachineName();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parseMachineAuthor();
+        if (s0 === peg$FAILED) {
+          s0 = peg$parseMachineContributor();
+          if (s0 === peg$FAILED) {
+            s0 = peg$parseMachineComment();
+            if (s0 === peg$FAILED) {
+              s0 = peg$parseMachineDefinition();
+              if (s0 === peg$FAILED) {
+                s0 = peg$parseMachineVersion();
+                if (s0 === peg$FAILED) {
+                  s0 = peg$parseMachineLicense();
+                  if (s0 === peg$FAILED) {
+                    s0 = peg$parseMachineLanguage();
+                    if (s0 === peg$FAILED) {
+                      s0 = peg$parseMachineTheme();
+                      if (s0 === peg$FAILED) {
+                        s0 = peg$parseDotPreamble();
+                        if (s0 === peg$FAILED) {
+                          s0 = peg$parseMachineFlow();
+                          if (s0 === peg$FAILED) {
+                            s0 = peg$parseMachineHookDefinition();
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1387); }
+    }
+
+    return s0;
+  }
+
+  function peg$parsePropertyVal() {
+    var s0;
+
+    s0 = peg$parseString();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseBoolean();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parseJsNumericLiteral();
+        if (s0 === peg$FAILED) {
+          s0 = peg$parseNull();
+          if (s0 === peg$FAILED) {
+            s0 = peg$parseUndefined();
+          }
+        }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseSdStateLabel() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    peg$silentFails++;
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 5) === peg$c1388) {
+        s2 = peg$c1388;
+        peg$currPos += 5;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1389); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseLabel();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1390(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1199); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseSdStateColor() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    peg$silentFails++;
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 5) === peg$c1391) {
+        s2 = peg$c1391;
+        peg$currPos += 5;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1392); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseColor();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1393(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1199); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseSdStateTextColor() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    peg$silentFails++;
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 10) === peg$c1395) {
+        s2 = peg$c1395;
+        peg$currPos += 10;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1396); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseColor();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1397(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1394); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseSdStateBackgroundColor() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    peg$silentFails++;
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 16) === peg$c1399) {
+        s2 = peg$c1399;
+        peg$currPos += 16;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1400); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseColor();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1401(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1398); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseSdStateBorderColor() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    peg$silentFails++;
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 12) === peg$c1403) {
+        s2 = peg$c1403;
+        peg$currPos += 12;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1404); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseColor();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1405(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1402); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseSdStateShape() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    peg$silentFails++;
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 5) === peg$c1407) {
+        s2 = peg$c1407;
+        peg$currPos += 5;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1408); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseGvizShape();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1409(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1406); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseSdStateCorners() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    peg$silentFails++;
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 7) === peg$c1411) {
+        s2 = peg$c1411;
+        peg$currPos += 7;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1412); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseCorners();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1413(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1410); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseSdStateLineStyle() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+    peg$silentFails++;
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 10) === peg$c1216) {
+        s2 = peg$c1216;
+        peg$currPos += 10;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1217); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseLineStyle();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 59) {
+                    s8 = peg$c1208;
+                    peg$currPos++;
+                  } else {
+                    s8 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                  }
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      peg$savedPos = s0;
+                      s1 = peg$c1415(s6);
+                      s0 = s1;
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = peg$parseWS();
+      if (s1 === peg$FAILED) {
+        s1 = null;
+      }
+      if (s1 !== peg$FAILED) {
+        if (input.substr(peg$currPos, 9) === peg$c1416) {
+          s2 = peg$c1416;
+          peg$currPos += 9;
+        } else {
+          s2 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$c1417); }
+        }
+        if (s2 !== peg$FAILED) {
+          s3 = peg$parseWS();
+          if (s3 === peg$FAILED) {
+            s3 = null;
+          }
+          if (s3 !== peg$FAILED) {
+            if (input.charCodeAt(peg$currPos) === 58) {
+              s4 = peg$c1206;
+              peg$currPos++;
+            } else {
+              s4 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+            }
+            if (s4 !== peg$FAILED) {
+              s5 = peg$parseWS();
+              if (s5 === peg$FAILED) {
+                s5 = null;
+              }
+              if (s5 !== peg$FAILED) {
+                s6 = peg$parseLineStyle();
+                if (s6 !== peg$FAILED) {
+                  s7 = peg$parseWS();
+                  if (s7 === peg$FAILED) {
+                    s7 = null;
+                  }
+                  if (s7 !== peg$FAILED) {
+                    if (input.charCodeAt(peg$currPos) === 59) {
+                      s8 = peg$c1208;
+                      peg$currPos++;
+                    } else {
+                      s8 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                    }
+                    if (s8 !== peg$FAILED) {
+                      s9 = peg$parseWS();
+                      if (s9 === peg$FAILED) {
+                        s9 = null;
+                      }
+                      if (s9 !== peg$FAILED) {
+                        peg$savedPos = s0;
+                        s1 = peg$c1415(s6);
+                        s0 = s1;
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1414); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseSdStateProperty() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
+
+    peg$silentFails++;
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 8) === peg$c1419) {
+        s2 = peg$c1419;
+        peg$currPos += 8;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1420); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 58) {
+            s4 = peg$c1206;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseAtom();
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 !== peg$FAILED) {
+                  s8 = peg$parsePropertyVal();
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      if (input.charCodeAt(peg$currPos) === 59) {
+                        s10 = peg$c1208;
+                        peg$currPos++;
+                      } else {
+                        s10 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                      }
+                      if (s10 !== peg$FAILED) {
+                        s11 = peg$parseWS();
+                        if (s11 === peg$FAILED) {
+                          s11 = null;
+                        }
+                        if (s11 !== peg$FAILED) {
+                          peg$savedPos = s0;
+                          s1 = peg$c1421(s6, s8);
+                          s0 = s1;
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = peg$parseWS();
+      if (s1 === peg$FAILED) {
+        s1 = null;
+      }
+      if (s1 !== peg$FAILED) {
+        if (input.substr(peg$currPos, 8) === peg$c1419) {
+          s2 = peg$c1419;
+          peg$currPos += 8;
+        } else {
+          s2 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$c1420); }
+        }
+        if (s2 !== peg$FAILED) {
+          s3 = peg$parseWS();
+          if (s3 === peg$FAILED) {
+            s3 = null;
+          }
+          if (s3 !== peg$FAILED) {
+            if (input.charCodeAt(peg$currPos) === 58) {
+              s4 = peg$c1206;
+              peg$currPos++;
+            } else {
+              s4 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+            }
+            if (s4 !== peg$FAILED) {
+              s5 = peg$parseWS();
+              if (s5 === peg$FAILED) {
+                s5 = null;
+              }
+              if (s5 !== peg$FAILED) {
+                s6 = peg$parseAtom();
+                if (s6 !== peg$FAILED) {
+                  s7 = peg$parseWS();
+                  if (s7 !== peg$FAILED) {
+                    s8 = peg$parsePropertyVal();
+                    if (s8 !== peg$FAILED) {
+                      s9 = peg$parseWS();
+                      if (s9 !== peg$FAILED) {
+                        if (input.substr(peg$currPos, 8) === peg$c1422) {
+                          s10 = peg$c1422;
+                          peg$currPos += 8;
+                        } else {
+                          s10 = peg$FAILED;
+                          if (peg$silentFails === 0) { peg$fail(peg$c1423); }
+                        }
+                        if (s10 !== peg$FAILED) {
+                          s11 = peg$parseWS();
+                          if (s11 === peg$FAILED) {
+                            s11 = null;
+                          }
+                          if (s11 !== peg$FAILED) {
+                            if (input.charCodeAt(peg$currPos) === 59) {
+                              s12 = peg$c1208;
+                              peg$currPos++;
+                            } else {
+                              s12 = peg$FAILED;
+                              if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                            }
+                            if (s12 !== peg$FAILED) {
+                              s13 = peg$parseWS();
+                              if (s13 === peg$FAILED) {
+                                s13 = null;
+                              }
+                              if (s13 !== peg$FAILED) {
+                                peg$savedPos = s0;
+                                s1 = peg$c1424(s6, s8);
+                                s0 = s1;
+                              } else {
+                                peg$currPos = s0;
+                                s0 = peg$FAILED;
+                              }
+                            } else {
+                              peg$currPos = s0;
+                              s0 = peg$FAILED;
+                            }
+                          } else {
+                            peg$currPos = s0;
+                            s0 = peg$FAILED;
+                          }
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1418); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseStateDeclarationItem() {
+    var s0;
+
+    s0 = peg$parseSdStateLabel();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseSdStateColor();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parseSdStateTextColor();
+        if (s0 === peg$FAILED) {
+          s0 = peg$parseSdStateBackgroundColor();
+          if (s0 === peg$FAILED) {
+            s0 = peg$parseSdStateBorderColor();
+            if (s0 === peg$FAILED) {
+              s0 = peg$parseSdStateShape();
+              if (s0 === peg$FAILED) {
+                s0 = peg$parseSdStateCorners();
+                if (s0 === peg$FAILED) {
+                  s0 = peg$parseSdStateLineStyle();
+                  if (s0 === peg$FAILED) {
+                    s0 = peg$parseSdStateProperty();
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseStateDeclarationDesc() {
+    var s0, s1, s2, s3, s4, s5;
+
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 123) {
+      s1 = peg$c1219;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1220); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseWS();
+      if (s2 === peg$FAILED) {
+        s2 = null;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = [];
+        s4 = peg$parseStateDeclarationItem();
+        while (s4 !== peg$FAILED) {
+          s3.push(s4);
+          s4 = peg$parseStateDeclarationItem();
+        }
+        if (s3 !== peg$FAILED) {
+          s4 = peg$parseWS();
+          if (s4 === peg$FAILED) {
+            s4 = null;
+          }
+          if (s4 !== peg$FAILED) {
+            if (input.charCodeAt(peg$currPos) === 125) {
+              s5 = peg$c1221;
+              peg$currPos++;
+            } else {
+              s5 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$c1222); }
+            }
+            if (s5 !== peg$FAILED) {
+              peg$savedPos = s0;
+              s1 = peg$c1223(s3);
+              s0 = s1;
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseStateDeclaration() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 5) === peg$c1263) {
+        s2 = peg$c1263;
+        peg$currPos += 5;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1264); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 !== peg$FAILED) {
+          s4 = peg$parseLabel();
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              if (input.charCodeAt(peg$currPos) === 58) {
+                s6 = peg$c1206;
+                peg$currPos++;
+              } else {
+                s6 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+              }
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  s8 = peg$parseStateDeclarationDesc();
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      if (input.charCodeAt(peg$currPos) === 59) {
+                        s10 = peg$c1208;
+                        peg$currPos++;
+                      } else {
+                        s10 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                      }
+                      if (s10 !== peg$FAILED) {
+                        s11 = peg$parseWS();
+                        if (s11 === peg$FAILED) {
+                          s11 = null;
+                        }
+                        if (s11 !== peg$FAILED) {
+                          peg$savedPos = s0;
+                          s1 = peg$c1425(s4, s8);
+                          s0 = s1;
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseNamedList() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.charCodeAt(peg$currPos) === 38) {
+        s2 = peg$c1426;
+        peg$currPos++;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1427); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 === peg$FAILED) {
+          s3 = null;
+        }
+        if (s3 !== peg$FAILED) {
+          s4 = peg$parseLabel();
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            if (s5 !== peg$FAILED) {
+              if (input.charCodeAt(peg$currPos) === 58) {
+                s6 = peg$c1206;
+                peg$currPos++;
+              } else {
+                s6 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$c1207); }
+              }
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 === peg$FAILED) {
+                  s7 = null;
+                }
+                if (s7 !== peg$FAILED) {
+                  s8 = peg$parseLabelOrLabelList();
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 === peg$FAILED) {
+                      s9 = null;
+                    }
+                    if (s9 !== peg$FAILED) {
+                      if (input.charCodeAt(peg$currPos) === 59) {
+                        s10 = peg$c1208;
+                        peg$currPos++;
+                      } else {
+                        s10 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                      }
+                      if (s10 !== peg$FAILED) {
+                        s11 = peg$parseWS();
+                        if (s11 === peg$FAILED) {
+                          s11 = null;
+                        }
+                        if (s11 !== peg$FAILED) {
+                          peg$savedPos = s0;
+                          s1 = peg$c1428(s4, s8);
+                          s0 = s1;
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseMachineProperty() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
+
+    s0 = peg$currPos;
+    s1 = peg$parseWS();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.substr(peg$currPos, 8) === peg$c1419) {
+        s2 = peg$c1419;
+        peg$currPos += 8;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c1420); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseWS();
+        if (s3 !== peg$FAILED) {
+          s4 = peg$parseLabel();
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parseWS();
+            if (s5 !== peg$FAILED) {
+              if (input.substr(peg$currPos, 7) === peg$c3) {
+                s6 = peg$c3;
+                peg$currPos += 7;
+              } else {
+                s6 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$c4); }
+              }
+              if (s6 !== peg$FAILED) {
+                s7 = peg$parseWS();
+                if (s7 !== peg$FAILED) {
+                  s8 = peg$parsePropertyVal();
+                  if (s8 !== peg$FAILED) {
+                    s9 = peg$parseWS();
+                    if (s9 !== peg$FAILED) {
+                      if (input.substr(peg$currPos, 8) === peg$c1422) {
+                        s10 = peg$c1422;
+                        peg$currPos += 8;
+                      } else {
+                        s10 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$c1423); }
+                      }
+                      if (s10 !== peg$FAILED) {
+                        s11 = peg$parseWS();
+                        if (s11 === peg$FAILED) {
+                          s11 = null;
+                        }
+                        if (s11 !== peg$FAILED) {
+                          if (input.charCodeAt(peg$currPos) === 59) {
+                            s12 = peg$c1208;
+                            peg$currPos++;
+                          } else {
+                            s12 = peg$FAILED;
+                            if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                          }
+                          if (s12 !== peg$FAILED) {
+                            s13 = peg$parseWS();
+                            if (s13 === peg$FAILED) {
+                              s13 = null;
+                            }
+                            if (s13 !== peg$FAILED) {
+                              peg$savedPos = s0;
+                              s1 = peg$c1429(s4, s8);
+                              s0 = s1;
+                            } else {
+                              peg$currPos = s0;
+                              s0 = peg$FAILED;
+                            }
+                          } else {
+                            peg$currPos = s0;
+                            s0 = peg$FAILED;
+                          }
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = peg$parseWS();
+      if (s1 === peg$FAILED) {
+        s1 = null;
+      }
+      if (s1 !== peg$FAILED) {
+        if (input.substr(peg$currPos, 8) === peg$c1419) {
+          s2 = peg$c1419;
+          peg$currPos += 8;
+        } else {
+          s2 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$c1420); }
+        }
+        if (s2 !== peg$FAILED) {
+          s3 = peg$parseWS();
+          if (s3 !== peg$FAILED) {
+            s4 = peg$parseLabel();
+            if (s4 !== peg$FAILED) {
+              s5 = peg$parseWS();
+              if (s5 !== peg$FAILED) {
+                if (input.substr(peg$currPos, 8) === peg$c1422) {
+                  s6 = peg$c1422;
+                  peg$currPos += 8;
+                } else {
+                  s6 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$c1423); }
+                }
+                if (s6 !== peg$FAILED) {
+                  s7 = peg$parseWS();
+                  if (s7 === peg$FAILED) {
+                    s7 = null;
+                  }
+                  if (s7 !== peg$FAILED) {
+                    if (input.charCodeAt(peg$currPos) === 59) {
+                      s8 = peg$c1208;
+                      peg$currPos++;
+                    } else {
+                      s8 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                    }
+                    if (s8 !== peg$FAILED) {
+                      s9 = peg$parseWS();
+                      if (s9 === peg$FAILED) {
+                        s9 = null;
+                      }
+                      if (s9 !== peg$FAILED) {
+                        peg$savedPos = s0;
+                        s1 = peg$c1430(s4);
+                        s0 = s1;
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        s1 = peg$parseWS();
+        if (s1 === peg$FAILED) {
+          s1 = null;
+        }
+        if (s1 !== peg$FAILED) {
+          if (input.substr(peg$currPos, 8) === peg$c1419) {
+            s2 = peg$c1419;
+            peg$currPos += 8;
+          } else {
+            s2 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c1420); }
+          }
+          if (s2 !== peg$FAILED) {
+            s3 = peg$parseWS();
+            if (s3 !== peg$FAILED) {
+              s4 = peg$parseLabel();
+              if (s4 !== peg$FAILED) {
+                s5 = peg$parseWS();
+                if (s5 !== peg$FAILED) {
+                  if (input.substr(peg$currPos, 7) === peg$c3) {
+                    s6 = peg$c3;
+                    peg$currPos += 7;
+                  } else {
+                    s6 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c4); }
+                  }
+                  if (s6 !== peg$FAILED) {
+                    s7 = peg$parseWS();
+                    if (s7 !== peg$FAILED) {
+                      s8 = peg$parsePropertyVal();
+                      if (s8 !== peg$FAILED) {
+                        s9 = peg$parseWS();
+                        if (s9 === peg$FAILED) {
+                          s9 = null;
+                        }
+                        if (s9 !== peg$FAILED) {
+                          if (input.charCodeAt(peg$currPos) === 59) {
+                            s10 = peg$c1208;
+                            peg$currPos++;
+                          } else {
+                            s10 = peg$FAILED;
+                            if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                          }
+                          if (s10 !== peg$FAILED) {
+                            s11 = peg$parseWS();
+                            if (s11 === peg$FAILED) {
+                              s11 = null;
+                            }
+                            if (s11 !== peg$FAILED) {
+                              peg$savedPos = s0;
+                              s1 = peg$c1431(s4, s8);
+                              s0 = s1;
+                            } else {
+                              peg$currPos = s0;
+                              s0 = peg$FAILED;
+                            }
+                          } else {
+                            peg$currPos = s0;
+                            s0 = peg$FAILED;
+                          }
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+        if (s0 === peg$FAILED) {
+          s0 = peg$currPos;
+          s1 = peg$parseWS();
+          if (s1 === peg$FAILED) {
+            s1 = null;
+          }
+          if (s1 !== peg$FAILED) {
+            if (input.substr(peg$currPos, 8) === peg$c1419) {
+              s2 = peg$c1419;
+              peg$currPos += 8;
+            } else {
+              s2 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$c1420); }
+            }
+            if (s2 !== peg$FAILED) {
+              s3 = peg$parseWS();
+              if (s3 !== peg$FAILED) {
+                s4 = peg$parseLabel();
+                if (s4 !== peg$FAILED) {
+                  s5 = peg$parseWS();
+                  if (s5 === peg$FAILED) {
+                    s5 = null;
+                  }
+                  if (s5 !== peg$FAILED) {
+                    if (input.charCodeAt(peg$currPos) === 59) {
+                      s6 = peg$c1208;
+                      peg$currPos++;
+                    } else {
+                      s6 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+                    }
+                    if (s6 !== peg$FAILED) {
+                      s7 = peg$parseWS();
+                      if (s7 === peg$FAILED) {
+                        s7 = null;
+                      }
+                      if (s7 !== peg$FAILED) {
+                        peg$savedPos = s0;
+                        s1 = peg$c1432(s4);
+                        s0 = s1;
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseRegularArrangeDeclaration() {
+    var s0, s1, s2, s3, s4, s5, s6;
+
+    s0 = peg$currPos;
+    if (input.substr(peg$currPos, 7) === peg$c1433) {
+      s1 = peg$c1433;
+      peg$currPos += 7;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1434); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseWS();
+      if (s2 === peg$FAILED) {
+        s2 = null;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseLabelOrLabelList();
+        if (s3 !== peg$FAILED) {
+          s4 = peg$parseWS();
+          if (s4 === peg$FAILED) {
+            s4 = null;
+          }
+          if (s4 !== peg$FAILED) {
+            if (input.charCodeAt(peg$currPos) === 59) {
+              s5 = peg$c1208;
+              peg$currPos++;
+            } else {
+              s5 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseWS();
+              if (s6 === peg$FAILED) {
+                s6 = null;
+              }
+              if (s6 !== peg$FAILED) {
+                peg$savedPos = s0;
+                s1 = peg$c1435(s3);
+                s0 = s1;
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseArrangeStartDeclaration() {
+    var s0, s1, s2, s3, s4, s5, s6;
+
+    s0 = peg$currPos;
+    if (input.substr(peg$currPos, 13) === peg$c1436) {
+      s1 = peg$c1436;
+      peg$currPos += 13;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1437); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseWS();
+      if (s2 === peg$FAILED) {
+        s2 = null;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseLabelOrLabelList();
+        if (s3 !== peg$FAILED) {
+          s4 = peg$parseWS();
+          if (s4 === peg$FAILED) {
+            s4 = null;
+          }
+          if (s4 !== peg$FAILED) {
+            if (input.charCodeAt(peg$currPos) === 59) {
+              s5 = peg$c1208;
+              peg$currPos++;
+            } else {
+              s5 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseWS();
+              if (s6 === peg$FAILED) {
+                s6 = null;
+              }
+              if (s6 !== peg$FAILED) {
+                peg$savedPos = s0;
+                s1 = peg$c1438(s3);
+                s0 = s1;
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseArrangeEndDeclaration() {
+    var s0, s1, s2, s3, s4, s5, s6;
+
+    s0 = peg$currPos;
+    if (input.substr(peg$currPos, 11) === peg$c1439) {
+      s1 = peg$c1439;
+      peg$currPos += 11;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1440); }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseWS();
+      if (s2 === peg$FAILED) {
+        s2 = null;
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseLabelOrLabelList();
+        if (s3 !== peg$FAILED) {
+          s4 = peg$parseWS();
+          if (s4 === peg$FAILED) {
+            s4 = null;
+          }
+          if (s4 !== peg$FAILED) {
+            if (input.charCodeAt(peg$currPos) === 59) {
+              s5 = peg$c1208;
+              peg$currPos++;
+            } else {
+              s5 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$c1209); }
+            }
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parseWS();
+              if (s6 === peg$FAILED) {
+                s6 = null;
+              }
+              if (s6 !== peg$FAILED) {
+                peg$savedPos = s0;
+                s1 = peg$c1441(s3);
+                s0 = s1;
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseArrangeDeclaration() {
+    var s0, s1;
+
+    peg$silentFails++;
+    s0 = peg$parseArrangeStartDeclaration();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseArrangeEndDeclaration();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parseRegularArrangeDeclaration();
+      }
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$c1442); }
+    }
+
+    return s0;
+  }
+
+  function peg$parseTerm() {
+    var s0;
+
+    s0 = peg$parseExp();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseStateDeclaration();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parseArrangeDeclaration();
+        if (s0 === peg$FAILED) {
+          s0 = peg$parseNamedList();
+          if (s0 === peg$FAILED) {
+            s0 = peg$parseMachineAttribute();
+            if (s0 === peg$FAILED) {
+              s0 = peg$parseMachineProperty();
+              if (s0 === peg$FAILED) {
+                s0 = peg$parseConfig();
+              }
+            }
+          }
+        }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseTermList() {
+    var s0, s1;
+
+    s0 = [];
+    s1 = peg$parseTerm();
+    while (s1 !== peg$FAILED) {
+      s0.push(s1);
+      s1 = peg$parseTerm();
+    }
+
+    return s0;
+  }
+
+  peg$result = peg$startRuleFunction();
+
+  if (peg$result !== peg$FAILED && peg$currPos === input.length) {
+    return peg$result;
+  } else {
+    if (peg$result !== peg$FAILED && peg$currPos < input.length) {
+      peg$fail(peg$endExpectation());
+    }
+
+    throw peg$buildStructuredError(
+      peg$maxFailExpected,
+      peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,
+      peg$maxFailPos < input.length
+        ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)
+        : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)
+    );
+  }
+}
+
+// this should be added to the end of the peg js output
+// after it's renamed ts
+
+export {
+  peg$SyntaxError as SyntaxError,
+  peg$parse       as parse
+};
diff --git a/src/ts/jssm.ts b/src/ts/jssm.ts
index 21f28953..874d6a48 100644
--- a/src/ts/jssm.ts
+++ b/src/ts/jssm.ts
@@ -12,16 +12,21 @@ import { circular_buffer }         from 'circular_buffer_js';
 
 import {
 
-  JssmGenericState, JssmGenericConfig,
-  JssmTransition, JssmTransitionList, // JssmTransitionRule,
+  JssmGenericState, JssmGenericConfig, JssmStateConfig,
+  JssmTransition, JssmTransitions, JssmTransitionList, // JssmTransitionRule,
   JssmMachineInternalState,
+  JssmAllowsOverride,
   JssmParseTree,
   JssmStateDeclaration, JssmStateDeclarationRule,
+  JssmStateStyleKey, JssmStateStyleKeyList,
   JssmCompileSe, JssmCompileSeStart, JssmCompileRule,
-  JssmArrow, JssmArrowDirection, JssmArrowKind,
-  JssmLayout,
-  FslDirection, FslTheme,
-  HookDescription, HookHandler, HookContext, HookResult, HookComplexResult
+  JssmLayout, JssmHistory,
+  JssmArrowKind,
+  JssmSerialization,
+  JssmPropertyDefinition,
+  FslDirection, FslDirections, FslTheme,
+  HookDescription, HookHandler, HookContext, HookResult, HookComplexResult,
+  JssmBaseTheme
 
 } from './jssm_types';
 
@@ -29,1054 +34,1053 @@ import {
 
 
 
+import { arrow_direction, arrow_left_kind, arrow_right_kind } from './jssm_arrow';
+import { compile, make, makeTransition, wrap_parse }          from './jssm_compiler';
+import { theme_mapping, base_theme }                          from './jssm_theme';
+
+
+
+
+
 import {
-  seq, weighted_rand_select, weighted_sample_select, histograph,
-  weighted_histo_key, array_box_if_string, hook_name, named_hook_name
+  seq,
+  unique, find_repeated,
+  weighted_rand_select, weighted_sample_select,
+  histograph, weighted_histo_key,
+  array_box_if_string,
+  name_bind_prop_and_state, hook_name, named_hook_name
 } from './jssm_util';
 
 
 
 
 
-import { shapes, gviz_shapes, named_colors } from './jssm_constants';
+import * as constants from './jssm_constants';
+const { shapes, gviz_shapes, named_colors } = constants;
 
 
 
 
 
-import { parse }     from './jssm-dot';
-import { version }   from './version';    // replaced from package.js in build
-import { JssmError } from './jssm_error';
+import { parse }               from './fsl_parser';
+import { version, build_time } from './version';    // replaced from package.js in build
+import { JssmError }           from './jssm_error';
 
 
 
 
 
-/* eslint-disable complexity */
-
 /*********
  *
- *  Return the direction of an arrow - `right`, `left`, or `both`.
- *
- *  ```typescript
- *  import { arrow_direction } from 'jssm';
- *
- *  arrow_direction('->');    // 'right'
- *  arrow_direction('<~=>');  // 'both'
- *  ```
+ *  An internal method meant to take a series of declarations and fold them into
+ *  a single multi-faceted declaration, in the process of building a state.  Not
+ *  generally meant for external use.
  *
- *  @param arrow The arrow to be evaluated
+ *  @internal
  *
  */
 
-function arrow_direction(arrow: JssmArrow): JssmArrowDirection {
-
-  switch (String(arrow)) {
-
-    case '->': case '→':
-    case '=>': case '⇒':
-    case '~>': case '↛':
-      return 'right';
-
-    case '<-': case '←':
-    case '<=': case '⇐':
-    case '<~': case '↚':
-      return 'left';
-
-    case '<->': case '↔':
-    case '<-=>': case '←⇒': case '←=>': case '<-⇒':
-    case '<-~>': case '←↛': case '←~>': case '<-↛':
-
-    case '<=>': case '⇔':
-    case '<=->': case '⇐→': case '⇐->': case '<=→':
-    case '<=~>': case '⇐↛': case '⇐~>': case '<=↛':
-
-    case '<~>': case '↮':
-    case '<~->': case '↚→': case '↚->': case '<~→':
-    case '<~=>': case '↚⇒': case '↚=>': case '<~⇒':
-      return 'both';
-
-    default:
-      throw new JssmError(undefined, `arrow_direction: unknown arrow type ${arrow}`);
-
-  }
+function transfer_state_properties(state_decl: JssmStateDeclaration): JssmStateDeclaration {
 
-}
+  state_decl.declarations.map( (d: JssmStateDeclarationRule) => {
 
-/* eslint-enable complexity */
+    switch (d.key) {
 
+      case 'shape'            : state_decl.shape           = d.value; break;
+      case 'color'            : state_decl.color           = d.value; break;
+      case 'corners'          : state_decl.corners         = d.value; break;
+      case 'line-style'       : state_decl.lineStyle       = d.value; break;
 
+      case 'text-color'       : state_decl.textColor       = d.value; break;
+      case 'background-color' : state_decl.backgroundColor = d.value; break;
+      case 'state-label'      : state_decl.stateLabel      = d.value; break;
+      case 'border-color'     : state_decl.borderColor     = d.value; break;
 
+      case 'state_property'   : state_decl.property        = { name: d.name, value: d.value }; break;
 
+      default: throw new JssmError(undefined, `Unknown state property: '${JSON.stringify(d)}'`);
 
-/* eslint-disable complexity */
+    }
 
-/*********
- *
- *  Return the direction of an arrow - `right`, `left`, or `both`.
- *
- *  ```typescript
- *  import { arrow_left_kind } from 'jssm';
- *
- *  arrow_left_kind('<-');    // 'legal'
- *  arrow_left_kind('<=');    // 'main'
- *  arrow_left_kind('<~');    // 'forced'
- *  arrow_left_kind('<->');   // 'legal'
- *  arrow_left_kind('->');    // 'none'
- *  ```
- *
- *  @param arrow The arrow to be evaluated
- *
- */
+  } );
 
-function arrow_left_kind(arrow: JssmArrow): JssmArrowKind {
+  return state_decl;
 
-  switch (String(arrow)) {
+}
 
-    case '->': case '→':
-    case '=>': case '⇒':
-    case '~>': case '↛':
-      return 'none';
 
-    case '<-': case '←':
-    case '<->': case '↔':
-    case '<-=>': case '←⇒':
-    case '<-~>': case '←↛':
-      return 'legal';
 
-    case '<=': case '⇐':
-    case '<=>': case '⇔':
-    case '<=->': case '⇐→':
-    case '<=~>': case '⇐↛':
-      return 'main';
 
-    case '<~': case '↚':
-    case '<~>': case '↮':
-    case '<~->': case '↚→':
-    case '<~=>': case '↚⇒':
-      return 'forced';
 
-    default:
-      throw new JssmError(undefined, `arrow_direction: unknown arrow type ${arrow}`);
+function state_style_condense(jssk: JssmStateStyleKeyList): JssmStateConfig {
 
-  }
+  const state_style: JssmStateConfig = {};
 
-}
+  if (Array.isArray(jssk)) {
 
-/* eslint-enable complexity */
+    jssk.forEach( (key, i) => {
 
+      if (typeof key !== 'object') {
+        throw new JssmError(this, `invalid state item ${i} in state_style_condense list: ${JSON.stringify(key)}`);
+      }
 
+      switch (key.key) {
 
+        case 'shape':
+          if (state_style.shape !== undefined) {
+            throw new JssmError(this, `cannot redefine 'shape' in state_style_condense, already defined`);
+          }
+          state_style.shape = key.value;
+          break;
 
+        case 'color':
+          if (state_style.color !== undefined) {
+            throw new JssmError(this, `cannot redefine 'color' in state_style_condense, already defined`);
+          }
+          state_style.color = key.value;
+          break;
 
-/* eslint-disable complexity */
+        case 'text-color':
+          if (state_style.textColor !== undefined) {
+            throw new JssmError(this, `cannot redefine 'text-color' in state_style_condense, already defined`);
+          }
+          state_style.textColor = key.value;
+          break;
 
-/*********
- *
- *  Return the direction of an arrow - `right`, `left`, or `both`.
- *
- *  ```typescript
- *  import { arrow_left_kind } from 'jssm';
- *
- *  arrow_left_kind('->');    // 'legal'
- *  arrow_left_kind('=>');    // 'main'
- *  arrow_left_kind('~>');    // 'forced'
- *  arrow_left_kind('<->');   // 'legal'
- *  arrow_left_kind('<-');    // 'none'
- *  ```
- *
- *  @param arrow The arrow to be evaluated
- *
- */
+        case 'corners':
+          if (state_style.corners !== undefined) {
+            throw new JssmError(this, `cannot redefine 'corners' in state_style_condense, already defined`);
+          }
+          state_style.corners = key.value;
+          break;
 
-function arrow_right_kind(arrow: JssmArrow): JssmArrowKind {
+        case 'line-style':
+          if (state_style.lineStyle !== undefined) {
+            throw new JssmError(this, `cannot redefine 'line-style' in state_style_condense, already defined`);
+          }
+          state_style.lineStyle = key.value;
+          break;
 
-  switch (String(arrow)) {
+        case 'background-color':
+          if (state_style.backgroundColor !== undefined) {
+            throw new JssmError(this, `cannot redefine 'background-color' in state_style_condense, already defined`);
+          }
+          state_style.backgroundColor = key.value;
+          break;
 
-    case '<-': case '←':
-    case '<=': case '⇐':
-    case '<~': case '↚':
-      return 'none';
+        case 'state-label':
+          if (state_style.stateLabel !== undefined) {
+            throw new JssmError(this, `cannot redefine 'state-label' in state_style_condense, already defined`);
+          }
+          state_style.stateLabel = key.value;
+          break;
 
-    case '->': case '→':
-    case '<->': case '↔':
-    case '<=->': case '⇐→':
-    case '<~->': case '↚→':
-      return 'legal';
+        case 'border-color':
+          if (state_style.borderColor !== undefined) {
+            throw new JssmError(this, `cannot redefine 'border-color' in state_style_condense, already defined`);
+          }
+          state_style.borderColor = key.value;
+          break;
 
-    case '=>': case '⇒':
-    case '<=>': case '⇔':
-    case '<-=>': case '←⇒':
-    case '<~=>': case '↚⇒':
-      return 'main';
+        default:
+          // TODO do that  trick to assert this list is complete
+          throw new JssmError(this, `unknown state style key in condense: ${(key as any).key}`);
 
-    case '~>': case '↛':
-    case '<~>': case '↮':
-    case '<-~>': case '←↛':
-    case '<=~>': case '⇐↛':
-      return 'forced';
+      }
 
-    default:
-      throw new JssmError(undefined, `arrow_direction: unknown arrow type ${arrow}`);
+    });
 
+  } else if (jssk === undefined) {
+    // do nothing, undefined is legal and means we should return the empty container above
+  } else {
+    throw new JssmError(this, 'state_style_condense received a non-array');
   }
 
-}
+  return state_style;
 
-/* eslint-enable complexity */
+}
 
 
 
 
 
-/*********
- *
- *  Internal method meant to perform factory assembly of an edge.  Not meant for
- *  external use.
- *
- *  @internal
- *
- *  @typeparam mDT The type of the machine data member; usually omitted
- *
- */
+// TODO add a lotta docblock here
 
-// TODO add at-param to docblock
+class Machine {
 
-function makeTransition(
 
-  this_se    : JssmCompileSe,
-  from       : string,
-  to         : string,
-  isRight    : boolean,
-  _wasList?  : Array,
-  _wasIndex? : number
+  _state                  : StateType;
+  _states                 : Map;
+  _edges                  : Array< JssmTransition >;
+  _edge_map               : Map>;
+  _named_transitions      : Map;
+  _actions                : Map>;
+  _reverse_actions        : Map>;
+  _reverse_action_targets : Map>;
 
-): JssmTransition {
+  _start_states           : Set;
+  _end_states             : Set;
 
-  const kind: JssmArrowKind = isRight ? arrow_right_kind(this_se.kind) : arrow_left_kind(this_se.kind),
-    edge: JssmTransition = {
-      from,
-      to,
-      kind,
-      forced_only: kind === 'forced',
-      main_path: kind === 'main'
-    };
+  _machine_author?        : Array;
+  _machine_comment?       : string;
+  _machine_contributor?   : Array;
+  _machine_definition?    : string;
+  _machine_language?      : string;
+  _machine_license?       : string;
+  _machine_name?          : string;
+  _machine_version?       : string;
+  _fsl_version?           : string;
+  _raw_state_declaration? : Array;
+  _state_declarations     : Map;
 
-  //  if ((wasList  !== undefined) && (wasIndex === undefined)) { throw new JssmError(undefined, `Must have an index if transition was in a list"); }
-  //  if ((wasIndex !== undefined) && (wasList  === undefined)) { throw new JssmError(undefined, `Must be in a list if transition has an index");   }
-  /*
-    if (typeof edge.to === 'object') {
+  _instance_name : string;
 
-      if (edge.to.key === 'cycle') {
-        if (wasList === undefined) { throw new JssmError(undefined, "Must have a waslist if a to is type cycle"); }
-        const nextIndex = wrapBy(wasIndex, edge.to.value, wasList.length);
-        edge.to = wasList[nextIndex];
-      }
+  _data? : mDT;
 
-    }
-  */
-  const action: string = isRight ? 'r_action' : 'l_action',
-    probability: string = isRight ? 'r_probability' : 'l_probability';
+  _graph_layout              : JssmLayout;
+  _dot_preamble              : string;
+  _arrange_declaration       : Array>;
+  _arrange_start_declaration : Array>;
+  _arrange_end_declaration   : Array>;
 
-  if (this_se[action]) { edge.action = this_se[action]; }
-  if (this_se[probability]) { edge.probability = this_se[probability]; }
+  _themes : FslTheme[];
+  _flow   : FslDirection;
 
-  return edge;
+  _has_hooks                : boolean;
+  _has_basic_hooks          : boolean;
+  _has_named_hooks          : boolean;
+  _has_entry_hooks          : boolean;
+  _has_exit_hooks           : boolean;
+  _has_global_action_hooks  : boolean;
+  _has_transition_hooks     : boolean;
+  // no boolean for the single hooks, just check if they're defined
 
-}
+  _has_forced_transitions   : boolean;
 
+  _hooks                    : Map>;
+  _named_hooks              : Map>;
+  _entry_hooks              : Map>;
+  _exit_hooks               : Map>;
+  _global_action_hooks      : Map>;
+  _any_action_hook          : HookHandler | undefined;
+  _standard_transition_hook : HookHandler | undefined;
+  _main_transition_hook     : HookHandler | undefined;
+  _forced_transition_hook   : HookHandler | undefined;
+  _any_transition_hook      : HookHandler | undefined;
 
+  _has_post_hooks                : boolean;
+  _has_post_basic_hooks          : boolean;
+  _has_post_named_hooks          : boolean;
+  _has_post_entry_hooks          : boolean;
+  _has_post_exit_hooks           : boolean;
+  _has_post_global_action_hooks  : boolean;
+  _has_post_transition_hooks     : boolean;
+  // no boolean for the single hooks, just check if they're defined
 
+  _code_allows_override   : JssmAllowsOverride;
+  _config_allows_override : JssmAllowsOverride;
 
+  _post_hooks                    : Map>;
+  _post_named_hooks              : Map>;
+  _post_entry_hooks              : Map>;
+  _post_exit_hooks               : Map>;
+  _post_global_action_hooks      : Map>;
+  _post_any_action_hook          : HookHandler | undefined;
+  _post_standard_transition_hook : HookHandler | undefined;
+  _post_main_transition_hook     : HookHandler | undefined;
+  _post_forced_transition_hook   : HookHandler | undefined;
+  _post_any_transition_hook      : HookHandler | undefined;
 
-/*********
- *
- *  This method wraps the parser call that comes from the peg grammar,
- *  {@link parse}.  Generally neither this nor that should be used directly
- *  unless you mean to develop plugins or extensions for the machine.
- *
- *  Parses the intermediate representation of a compiled string down to a
- *  machine configuration object.  If you're using this (probably don't,) you're
- *  probably also using {@link compile} and {@link Machine.constructor}.
- *
- *  ```typescript
- *  import { parse, compile, Machine } from 'jssm';
- *
- *  const intermediate = wrap_parse('a -> b;', {});
- *  // [ {key:'transition', from:'a', se:{kind:'->',to:'b'}} ]
- *
- *  const cfg = compile(intermediate);
- *  // { start_states:['a'], transitions: [{ from:'a', to:'b', kind:'legal', forced_only:false, main_path:false }] }
- *
- *  const machine = new Machine(cfg);
- *  // Machine { _instance_name: undefined, _state: 'a', ...
- *  ```
- *
- *  This method is mostly for plugin and intermediate tool authors, or people
- *  who need to work with the machine's intermediate representation.
- *
- *  # Hey!
- *
- *  Most people looking at this want either the `sm` operator or method `from`,
- *  which perform all the steps in the chain.  The library's author mostly uses
- *  operator `sm`, and mostly falls back to `.from` when needing to parse
- *  strings dynamically instead of from template literals.
- *
- *  Operator {@link sm}:
- *
- *  ```typescript
- *  import { sm } from 'jssm';
- *
- *  const switch = sm`on <=> off;`;
- *  ```
- *
- *  Method {@link from}:
- *
- *  ```typescript
- *  import * as jssm from 'jssm';
- *
- *  const toggle = jssm.from('up <=> down;');
- *  ```
- *
- *  `wrap_parse` itself is an internal convenience method for alting out an
- *  object as the options call.  Not generally meant for external use.
- *
- *  @param input The FSL code to be evaluated
- *
- *  @param options Things to control about the instance
- *
- */
+  _property_keys       : Set;
+  _default_properties  : Map;
+  _state_properties    : Map;
+  _required_properties : Set;
 
-function wrap_parse(input: string, options?: Object) {
-  return parse(input, options || {});
-}
+  _history        : JssmHistory;
+  _history_length : number;
 
+  _state_style          : JssmStateConfig;
+  _active_state_style   : JssmStateConfig;
+  _hooked_state_style   : JssmStateConfig;
+  _terminal_state_style : JssmStateConfig;
+  _start_state_style    : JssmStateConfig;
+  _end_state_style      : JssmStateConfig;
 
+  _state_labels : Map;
 
 
+  // whargarbl this badly needs to be broken up, monolith master
+  constructor({
 
-/*********
- *
- *  Internal method performing one step in compiling rules for transitions.  Not
- *  generally meant for external use.
- *
- *  @internal
- *
- *  @typeparam mDT The type of the machine data member; usually omitted
- *
- */
+    start_states,
+    end_states                = [],
+    complete                  = [],
+    transitions,
+    machine_author,
+    machine_comment,
+    machine_contributor,
+    machine_definition,
+    machine_language,
+    machine_license,
+    machine_name,
+    machine_version,
+    state_declaration,
+    property_definition,
+    state_property,
+    fsl_version,
+    dot_preamble              = undefined,
+    arrange_declaration       = [],
+    arrange_start_declaration = [],
+    arrange_end_declaration   = [],
+    theme                     = ['default'],
+    flow                      = 'down',
+    graph_layout              = 'dot',
+    instance_name,
+    history,
+    data,
+    default_state_config,
+    default_active_state_config,
+    default_hooked_state_config,
+    default_terminal_state_config,
+    default_start_state_config,
+    default_end_state_config,
+    allows_override,
+    config_allows_override
+
+  }: JssmGenericConfig) {
 
-function compile_rule_transition_step(
+    this._instance_name = instance_name;
 
-  acc     : Array>,
-  from    : string,
-  to      : string,
-  this_se : JssmCompileSe,
-  next_se : JssmCompileSe
+    this._state                  = start_states[0];
+    this._states                 = new Map();
+    this._state_declarations     = new Map();
+    this._edges                  = [];
+    this._edge_map               = new Map();
+    this._named_transitions      = new Map();
+    this._actions                = new Map();
+    this._reverse_actions        = new Map();
+    this._reverse_action_targets = new Map();   // todo
 
-): Array> { // todo typescript describe the parser representation of a transition step extension
+    this._start_states = new Set(start_states);
+    this._end_states   = new Set(end_states);   // todo consider what to do about incorporating complete too
 
-  const edges: Array> = [];
+    this._machine_author        = array_box_if_string(machine_author);
+    this._machine_comment       = machine_comment;
+    this._machine_contributor   = array_box_if_string(machine_contributor);
+    this._machine_definition    = machine_definition;
+    this._machine_language      = machine_language;
+    this._machine_license       = machine_license;
+    this._machine_name          = machine_name;
+    this._machine_version       = machine_version;
+    this._raw_state_declaration = state_declaration || [];
+    this._fsl_version           = fsl_version;
 
-  const uFrom: Array = (Array.isArray(from) ? from : [from]),
-    uTo: Array = (Array.isArray(to) ? to : [to]);
+    this._arrange_declaration       = arrange_declaration;
+    this._arrange_start_declaration = arrange_start_declaration;
+    this._arrange_end_declaration   = arrange_end_declaration;
 
-  uFrom.map((f: string) => {
-    uTo.map((t: string) => {
+    this._dot_preamble = dot_preamble;
+    this._themes       = theme;
+    this._flow         = flow;
+    this._graph_layout = graph_layout;
 
-      const right: JssmTransition = makeTransition(this_se, f, t, true);
-      if (right.kind !== 'none') { edges.push(right); }
+    this._has_hooks               = false;
+    this._has_basic_hooks         = false;
+    this._has_named_hooks         = false;
+    this._has_entry_hooks         = false;
+    this._has_exit_hooks          = false;
+    this._has_global_action_hooks = false;
+    this._has_transition_hooks    = true;
+    // no need for a boolean for single hooks, just test for undefinedness
 
-      const left: JssmTransition = makeTransition(this_se, t, f, false);
-      if (left.kind !== 'none') { edges.push(left); }
+    this._has_forced_transitions   = false;
 
-    });
-  });
+    this._hooks                    = new Map();
+    this._named_hooks              = new Map();
+    this._entry_hooks              = new Map();
+    this._exit_hooks               = new Map();
+    this._global_action_hooks      = new Map();
+    this._any_action_hook          = undefined;
+    this._standard_transition_hook = undefined;
+    this._main_transition_hook     = undefined;
+    this._forced_transition_hook   = undefined;
+    this._any_transition_hook      = undefined;
 
-  const new_acc: Array> = acc.concat(edges);
+    this._has_post_hooks               = false;
+    this._has_post_basic_hooks         = false;
+    this._has_post_named_hooks         = false;
+    this._has_post_entry_hooks         = false;
+    this._has_post_exit_hooks          = false;
+    this._has_post_global_action_hooks = false;
+    this._has_post_transition_hooks    = true;
+    // no need for a boolean for single hooks, just test for undefinedness
 
-  if (next_se) {
-    return compile_rule_transition_step(new_acc, to, next_se.to, next_se, next_se.se);
-  } else {
-    return new_acc;
-  }
+    this._code_allows_override   = allows_override;
+    this._config_allows_override = config_allows_override;
+    if ( (allows_override === false) && (config_allows_override === true) ) {
+      throw new JssmError(undefined, "Code specifies no override, but config tries to permit; config may not be less strict than code");
+    }
 
-}
+    this._post_hooks                    = new Map();
+    this._post_named_hooks              = new Map();
+    this._post_entry_hooks              = new Map();
+    this._post_exit_hooks               = new Map();
+    this._post_global_action_hooks      = new Map();
+    this._post_any_action_hook          = undefined;
+    this._post_standard_transition_hook = undefined;
+    this._post_main_transition_hook     = undefined;
+    this._post_forced_transition_hook   = undefined;
+    this._post_any_transition_hook      = undefined;
 
+    this._data                          = data;
 
+    this._property_keys                 = new Set();
+    this._default_properties            = new Map();
+    this._state_properties              = new Map();
+    this._required_properties           = new Set();
 
-/*********
- *
- *  Internal method performing one step in compiling rules for transitions.  Not
- *  generally meant for external use.
- *
- *  @internal
- *
- */
+    this._state_style                   = state_style_condense(default_state_config);
+    this._active_state_style            = state_style_condense(default_active_state_config);
+    this._hooked_state_style            = state_style_condense(default_hooked_state_config);
+    this._terminal_state_style          = state_style_condense(default_terminal_state_config);
+    this._start_state_style             = state_style_condense(default_start_state_config);
+    this._end_state_style               = state_style_condense(default_end_state_config);
 
-function compile_rule_handle_transition(rule: JssmCompileSeStart): any { // TODO FIXME no any // todo typescript describe the parser representation of a transition
-  return compile_rule_transition_step([], rule.from, rule.se.to, rule.se, rule.se.se);
-}
+    this._history_length                = history || 0;
+    this._history                       = new circular_buffer(this._history_length);
 
+    this._state_labels                  = new Map();
 
 
-/*********
- *
- *  Internal method performing one step in compiling rules for transitions.  Not
- *  generally meant for external use.
- *
- *  @internal
- *
- */
+    // consolidate the state declarations
+    if (state_declaration) {
+      state_declaration.map((state_decl: JssmStateDeclaration) => {
 
-function compile_rule_handler(rule: JssmCompileSeStart): JssmCompileRule {
+        if (this._state_declarations.has(state_decl.state)) { // no repeats
+          throw new JssmError(this, `Added the same state declaration twice: ${JSON.stringify(state_decl.state)}`);
+        }
 
-  if (rule.key === 'transition') {
-    return { agg_as: 'transition', val: compile_rule_handle_transition(rule) };
-  }
+        this._state_declarations.set(state_decl.state, transfer_state_properties(state_decl));
 
-  if (rule.key === 'machine_language') {
-    return { agg_as: 'machine_language', val: reduce_to_639(rule.value) };
-  }
+      });
+    }
 
-  if (rule.key === 'state_declaration') {
-    if (!rule.name) { throw new JssmError(undefined, 'State declarations must have a name'); }
-    return { agg_as: 'state_declaration', val: { state: rule.name, declarations: rule.value } };
-  }
 
-  if (['arrange_declaration', 'arrange_start_declaration',
-    'arrange_end_declaration'].includes(rule.key)) {
-    return { agg_as: rule.key, val: [rule.value] };
-  }
+    // walk the decls for labels; aggregate them when found
+    [... this._state_declarations].map(sd => {
 
-  const tautologies: Array = [
-    'graph_layout', 'start_states', 'end_states', 'machine_name', 'machine_version',
-    'machine_comment', 'machine_author', 'machine_contributor', 'machine_definition',
-    'machine_reference', 'machine_license', 'fsl_version', 'state_config', 'theme',
-    'flow', 'dot_preamble'
-  ];
+      const [key, decl] = sd,
+            labelled    = decl.declarations.filter(d => d.key === 'state-label');
 
-  if (tautologies.includes(rule.key)) {
-    return { agg_as: rule.key, val: rule.value };
-  }
+      if (labelled.length > 1) {
+        throw new JssmError(this, `state ${key} may only have one state-label; has ${labelled.length}`);
+      }
 
-  throw new JssmError(undefined, `compile_rule_handler: Unknown rule: ${JSON.stringify(rule)}`);
+      if (labelled.length === 1) {
+        this._state_labels.set(key, labelled[0].value);
+      }
 
-}
+    });
 
 
 
+    // walk the transitions
+    transitions.map((tr: JssmTransition) => {
 
+      if ( tr.from === undefined ) { throw new JssmError(this, `transition must define 'from': ${JSON.stringify(tr)}`); }
+      if ( tr.to   === undefined ) { throw new JssmError(this, `transition must define 'to': ${JSON.stringify(tr)}`); }
 
-/*********
- *
- *  Compile a machine's JSON intermediate representation to a config object.  If
- *  you're using this (probably don't,) you're probably also using
- *  {@link parse} to get the IR, and the object constructor
- *  {@link Machine.construct} to turn the config object into a workable machine.
- *
- *  ```typescript
- *  import { parse, compile, Machine } from 'jssm';
- *
- *  const intermediate = parse('a -> b;');
- *  // [ {key:'transition', from:'a', se:{kind:'->',to:'b'}} ]
- *
- *  const cfg = compile(intermediate);
- *  // { start_states:['a'], transitions: [{ from:'a', to:'b', kind:'legal', forced_only:false, main_path:false }] }
- *
- *  const machine = new Machine(cfg);
- *  // Machine { _instance_name: undefined, _state: 'a', ...
- *  ```
- *
- *  This method is mostly for plugin and intermediate tool authors, or people
- *  who need to work with the machine's intermediate representation.
- *
- *  # Hey!
- *
- *  Most people looking at this want either the `sm` operator or method `from`,
- *  which perform all the steps in the chain.  The library's author mostly uses
- *  operator `sm`, and mostly falls back to `.from` when needing to parse
- *  strings dynamically instead of from template literals.
- *
- *  Operator {@link sm}:
- *
- *  ```typescript
- *  import { sm } from 'jssm';
- *
- *  const switch = sm`on <=> off;`;
- *  ```
- *
- *  Method {@link from}:
- *
- *  ```typescript
- *  import * as jssm from 'jssm';
- *
- *  const toggle = jssm.from('up <=> down;');
- *  ```
- *
- *  @typeparam mDT The type of the machine data member; usually omitted
- *
- *  @param tree The parse tree to be boiled down into a machine config
- *
- */
+      // get the cursors.  what a mess
+      const cursor_from: JssmGenericState
+        = this._states.get(tr.from)
+        || { name: tr.from, from: [], to: [], complete: complete.includes(tr.from) };
 
-function compile(tree: JssmParseTree): JssmGenericConfig {
-
-  const results: {
-    graph_layout              : Array,
-    transition                : Array>,
-    start_states              : Array,
-    end_states                : Array,
-    state_config              : Array,           // TODO COMEBACK no any
-    state_declaration         : Array,
-    fsl_version               : Array,
-    machine_author            : Array,
-    machine_comment           : Array,
-    machine_contributor       : Array,
-    machine_definition        : Array,
-    machine_language          : Array,
-    machine_license           : Array,
-    machine_name              : Array,
-    machine_reference         : Array,
-    theme                     : Array,
-    flow                      : Array,
-    dot_preamble              : Array,
-    arrange_declaration       : Array>, // TODO COMEBACK CHECKME
-    arrange_start_declaration : Array>, // TODO COMEBACK CHECKME
-    arrange_end_declaration   : Array>, // TODO COMEBACK CHECKME
-    machine_version           : Array         // TODO COMEBACK semver
-  } = {
-    graph_layout              : [],
-    transition                : [],
-    start_states              : [],
-    end_states                : [],
-    state_config              : [],
-    state_declaration         : [],
-    fsl_version               : [],
-    machine_author            : [],
-    machine_comment           : [],
-    machine_contributor       : [],
-    machine_definition        : [],
-    machine_language          : [],
-    machine_license           : [],
-    machine_name              : [],
-    machine_reference         : [],
-    theme                     : [],
-    flow                      : [],
-    dot_preamble              : [],
-    arrange_declaration       : [],
-    arrange_start_declaration : [],
-    arrange_end_declaration   : [],
-    machine_version           : []
-  };
-
-  tree.map((tr: JssmCompileSeStart) => {
-
-    const rule   : JssmCompileRule = compile_rule_handler(tr),
-          agg_as : string          = rule.agg_as,
-          val    : any             = rule.val;                  // TODO FIXME no any
-
-    results[agg_as] = results[agg_as].concat(val);
-
-  });
-
-  const assembled_transitions: Array> = [].concat(...results['transition']);
-
-  const result_cfg: JssmGenericConfig = {
-    start_states: results.start_states.length ? results.start_states : [assembled_transitions[0].from],
-    transitions: assembled_transitions
-  };
-
-  const oneOnlyKeys: Array = [
-    'graph_layout', 'machine_name', 'machine_version', 'machine_comment',
-    'fsl_version', 'machine_license', 'machine_definition', 'machine_language',
-    'theme', 'flow', 'dot_preamble'
-  ];
-
-  oneOnlyKeys.map((oneOnlyKey: string) => {
-    if (results[oneOnlyKey].length > 1) {
-      throw new JssmError(undefined,
-        `May only have one ${oneOnlyKey} statement maximum: ${JSON.stringify(results[oneOnlyKey])}`
-      );
-    } else {
-      if (results[oneOnlyKey].length) {
-        result_cfg[oneOnlyKey] = results[oneOnlyKey][0];
+      if (!(this._states.has(tr.from))) {
+        this._new_state(cursor_from);
       }
-    }
-  });
 
-  ['arrange_declaration', 'arrange_start_declaration', 'arrange_end_declaration',
-    'machine_author', 'machine_contributor', 'machine_reference', 'state_declaration'].map(
-      (multiKey: string) => {
-        if (results[multiKey].length) {
-          result_cfg[multiKey] = results[multiKey];
+      const cursor_to: JssmGenericState
+        = this._states.get(tr.to)
+        || { name: tr.to, from: [], to: [], complete: complete.includes(tr.to) };
+
+      if (!(this._states.has(tr.to))) {
+        this._new_state(cursor_to);
+      }
+
+      // guard against existing connections being re-added
+      if (cursor_from.to.includes(tr.to)) {
+        throw new JssmError(this, `already has ${JSON.stringify(tr.from)} to ${JSON.stringify(tr.to)}`);
+      } else {
+        cursor_from.to.push(tr.to);
+        cursor_to.from.push(tr.from);
+      }
+
+      // add the edge; note its id
+      this._edges.push(tr);
+      const thisEdgeId: number = this._edges.length - 1;
+      if (tr.forced_only) { this._has_forced_transitions = true; }
+
+      // guard against repeating a transition name
+      if (tr.name) {
+        if (this._named_transitions.has(tr.name)) {
+          throw new JssmError(this, `named transition "${JSON.stringify(tr.name)}" already created`);
+        } else {
+          this._named_transitions.set(tr.name, thisEdgeId);
         }
       }
-    );
 
-  return result_cfg;
+      // set up the mapping, so that edges can be looked up by endpoint pairs
+      const from_mapping: Map = this._edge_map.get(tr.from) || new Map();
+      if (!(this._edge_map.has(tr.from))) {
+        this._edge_map.set(tr.from, from_mapping);
+      }
+
+      //    const to_mapping = from_mapping.get(tr.to);
+      from_mapping.set(tr.to, thisEdgeId); // already checked that this mapping doesn't exist, above
 
-}
+      // set up the action mapping, so that actions can be looked up by origin
+      if (tr.action) {
 
 
+        // forward mapping first by action name
+        let actionMap: Map = this._actions.get(tr.action);
+        if (!(actionMap)) {
+          actionMap = new Map();
+          this._actions.set(tr.action, actionMap);
+        }
 
+        if (actionMap.has(tr.from)) {
+          throw new JssmError(this, `action ${JSON.stringify(tr.action)} already attached to origin ${JSON.stringify(tr.from)}`);
+        } else {
+          actionMap.set(tr.from, thisEdgeId);
+        }
 
 
-/*********
- *
- *  An internal convenience wrapper for parsing then compiling a machine string.
- *  Not generally meant for external use.  Please see {@link compile} or
- *  {@link sm}.
- *
- *  @typeparam mDT The type of the machine data member; usually omitted
- *
- *  @param plan The FSL code to be evaluated and built into a machine config
- *
- */
+        // reverse mapping first by state origin name
+        let rActionMap: Map = this._reverse_actions.get(tr.from);
+        if (!(rActionMap)) {
+          rActionMap = new Map();
+          this._reverse_actions.set(tr.from, rActionMap);
+        }
 
-function make(plan: string): JssmGenericConfig {
-  return compile(wrap_parse(plan));
-}
+        // no need to test for reverse mapping pre-presence;
+        // forward mapping already covers collisions
+        rActionMap.set(tr.action, thisEdgeId);
 
 
+        // reverse mapping first by state target name
+        if (!(this._reverse_action_targets.has(tr.to))) {
+          this._reverse_action_targets.set(tr.to, new Map());
+        }
 
+        /* todo comeback
+           fundamental problem is roActionMap needs to be a multimap
+                const roActionMap = this._reverse_action_targets.get(tr.to);  // wasteful - already did has - refactor
+                if (roActionMap) {
+                  if (roActionMap.has(tr.action)) {
+                    throw new JssmError(this, `ro-action ${tr.to} already attached to action ${tr.action}`);
+                  } else {
+                    roActionMap.set(tr.action, thisEdgeId);
+                  }
+                } else {
+                  throw new JssmError(this, `should be impossible - flow doesn\'t know .set precedes .get yet again.  severe error?');
+                }
+        */
+      }
 
+    });
 
-/*********
- *
- *  An internal method meant to take a series of declarations and fold them into
- *  a single multi-faceted declaration, in the process of building a state.  Not
- *  generally meant for external use.
- *
- *  @internal
- *
- */
 
-function transfer_state_properties(state_decl: JssmStateDeclaration): JssmStateDeclaration {
+    if (Array.isArray(property_definition)) {
 
-  state_decl.declarations.map( (d: JssmStateDeclarationRule) => {
+      property_definition.forEach(pr => {
 
-    switch (d.key) {
+        this._property_keys.add(pr.name);
 
-      case 'shape'            : state_decl.shape           = d.value; break;
-      case 'color'            : state_decl.color           = d.value; break;
-      case 'corners'          : state_decl.corners         = d.value; break;
-      case 'linestyle'        : state_decl.linestyle       = d.value; break;
+        if (pr.hasOwnProperty('default_value')) {
+          this._default_properties.set(pr.name, pr.default_value);
+        }
 
-      case 'text-color'       : state_decl.textColor       = d.value; break;
-      case 'background-color' : state_decl.backgroundColor = d.value; break;
-      case 'border-color'     : state_decl.borderColor     = d.value; break;
+        if (pr.hasOwnProperty('required') && (pr.required === true)) {
+          this._required_properties.add(pr.name);
+        }
 
-      default: throw new JssmError(undefined, `Unknown state property: '${JSON.stringify(d)}'`);
+      });
 
     }
 
-  } );
 
-  return state_decl;
+    if (Array.isArray(state_property)) {
 
-}
+      state_property.forEach(sp => {
+        this._state_properties.set(sp.name, sp.default_value);
+      });
 
+    }
 
 
+    // done building, do checks
 
+    // assert all props are valid
+    this._state_properties.forEach( (_value, key) => {
+      const inside = JSON.parse(key);
+      if (Array.isArray(inside)) {
+        const j_property = inside[0];
+        if (typeof j_property === 'string') {
+          const j_state = inside[1];
+          if (typeof j_state === 'string') {
+            if (!(this.known_prop(j_property))) {
+              throw new JssmError(this, `State "${j_state}" has property "${j_property}" which is not globally declared`);
+            }
+          }
+        }
+      }
+    });
 
-// TODO add a lotta docblock here
+    // assert all required properties are serviced
+    this._required_properties.forEach( dp_key => {
+      if (this._default_properties.has(dp_key)) {
+        throw new JssmError(this, `The property "${dp_key}" is required, but also has a default; these conflict`);
+      }
+      this.states().forEach(s => {
+        const bound_name = name_bind_prop_and_state(dp_key, s);
+        if (!(this._state_properties.has(bound_name))) {
+          throw new JssmError(this, `State "${s}" is missing required property "${dp_key}"`);
+        }
+      });
+    });
 
-class Machine {
+    // assert chosen starting state is valid
+    if (!(this.has_state( this.state() ))) {
+      throw new JssmError(this, `Current start state "${this.state()}" does not exist`);
+    }
 
+    // assert all starting states are valid
+    start_states.forEach( (ss, ssi) => {
+      if (!(this.has_state(ss))) {
+        throw new JssmError(this, `Start state ${ssi} "${ss}" does not exist`);
+      }
+    });
 
-  _state                  : StateType;
-  _states                 : Map;
-  _edges                  : Array>;
-  _edge_map               : Map>;
-  _named_transitions      : Map;
-  _actions                : Map>;
-  _reverse_actions        : Map>;
-  _reverse_action_targets : Map>;
+    // assert chosen starting state is valid
+    if (!( start_states.length === this._start_states.size )) {
+      throw new JssmError(this, `Start states cannot be repeated`);
+    }
 
-  _machine_author?        : Array;
-  _machine_comment?       : string;
-  _machine_contributor?   : Array;
-  _machine_definition?    : string;
-  _machine_language?      : string;
-  _machine_license?       : string;
-  _machine_name?          : string;
-  _machine_version?       : string;
-  _fsl_version?           : string;
-  _raw_state_declaration? : Array;
-  _state_declarations     : Map;
 
-  _instance_name : string;
+  }
 
-  _data? : mDT;
 
-  _graph_layout              : JssmLayout;
-  _dot_preamble              : string;
-  _arrange_declaration       : Array>;
-  _arrange_start_declaration : Array>;
-  _arrange_end_declaration   : Array>;
 
-  _theme : FslTheme;
-  _flow  : FslDirection;
 
-  _has_hooks                : boolean;
-  _has_basic_hooks          : boolean;
-  _has_named_hooks          : boolean;
-  _has_entry_hooks          : boolean;
-  _has_exit_hooks           : boolean;
-  _has_global_action_hooks  : boolean;
-  _has_transition_hooks     : boolean;
-  // no boolean for the single hooks, just check if they're defined
 
-  _hooks                    : Map>;
-  _named_hooks              : Map>;
-  _entry_hooks              : Map>;
-  _exit_hooks               : Map>;
-  _global_action_hooks      : Map>;
-  _any_action_hook          : HookHandler | undefined;
-  _standard_transition_hook : HookHandler | undefined;
-  _main_transition_hook     : HookHandler | undefined;
-  _forced_transition_hook   : HookHandler | undefined;
-  _any_transition_hook      : HookHandler | undefined;
+  /********
+   *
+   *  Internal method for fabricating states.  Not meant for external use.
+   *
+   *  @internal
+   *
+   */
 
-  _has_post_hooks                : boolean;
-  _has_post_basic_hooks          : boolean;
-  _has_post_named_hooks          : boolean;
-  _has_post_entry_hooks          : boolean;
-  _has_post_exit_hooks           : boolean;
-  _has_post_global_action_hooks  : boolean;
-  _has_post_transition_hooks     : boolean;
-  // no boolean for the single hooks, just check if they're defined
+  _new_state(state_config: JssmGenericState): StateType {
 
-  _post_hooks                    : Map>;
-  _post_named_hooks              : Map>;
-  _post_entry_hooks              : Map>;
-  _post_exit_hooks               : Map>;
-  _post_global_action_hooks      : Map>;
-  _post_any_action_hook          : HookHandler | undefined;
-  _post_standard_transition_hook : HookHandler | undefined;
-  _post_main_transition_hook     : HookHandler | undefined;
-  _post_forced_transition_hook   : HookHandler | undefined;
-  _post_any_transition_hook      : HookHandler | undefined;
+    if (this._states.has(state_config.name)) {
+      throw new JssmError(this, `state ${JSON.stringify(state_config.name)} already exists`);
+    }
 
-  _history        : circular_buffer<[StateType, mDT]>;
-  _history_length : number;
+    this._states.set(state_config.name, state_config);
+    return state_config.name;
 
+  }
 
-  // whargarbl this badly needs to be broken up, monolith master
-  constructor({
 
-    start_states,
-    complete = [],
-    transitions,
-    machine_author,
-    machine_comment,
-    machine_contributor,
-    machine_definition,
-    machine_language,
-    machine_license,
-    machine_name,
-    machine_version,
-    state_declaration,
-    fsl_version,
-    dot_preamble              = undefined,
-    arrange_declaration       = [],
-    arrange_start_declaration = [],
-    arrange_end_declaration   = [],
-    theme                     = 'default',
-    flow                      = 'down',
-    graph_layout              = 'dot',
-    instance_name,
-    history,
-    data
 
-  }: JssmGenericConfig) {
 
-    this._instance_name = instance_name;
 
-    this._state                  = start_states[0];
-    this._states                 = new Map();
-    this._state_declarations     = new Map();
-    this._edges                  = [];
-    this._edge_map               = new Map();
-    this._named_transitions      = new Map();
-    this._actions                = new Map();
-    this._reverse_actions        = new Map();
-    this._reverse_action_targets = new Map();   // todo
+  /*********
+   *
+   *  Get the current state of a machine.
+   *
+   *  ```typescript
+   *  import * as jssm from 'jssm';
+   *
+   *  const lswitch = jssm.from('on <=> off;');
+   *  console.log( lswitch.state() );             // 'on'
+   *
+   *  lswitch.transition('off');
+   *  console.log( lswitch.state() );             // 'off'
+   *  ```
+   *
+   *  @typeparam mDT The type of the machine data member; usually omitted
+   *
+   */
 
-    this._machine_author        = array_box_if_string(machine_author);
-    this._machine_comment       = machine_comment;
-    this._machine_contributor   = array_box_if_string(machine_contributor);
-    this._machine_definition    = machine_definition;
-    this._machine_language      = machine_language;
-    this._machine_license       = machine_license;
-    this._machine_name          = machine_name;
-    this._machine_version       = machine_version;
-    this._raw_state_declaration = state_declaration || [];
-    this._fsl_version           = fsl_version;
+  state(): StateType {
+    return this._state;
+  }
 
-    this._arrange_declaration       = arrange_declaration;
-    this._arrange_start_declaration = arrange_start_declaration;
-    this._arrange_end_declaration   = arrange_end_declaration;
 
-    this._dot_preamble = dot_preamble;
-    this._theme        = theme;
-    this._flow         = flow;
-    this._graph_layout = graph_layout;
 
-    this._has_hooks               = false;
-    this._has_basic_hooks         = false;
-    this._has_named_hooks         = false;
-    this._has_entry_hooks         = false;
-    this._has_exit_hooks          = false;
-    this._has_global_action_hooks = false;
-    this._has_transition_hooks    = true;
-    // no need for a boolean for single hooks, just test for undefinedness
 
-    this._hooks                    = new Map();
-    this._named_hooks              = new Map();
-    this._entry_hooks              = new Map();
-    this._exit_hooks               = new Map();
-    this._global_action_hooks      = new Map();
-    this._any_action_hook          = undefined;
-    this._standard_transition_hook = undefined;
-    this._main_transition_hook     = undefined;
-    this._forced_transition_hook   = undefined;
-    this._any_transition_hook      = undefined;
 
-    this._has_post_hooks               = false;
-    this._has_post_basic_hooks         = false;
-    this._has_post_named_hooks         = false;
-    this._has_post_entry_hooks         = false;
-    this._has_post_exit_hooks          = false;
-    this._has_post_global_action_hooks = false;
-    this._has_post_transition_hooks    = true;
-    // no need for a boolean for single hooks, just test for undefinedness
+  /*********
+   *
+   *  Get the label for a given state, if any; return `undefined` otherwise.
+   *
+   *  ```typescript
+   *  import * as jssm from 'jssm';
+   *
+   *  const lswitch = jssm.from('a -> b; state a: { label: "Foo!"; };');
+   *  console.log( lswitch.label_for('a') );              // 'Foo!'
+   *  console.log( lswitch.label_for('b') );              // undefined
+   *  ```
+   *
+   *  See also {@link display_text}.
+   *
+   *  @typeparam mDT The type of the machine data member; usually omitted
+   *
+   */
 
-    this._post_hooks                    = new Map();
-    this._post_named_hooks              = new Map();
-    this._post_entry_hooks              = new Map();
-    this._post_exit_hooks               = new Map();
-    this._post_global_action_hooks      = new Map();
-    this._post_any_action_hook          = undefined;
-    this._post_standard_transition_hook = undefined;
-    this._post_main_transition_hook     = undefined;
-    this._post_forced_transition_hook   = undefined;
-    this._post_any_transition_hook      = undefined;
+  label_for(state: StateType): string {
+    return this._state_labels.get(state);
+  }
 
-    this._data                     = data;
 
-    this._history_length           = history || 0;
-    this._history                  = new circular_buffer(this._history_length);
 
 
-    if (state_declaration) {
-      state_declaration.map((state_decl: JssmStateDeclaration) => {
 
-        if (this._state_declarations.has(state_decl.state)) { // no repeats
-          throw new JssmError(this, `Added the same state declaration twice: ${JSON.stringify(state_decl.state)}`);
-        }
+  /*********
+   *
+   *  Get whatever the node should show as text.
+   *
+   *  Currently, this means to get the label for a given state, if any;
+   *  otherwise to return the node's name.  However, this definition is expected
+   *  to grow with time, and it is currently considered ill-advised to manually
+   *  parse this text.
+   *
+   *  See also {@link label_for}.
+   *
+   *  ```typescript
+   *  import * as jssm from 'jssm';
+   *
+   *  const lswitch = jssm.from('a -> b; state a: { label: "Foo!"; };');
+   *  console.log( lswitch.display_text('a') );              // 'Foo!'
+   *  console.log( lswitch.display_text('b') );              // 'b'
+   *  ```
+   *
+   *  @typeparam mDT The type of the machine data member; usually omitted
+   *
+   */
 
-        this._state_declarations.set(state_decl.state, transfer_state_properties(state_decl));
+  display_text(state: StateType): string {
+    return this._state_labels.get(state) ?? state;
+  }
 
-      });
+
+
+
+
+  /*********
+   *
+   *  Get the current data of a machine.
+   *
+   *  ```typescript
+   *  import * as jssm from 'jssm';
+   *
+   *  const lswitch = jssm.from('on <=> off;', {data: 1});
+   *  console.log( lswitch.data() );              // 1
+   *  ```
+   *
+   *  @typeparam mDT The type of the machine data member; usually omitted
+   *
+   */
+
+  data(): mDT {
+    return this._data;
+  }
+
+
+
+
+
+  // NEEDS_DOCS
+  /*********
+   *
+   *  Get the current value of a given property name.
+   *
+   *  ```typescript
+   *
+   *  ```
+   *
+   *  @param name The relevant property name to look up
+   *
+   *  @returns The value behind the prop name.  Because functional props are
+   *  evaluated as getters, this can be anything.
+   *
+   */
+
+  prop(name: string): any {
+
+    const bound_name = name_bind_prop_and_state(name, this.state());
+
+    if (this._state_properties.has(bound_name)) {
+      return this._state_properties.get(bound_name);
+
+    } else if (this._default_properties.has(name)) {
+      return this._default_properties.get(name);
+
+    } else {
+      return undefined;
     }
 
+  }
 
-    transitions.map((tr: JssmTransition) => {
 
-      if ( tr.from === undefined ) { throw new JssmError(this, `transition must define 'from': ${JSON.stringify(tr)}`); }
-      if ( tr.to === undefined )   { throw new JssmError(this, `transition must define 'to': ${JSON.stringify(tr)}`); }
 
-      // get the cursors.  what a mess
-      const cursor_from: JssmGenericState
-        = this._states.get(tr.from)
-        || { name: tr.from, from: [], to: [], complete: complete.includes(tr.from) };
 
-      if (!(this._states.has(tr.from))) {
-        this._new_state(cursor_from);
-      }
 
-      const cursor_to: JssmGenericState
-        = this._states.get(tr.to)
-        || { name: tr.to, from: [], to: [], complete: complete.includes(tr.to) };
+  // NEEDS_DOCS
+  /*********
+   *
+   *  Get the current value of a given property name.  If missing on the state
+   *  and without a global default, throw, unlike {@link prop}, which would
+   *  return `undefined` instead.
+   *
+   *  ```typescript
+   *
+   *  ```
+   *
+   *  @param name The relevant property name to look up
+   *
+   *  @returns The value behind the prop name.  Because functional props are
+   *  evaluated as getters, this can be anything.
+   *
+   */
+
+  strict_prop(name: string): any {
+
+    const bound_name = name_bind_prop_and_state(name, this.state());
+
+    if (this._state_properties.has(bound_name)) {
+      return this._state_properties.get(bound_name);
+
+    } else if (this._default_properties.has(name)) {
+      return this._default_properties.get(name);
+
+    } else {
+      throw new JssmError(this, `Strictly requested a prop '${name}' which doesn't exist on current state '${this.state()}' and has no default`);
+    }
+
+  }
+
+
+
+
+
+  // NEEDS_DOCS
+  // COMEBACK add prop_map, sparse_props and strict_props to doc text when implemented
+  /*********
+   *
+   *  Get the current value of every prop, as an object.  If no current definition
+   *  exists for a prop - that is, if the prop was defined without a default and
+   *  the current state also doesn't define the prop - then that prop will be listed
+   *  in the returned object with a value of `undefined`.
+   *
+   *  ```typescript
+   *  const traffic_light = sm`
+   *
+   *    property can_go     default true;
+   *    property hesitate   default true;
+   *    property stop_first default false;
+   *
+   *    Off -> Red => Green => Yellow => Red;
+   *    [Red Yellow Green] ~> [Off FlashingRed];
+   *    FlashingRed -> Red;
+   *
+   *    state Red:         { property stop_first true;  property can_go false; };
+   *    state Off:         { property stop_first true;  };
+   *    state FlashingRed: { property stop_first true;  };
+   *    state Green:       { property hesitate   false; };
+   *
+   *  `;
+   *
+   *  traffic_light.state();  // Off
+   *  traffic_light.props();  // { can_go: true,  hesitate: true,  stop_first: true;  }
+   *
+   *  traffic_light.go('Red');
+   *  traffic_light.props();  // { can_go: false, hesitate: true,  stop_first: true;  }
+   *
+   *  traffic_light.go('Green');
+   *  traffic_light.props();  // { can_go: true,  hesitate: false, stop_first: false; }
+   *  ```
+   *
+   */
 
-      if (!(this._states.has(tr.to))) {
-        this._new_state(cursor_to);
-      }
+  props(): object {
 
-      // guard against existing connections being re-added
-      if (cursor_from.to.includes(tr.to)) {
-        throw new JssmError(this, `already has ${JSON.stringify(tr.from)} to ${JSON.stringify(tr.to)}`);
-      } else {
-        cursor_from.to.push(tr.to);
-        cursor_to.from.push(tr.from);
-      }
+    const ret: object = {};
+    this.known_props().forEach(
+      p =>
+        ret[p] = this.prop(p)
+    );
 
-      // add the edge; note its id
-      this._edges.push(tr);
-      const thisEdgeId: number = this._edges.length - 1;
+    return ret;
 
-      // guard against repeating a transition name
-      if (tr.name) {
-        if (this._named_transitions.has(tr.name)) {
-          throw new JssmError(this, `named transition "${JSON.stringify(tr.name)}" already created`);
-        } else {
-          this._named_transitions.set(tr.name, thisEdgeId);
-        }
-      }
+  }
 
-      // set up the mapping, so that edges can be looked up by endpoint pairs
-      const from_mapping: Map = this._edge_map.get(tr.from) || new Map();
-      if (!(this._edge_map.has(tr.from))) {
-        this._edge_map.set(tr.from, from_mapping);
-      }
 
-      //    const to_mapping = from_mapping.get(tr.to);
-      from_mapping.set(tr.to, thisEdgeId); // already checked that this mapping doesn't exist, above
 
-      // set up the action mapping, so that actions can be looked up by origin
-      if (tr.action) {
 
 
-        // forward mapping first by action name
-        let actionMap: Map = this._actions.get(tr.action);
-        if (!(actionMap)) {
-          actionMap = new Map();
-          this._actions.set(tr.action, actionMap);
-        }
+  // NEEDS_DOCS
+  // TODO COMEBACK
+  /*********
+   *
+   *  Get the current value of every prop, as an object.  Compare
+   *  {@link prop_map}, which returns a `Map`.
+   *
+   *  ```typescript
+   *
+   *  ```
+   *
+   */
 
-        if (actionMap.has(tr.from)) {
-          throw new JssmError(this, `action ${JSON.stringify(tr.action)} already attached to origin ${JSON.stringify(tr.from)}`);
-        } else {
-          actionMap.set(tr.from, thisEdgeId);
-        }
+  // sparse_props(name: string): object {
 
+  // }
 
-        // reverse mapping first by state origin name
-        let rActionMap: Map = this._reverse_actions.get(tr.from);
-        if (!(rActionMap)) {
-          rActionMap = new Map();
-          this._reverse_actions.set(tr.from, rActionMap);
-        }
 
-        // no need to test for reverse mapping pre-presence;
-        // forward mapping already covers collisions
-        rActionMap.set(tr.action, thisEdgeId);
 
 
-        // reverse mapping first by state target name
-        if (!(this._reverse_action_targets.has(tr.to))) {
-          this._reverse_action_targets.set(tr.to, new Map());
-        }
 
-        /* todo comeback
-           fundamental problem is roActionMap needs to be a multimap
-                const roActionMap = this._reverse_action_targets.get(tr.to);  // wasteful - already did has - refactor
-                if (roActionMap) {
-                  if (roActionMap.has(tr.action)) {
-                    throw new JssmError(this, `ro-action ${tr.to} already attached to action ${tr.action}`);
-                  } else {
-                    roActionMap.set(tr.action, thisEdgeId);
-                  }
-                } else {
-                  throw new JssmError(this, `should be impossible - flow doesn\'t know .set precedes .get yet again.  severe error?');
-                }
-        */
-      }
+  // NEEDS_DOCS
+  // TODO COMEBACK
+  /*********
+   *
+   *  Get the current value of every prop, as an object.  Compare
+   *  {@link prop_map}, which returns a `Map`.  Akin to {@link strict_prop},
+   *  this throws if a required prop is missing.
+   *
+   *  ```typescript
+   *
+   *  ```
+   *
+   */
 
-    });
+  // strict_props(name: string): object {
 
-  }
+  // }
 
 
 
 
 
-  /********
+  /*********
    *
-   *  Internal method for fabricating states.  Not meant for external use.
+   *  Check whether a given string is a known property's name.
    *
-   *  @internal
+   *  ```typescript
+   *  const example = sm`property foo default 1; a->b;`;
+   *
+   *  example.known_prop('foo');  // true
+   *  example.known_prop('bar');  // false
+   *  ```
+   *
+   *  @param prop_name The relevant property name to look up
    *
    */
 
-  _new_state(state_config: JssmGenericState): StateType {
+  known_prop(prop_name: string): boolean {
+    return this._property_keys.has(prop_name);
+  }
 
-    if (this._states.has(state_config.name)) {
-      throw new JssmError(this, `state ${JSON.stringify(state_config.name)} already exists`);
-    }
 
-    this._states.set(state_config.name, state_config);
-    return state_config.name;
 
+
+
+  // NEEDS_DOCS
+
+  /*********
+   *
+   *  List all known property names.  If you'd also like values, use
+   *  {@link props} instead.  The order of the properties is not defined, and
+   *  the properties generally will not be sorted.
+   *
+   *  ```typescript
+   *  ```
+   *
+   */
+
+  known_props(): string[] {
+    return [... this._property_keys];
   }
 
 
 
 
 
-  /*********
+  /********
    *
-   *  Get the current state of a machine.
+   *  Check whether a given state is a valid start state (either because it was
+   *  explicitly named as such, or because it was the first mentioned state.)
    *
    *  ```typescript
-   *  import * as jssm from 'jssm';
+   *  import { sm, is_start_state } from 'jssm';
+   *
+   *  const example = sm`a -> b;`;
    *
-   *  const switch = jssm.from('on <=> off;');
-   *  console.log( switch.state() );             // 'on'
+   *  console.log( final_test.is_start_state('a') );   // true
+   *  console.log( final_test.is_start_state('b') );   // false
    *
-   *  switch.transition('off');
-   *  console.log( switch.state() );             // 'off'
+   *  const example = sm`start_states: [a b]; a -> b;`;
+   *
+   *  console.log( final_test.is_start_state('a') );   // true
+   *  console.log( final_test.is_start_state('b') );   // true
    *  ```
    *
    *  @typeparam mDT The type of the machine data member; usually omitted
    *
+   *  @param whichState The name of the state to check
+   *
    */
 
-  state(): StateType {
-    return this._state;
+  is_start_state(whichState: StateType): boolean {
+    return this._start_states.has(whichState);
   }
 
-  /* whargarbl todo major
-     when we reimplement this, reintroduce this change to the is_final call
-
-    is_changing(): boolean {
-      return true; // todo whargarbl
-    }
-  */
-
 
 
 
 
-  /*********
+  /********
    *
-   *  Get the current data of a machine.
+   *  Check whether a given state is a valid start state (either because it was
+   *  explicitly named as such, or because it was the first mentioned state.)
    *
    *  ```typescript
-   *  import * as jssm from 'jssm';
+   *  import { sm, is_end_state } from 'jssm';
+   *
+   *  const example = sm`a -> b;`;
+   *
+   *  console.log( final_test.is_start_state('a') );   // false
+   *  console.log( final_test.is_start_state('b') );   // true
    *
-   *  const switch = jssm.from('on <=> off;', {data: 1});
-   *  console.log( switch.data() );              // 1
+   *  const example = sm`end_states: [a b]; a -> b;`;
+   *
+   *  console.log( final_test.is_start_state('a') );   // true
+   *  console.log( final_test.is_start_state('b') );   // true
    *  ```
    *
    *  @typeparam mDT The type of the machine data member; usually omitted
    *
+   *  @param whichState The name of the state to check
+   *
    */
 
-  data(): mDT {
-    return this._data;
+  is_end_state(whichState: StateType): boolean {
+    return this._end_states.has(whichState);
   }
 
-  /* whargarbl todo major
-     when we reimplement this, reintroduce this change to the is_final call
-
-    is_changing(): boolean {
-      return true; // todo whargarbl
-    }
-  */
 
 
 
@@ -1102,7 +1106,7 @@ class Machine {
    */
 
   state_is_final(whichState: StateType): boolean {
-    return ((this.state_is_terminal(whichState)) && (this.state_is_complete(whichState)));
+    return ((this.state_is_terminal(whichState)) || (this.state_is_complete(whichState)));
   }
 
 
@@ -1115,7 +1119,7 @@ class Machine {
    *  `complete`.)
    *
    *  ```typescript
-   *  import { sm, state_is_final } from 'jssm';
+   *  import { sm, is_final } from 'jssm';
    *
    *  const final_test = sm`first -> second;`;
    *
@@ -1124,8 +1128,6 @@ class Machine {
    *  console.log( final_test.is_final() );   // true
    *  ```
    *
-   *  @typeparam mDT The type of the machine data member; usually omitted
-   *
    */
 
   is_final(): boolean {
@@ -1137,6 +1139,37 @@ class Machine {
 
 
 
+  /********
+   *
+   *  Serialize the current machine, including all defining state but not the
+   *  machine string, to a structure.  This means you will need the machine
+   *  string to recreate (to not waste repeated space;) if you want the machine
+   *  string embedded, call {@link serialize_with_string} instead.
+   *
+   *  @typeparam mDT The type of the machine data member; usually omitted
+   *
+   */
+
+  serialize(comment?: string | undefined): JssmSerialization {
+
+    return {
+
+      comment,
+      state            : this._state,
+      data             : this._data,
+      jssm_version     : version,
+      history          : this._history.toArray(),
+      history_capacity : this._history.capacity,
+      timestamp        : new Date().getTime(),
+
+    };
+
+  }
+
+
+
+
+
   graph_layout(): string {
     return this._graph_layout;
   }
@@ -1216,12 +1249,6 @@ class Machine {
 
   }
 
-  /*
-    load_machine_state(): boolean {
-      return false; // todo whargarbl
-    }
-  */
-
 
 
 
@@ -1234,8 +1261,8 @@ class Machine {
    *  ```typescript
    *  import * as jssm from 'jssm';
    *
-   *  const switch = jssm.from('on <=> off;');
-   *  console.log( switch.states() );             // ['on', 'off']
+   *  const lswitch = jssm.from('on <=> off;');
+   *  console.log( lswitch.states() );             // ['on', 'off']
    *  ```
    *
    *  @typeparam mDT The type of the machine data member; usually omitted
@@ -1251,9 +1278,15 @@ class Machine {
 
 
   state_for(whichState: StateType): JssmGenericState {
+
     const state: JssmGenericState = this._states.get(whichState);
-    if (state) { return state; }
-    else { throw new JssmError(this, 'No such state', { requested_state: whichState }); }
+
+    if (state) {
+      return state;
+    } else {
+      throw new JssmError(this, 'No such state', { requested_state: whichState });
+    }
+
   }
 
 
@@ -1267,10 +1300,10 @@ class Machine {
    *  ```typescript
    *  import * as jssm from 'jssm';
    *
-   *  const switch = jssm.from('on <=> off;');
+   *  const lswitch = jssm.from('on <=> off;');
    *
-   *  console.log( switch.has_state('off') );     // true
-   *  console.log( switch.has_state('dance') );   // false
+   *  console.log( lswitch.has_state('off') );     // true
+   *  console.log( lswitch.has_state('dance') );   // false
    *  ```
    *
    *  @typeparam mDT The type of the machine data member; usually omitted
@@ -1321,7 +1354,7 @@ class Machine {
    *
    */
 
-  list_edges(): Array> {
+  list_edges(): Array> {
     return this._edges;
   }
 
@@ -1333,10 +1366,105 @@ class Machine {
     return Array.from(this._actions.keys());
   }
 
+  get uses_actions(): boolean {
+    return Array.from(this._actions.keys()).length > 0;
+  }
+
+  get uses_forced_transitions(): boolean {
+    return this._has_forced_transitions;
+  }
+
+
+
+
+
+  /*********
+   *
+   *  Check if the code that built the machine allows overriding state and data.
+   *
+   */
+
+  get code_allows_override(): JssmAllowsOverride {
+    return this._code_allows_override;
+  }
+
+
+
+
+
+  /*********
+   *
+   *  Check if the machine config allows overriding state and data.
+   *
+   */
+
+  get config_allows_override(): JssmAllowsOverride {
+    return this._config_allows_override;
+  }
+
+
+
+
+
+  /*********
+   *
+   *  Check if a machine allows overriding state and data.
+   *
+   */
+
+  get allows_override(): JssmAllowsOverride {
+
+    // code false?  config true, throw.  config false, false.  config undefined, false.
+    if (this._code_allows_override === false) {
+      /* istanbul ignore next */
+      if (this._config_allows_override === true) {
+        /* istanbul ignore next */
+        throw new JssmError(this, "Code specifies no override, but config tries to permit; config may not be less strict than code; should be unreachable");
+      } else {
+        return false;
+      }
+    }
+
+    // code true?  config true, true.  config false, false.  config undefined, true.
+    if (this._code_allows_override === true) {
+      if (this._config_allows_override === false) {
+        return false;
+      } else {
+        return true;
+      }
+    }
+
+    // code must be undefined.  config false, false.  config true, true.  config undefined, false.
+    if (this._config_allows_override === true) {
+      return true;
+    } else {
+      return false;
+    }
+
+  }
+
+
+
+
+
+  all_themes(): FslTheme[] {
+    return [... theme_mapping.keys()];     // constructor sets this to "default" otherwise
+  }
+
+  // This will always return an array of FSL themes; the reason we spuriously
+  // add the single type is that the setter and getter need matching accept/return
+  // types, and the setter can take both as a convenience
 
+  get themes(): FslTheme | FslTheme[] {
+    return this._themes;     // constructor sets this to "default" otherwise
+  }
 
-  theme(): FslTheme {
-    return this._theme;  // constructor sets this to "default" otherwise
+  set themes(to: FslTheme | FslTheme[]) {
+    if (typeof to === 'string') {
+      this._themes = [to];
+    } else {
+      this._themes = to;
+    }
   }
 
   flow(): FslDirection {
@@ -1359,7 +1487,7 @@ class Machine {
 
 
 
-  lookup_transition_for(from: StateType, to: StateType): JssmTransition {
+  lookup_transition_for(from: StateType, to: StateType): JssmTransition {
     const id: number = this.get_transition_by_state_names(from, to);
     return ((id === undefined) || (id === null)) ? undefined : this._edges[id];
   }
@@ -1400,7 +1528,10 @@ class Machine {
   /********
    *
    *  List all entrances attached to the current state.  Please note that the
-   *  order of the list is not defined.
+   *  order of the list is not defined.  This list includes both unforced and
+   *  forced entrances; if this isn't desired, consider
+   *  {@link list_unforced_entrances} or {@link list_forced_entrances} as
+   *  appropriate.
    *
    *  ```typescript
    *  import { sm } from 'jssm';
@@ -1418,9 +1549,10 @@ class Machine {
    */
 
   list_entrances(whichState: StateType = this.state()): Array {
-    return (this._states.get(whichState)
-      || { from: undefined }).from
-      || [];
+
+    const guaranteed = (this._states.get(whichState) ?? { from: undefined });
+    return guaranteed.from ?? [];
+
   }
 
 
@@ -1430,7 +1562,9 @@ class Machine {
   /********
    *
    *  List all exits attached to the current state.  Please note that the order
-   *  of the list is not defined.
+   *  of the list is not defined.  This list includes both unforced and forced
+   *  exits; if this isn't desired, consider {@link list_unforced_exits} or
+   *  {@link list_forced_exits} as appropriate.
    *
    *  ```typescript
    *  import { sm } from 'jssm';
@@ -1448,25 +1582,26 @@ class Machine {
    */
 
   list_exits(whichState: StateType = this.state()): Array {
-    return (this._states.get(whichState)
-      || { to: undefined }).to
-      || [];
+
+    const guaranteed = (this._states.get(whichState) ?? { to: undefined });
+    return guaranteed.to ?? [];
+
   }
 
 
 
 
 
-  probable_exits_for(whichState: StateType): Array> {
+  probable_exits_for(whichState: StateType): Array> {
 
     const wstate: JssmGenericState = this._states.get(whichState);
     if (!(wstate)) { throw new JssmError(this, `No such state ${JSON.stringify(whichState)} in probable_exits_for`); }
 
     const wstate_to: Array = wstate.to,
 
-      wtf: Array> // wstate_to_filtered -> wtf
+      wtf: Array> // wstate_to_filtered -> wtf
         = wstate_to
-          .map((ws): JssmTransition => this.lookup_transition_for(this.state(), ws))
+          .map((ws): JssmTransition => this.lookup_transition_for(this.state(), ws))
           .filter(Boolean);
 
     return wtf;
@@ -1474,7 +1609,7 @@ class Machine {
   }
 
   probabilistic_transition(): boolean {
-    const selected: JssmTransition = weighted_rand_select(this.probable_exits_for(this.state()));
+    const selected: JssmTransition = weighted_rand_select(this.probable_exits_for(this.state()));
     return this.transition(selected.to);
   }
 
@@ -1604,9 +1739,9 @@ class Machine {
     }
 
     return Array.from(ra_base.values())
-      .map((edgeId: number): JssmTransition => this._edges[edgeId])
-      .filter((o: JssmTransition): boolean => o.from === whichState)
-      .map((filtered: JssmTransition): StateType => filtered.action);
+      .map((edgeId: number): JssmTransition => this._edges[edgeId])
+      .filter((o: JssmTransition): boolean => o.from === whichState)
+      .map((filtered: JssmTransition): StateType => filtered.action);
 
   }
 
@@ -1619,8 +1754,8 @@ class Machine {
     if (!(ra_base)) { throw new JssmError(this, `No such state ${JSON.stringify(whichState)}`); }
 
     return Array.from(ra_base.values())
-      .map((edgeId: number): JssmTransition => this._edges[edgeId])
-      .filter((o: JssmTransition): boolean => o.from === whichState)
+      .map((edgeId: number): JssmTransition => this._edges[edgeId])
+      .filter((o: JssmTransition): boolean => o.from === whichState)
       .map((filtered): any => ({
         action: filtered.action,          // TODO FIXME no any
         probability: filtered.probability
@@ -1988,14 +2123,53 @@ class Machine {
 
 
 
-  // remove_hook(HookDesc: HookDescription) {
-  //   throw new JssmError(this, 'TODO: Should remove hook here');
-  // }
+  // remove_hook(HookDesc: HookDescription) {
+  //   throw new JssmError(this, 'TODO: Should remove hook here');
+  // }
+
+
+
+  edges_between(from: string, to: string): JssmTransition[] {
+    return this._edges.filter( edge => ((edge.from === from) && (edge.to === to)) );
+  }
+
+
+
+  /*********
+   *
+   *  Replace the current state and data with no regard to the graph.
+   *
+   *  ```typescript
+   *  import { sm } from 'jssm';
+   *
+   *  const machine = sm`a -> b -> c;`;
+   *  console.log( machine.state() );    // 'a'
+   *
+   *  machine.go('b');
+   *  machine.go('c');
+   *  console.log( machine.state() );    // 'c'
+   *
+   *  machine.override('a');
+   *  console.log( machine.state() );    // 'a'
+   *  ```
+   *
+   */
+
+  override(newState: StateType, newData?: mDT | undefined) {
+
+    if (this.allows_override) {
 
+      if (this._states.has(newState)) {
+        this._state = newState;
+        this._data  = newData;
+      } else {
+        throw new JssmError(this, `Cannot override state to "${newState}", a state that does not exist`);
+      }
 
+    } else {
+      throw new JssmError(this, "Code specifies no override, but config tries to permit; config may not be less strict than code");
+    }
 
-  edges_between(from: string, to: string): JssmTransition[] {
-    return this._edges.filter( edge => ((edge.from === from) && (edge.to === to)) );
   }
 
 
@@ -2019,11 +2193,11 @@ class Machine {
 
     } else if (wasAction) {
       if (this.valid_action(newStateOrAction, newData)) {
-        const edge: JssmTransition = this.current_action_edge_for(newStateOrAction);
-        valid                           = true;
-        trans_type                      = edge.kind;
-        newState                        = edge.to;
-        fromAction                      = newStateOrAction;
+        const edge: JssmTransition = this.current_action_edge_for(newStateOrAction);
+        valid                                      = true;
+        trans_type                                 = edge.kind;
+        newState                                   = edge.to;
+        fromAction                                 = newStateOrAction;
       }
 
     } else {
@@ -2038,11 +2212,12 @@ class Machine {
 
 
     const hook_args = {
-      data   : this._data,
-      action : fromAction,
-      from   : this._state,
-      to     : newState,
-      forced : wasForced,
+      data       : this._data,
+      action     : fromAction,
+      from       : this._state,
+      to         : newState,
+      next_data  : newData,
+      forced     : wasForced,
       trans_type
     };
 
@@ -2052,8 +2227,9 @@ class Machine {
 
         function update_fields(res: HookComplexResult) {
           if (res.hasOwnProperty('data')) {
-            hook_args.data = res.data;
-            data_changed   = true;
+            hook_args.data      = res.data;
+            hook_args.next_data = res.next_data;
+            data_changed        = true;
           }
         }
 
@@ -2365,7 +2541,7 @@ class Machine {
 
   /********
    *
-   *  Instruct the machine to complete an action.
+   *  Instruct the machine to complete an action.  Synonym for {@link do}.
    *
    *  ```typescript
    *  const light = sm`red 'next' -> green 'next' -> yellow 'next' -> red; [red yellow green] 'shutdown' ~> off 'start' -> red;`;
@@ -2393,14 +2569,389 @@ class Machine {
 
   /********
    *
-   *  Instruct the machine to complete a transition.
+   *  Get the standard style for a single state.  ***Does not*** include
+   *  composition from an applied theme, or things from the underlying base
+   *  stylesheet; only the modifications applied by this machine.
    *
    *  ```typescript
-   *  const light = sm`red -> green -> yellow -> red; [red yellow green] 'shutdown' ~> off 'start' -> red;`;
+   *  const light = sm`a -> b;`;
+   *  console.log(light.standard_state_style);
+   *  // {}
    *
-   *  light.state();               // 'red'
-   *  light.transition('green');   // true
-   *  light.state();               // 'green'
+   *  const light = sm`a -> b; state: { shape: circle; };`;
+   *  console.log(light.standard_state_style);
+   *  // { shape: 'circle' }
+   *  ```
+   *
+   *  @typeparam mDT The type of the machine data member; usually omitted
+   *
+   */
+
+  get standard_state_style(): JssmStateConfig {
+    return this._state_style;
+  }
+
+
+
+
+
+  /********
+   *
+   *  Get the hooked state style.  ***Does not*** include
+   *  composition from an applied theme, or things from the underlying base
+   *  stylesheet; only the modifications applied by this machine.
+   *
+   *  The hooked style is only applied to nodes which have a named hook in the
+   *  graph.  Open hooks set through the external API aren't graphed, because
+   *  that would be literally every node.
+   *
+   *  ```typescript
+   *  const light = sm`a -> b;`;
+   *  console.log(light.hooked_state_style);
+   *  // {}
+   *
+   *  const light = sm`a -> b; hooked_state: { shape: circle; };`;
+   *  console.log(light.hooked_state_style);
+   *  // { shape: 'circle' }
+   *  ```
+   *
+   *  @typeparam mDT The type of the machine data member; usually omitted
+   *
+   */
+
+  get hooked_state_style(): JssmStateConfig {
+    return this._hooked_state_style;
+  }
+
+
+
+
+
+  /********
+   *
+   *  Get the start state style.  ***Does not*** include composition from an
+   *  applied theme, or things from the underlying base stylesheet; only the
+   *  modifications applied by this machine.
+   *
+   *  Start states are defined by the directive `start_states`, or in absentia,
+   *  are the first mentioned state.
+   *
+   *  ```typescript
+   *  const light = sm`a -> b;`;
+   *  console.log(light.start_state_style);
+   *  // {}
+   *
+   *  const light = sm`a -> b; start_state: { shape: circle; };`;
+   *  console.log(light.start_state_style);
+   *  // { shape: 'circle' }
+   *  ```
+   *
+   *  @typeparam mDT The type of the machine data member; usually omitted
+   *
+   */
+
+  get start_state_style(): JssmStateConfig {
+    return this._start_state_style;
+  }
+
+
+
+
+
+  /********
+   *
+   *  Get the end state style.  ***Does not*** include
+   *  composition from an applied theme, or things from the underlying base
+   *  stylesheet; only the modifications applied by this machine.
+   *
+   *  End states are defined in the directive `end_states`, and are distinct
+   *  from terminal states.  End states are voluntary successful endpoints for a
+   *  process.  Terminal states are states that cannot be exited.  By example,
+   *  most error states are terminal states, but not end states.  Also, since
+   *  some end states can be exited and are determined by hooks, such as
+   *  recursive or iterative nodes, there is such a thing as an end state that
+   *  is not a terminal state.
+   *
+   *  ```typescript
+   *  const light = sm`a -> b;`;
+   *  console.log(light.standard_state_style);
+   *  // {}
+   *
+   *  const light = sm`a -> b; end_state: { shape: circle; };`;
+   *  console.log(light.standard_state_style);
+   *  // { shape: 'circle' }
+   *  ```
+   *
+   *  @typeparam mDT The type of the machine data member; usually omitted
+   *
+   */
+
+  get end_state_style(): JssmStateConfig {
+    return this._end_state_style;
+  }
+
+
+
+
+
+  /********
+   *
+   *  Get the terminal state style.  ***Does not*** include
+   *  composition from an applied theme, or things from the underlying base
+   *  stylesheet; only the modifications applied by this machine.
+   *
+   *  Terminal state styles are automatically determined by the machine.  Any
+   *  state without a valid exit transition is terminal.
+   *
+   *  ```typescript
+   *  const light = sm`a -> b;`;
+   *  console.log(light.terminal_state_style);
+   *  // {}
+   *
+   *  const light = sm`a -> b; terminal_state: { shape: circle; };`;
+   *  console.log(light.terminal_state_style);
+   *  // { shape: 'circle' }
+   *  ```
+   *
+   *  @typeparam mDT The type of the machine data member; usually omitted
+   *
+   */
+
+  get terminal_state_style(): JssmStateConfig {
+    return this._terminal_state_style;
+  }
+
+
+
+
+
+  /********
+   *
+   *  Get the style for the active state.  ***Does not*** include
+   *  composition from an applied theme, or things from the underlying base
+   *  stylesheet; only the modifications applied by this machine.
+   *
+   *  ```typescript
+   *  const light = sm`a -> b;`;
+   *  console.log(light.active_state_style);
+   *  // {}
+   *
+   *  const light = sm`a -> b; active_state: { shape: circle; };`;
+   *  console.log(light.active_state_style);
+   *  // { shape: 'circle' }
+   *  ```
+   *
+   *  @typeparam mDT The type of the machine data member; usually omitted
+   *
+   */
+
+  get active_state_style(): JssmStateConfig {
+    return this._active_state_style;
+  }
+
+
+
+
+
+  /*
+   */
+
+  // TODO COMEBACK IMPLEMENTME FIXME
+
+  // has_hooks(state: StateType): false {
+  //   return false;
+  // }
+
+
+
+
+
+  /********
+   *
+   *  Gets the composite style for a specific node by individually imposing the
+   *  style layers on a given object, after determining which layers are
+   *  appropriate.
+   *
+   *  The order of composition is base, then theme, then user content.  Each
+   *  item in the stack will be composited independently.  First, the base state
+   *  style, then the theme state style, then the user state style.
+   *
+   *  After the three state styles, we'll composite the hooked styles; then the
+   *  terminal styles; then the start styles; then the end styles; finally, the
+   *  active styles.  Remember, last wins.
+   *
+   *  The base state style must exist.  All other styles are optional.
+   *
+   *  @typeparam mDT The type of the machine data member; usually omitted
+   *
+   */
+
+  style_for(state: StateType): JssmStateConfig {
+
+
+    // first look up the themes
+    const themes: JssmBaseTheme[] = [];
+
+    this._themes.forEach(th => {
+
+      const theme_impl = theme_mapping.get(th);
+
+      if (theme_impl !== undefined) {
+        themes.push(theme_impl);
+      }
+
+    });
+
+    // basic state style
+    const layers = [ base_theme.state ];
+
+
+    themes.reverse().map(theme => {
+      if (theme.state) { layers.push(theme.state); }
+    });
+
+    if (this._state_style) { layers.push(this._state_style); }
+
+
+    // hooked state style
+    // if (this.has_hooks(state)) {
+    //   layers.push(base_theme.hooked);
+    //   themes.map(theme => {
+    //     if (theme.hooked) { layers.push(theme.hooked); }
+    //   });
+    //   if (this._hooked_state_style) { layers.push(this._hooked_state_style); }
+    // }
+
+
+    // terminal state style
+    if (this.state_is_terminal(state)) {
+      layers.push(base_theme.terminal);
+      themes.map(theme => {
+        if (theme.terminal) { layers.push(theme.terminal); }
+      });
+      if (this._terminal_state_style) { layers.push(this._terminal_state_style); }
+    }
+
+
+    // start state style
+    if (this.is_start_state(state)) {
+      layers.push(base_theme.start);
+      themes.map(theme => {
+        if (theme.start) { layers.push(theme.start); }
+      });
+      if (this._start_state_style) { layers.push(this._start_state_style); }
+    }
+
+
+    // end state style
+    if (this.is_end_state(state)) {
+      layers.push(base_theme.end);
+      themes.map(theme => {
+        if (theme.end) { layers.push(theme.end); }
+      });
+      if (this._end_state_style) { layers.push(this._end_state_style); }
+    }
+
+
+    // active state style
+    if (this.state() === state) {
+      layers.push(base_theme.active);
+      themes.map(theme => {
+        if (theme.active) { layers.push(theme.active); }
+      });
+      if (this._active_state_style) { layers.push(this._active_state_style); }
+    }
+
+
+    const individual_style : JssmStateConfig      = {},
+          decl             : JssmStateDeclaration = this._state_declarations.get(state);
+
+    individual_style.color           = decl?.color;
+    individual_style.textColor       = decl?.textColor;
+    individual_style.borderColor     = decl?.borderColor;
+    individual_style.backgroundColor = decl?.backgroundColor;
+    individual_style.lineStyle       = decl?.lineStyle;
+    individual_style.corners         = decl?.corners;
+    individual_style.shape           = decl?.shape;
+
+    layers.push(individual_style);
+
+
+    return layers.reduce((acc: JssmStateConfig, cur: JssmStateConfig) => {
+
+      const composite_state: JssmStateConfig = acc;
+      Object.keys(cur).forEach(key => composite_state[key] = cur[key] ?? composite_state[key]);
+
+      return composite_state;
+
+    }, {} as JssmStateConfig);
+
+  }
+
+
+
+
+
+  /********
+   *
+   *  Instruct the machine to complete an action.  Synonym for {@link action}.
+   *
+   *  ```typescript
+   *  const light = sm`
+   *    off 'start' -> red;
+   *    red 'next' -> green 'next' -> yellow 'next' -> red;
+   *    [red yellow green] 'shutdown' ~> off;
+   *  `;
+   *
+   *  light.state();       // 'off'
+   *  light.do('start');   // true
+   *  light.state();       // 'red'
+   *  light.do('next');    // true
+   *  light.state();       // 'green'
+   *  light.do('next');    // true
+   *  light.state();       // 'yellow'
+   *  light.do('dance');   // !! false - no such action
+   *  light.state();       // 'yellow'
+   *  light.do('start');   // !! false - yellow does not have the action start
+   *  light.state();       // 'yellow'
+   *  ```
+   *
+   *  @typeparam mDT The type of the machine data member; usually omitted
+   *
+   *  @param actionName The action to engage
+   *
+   *  @param newData The data change to insert during the action
+   *
+   */
+
+  do(actionName: StateType, newData?: mDT): boolean {
+    return this.transition_impl(actionName, newData, false, true);
+  }
+
+
+
+
+
+  /********
+   *
+   *  Instruct the machine to complete a transition.  Synonym for {@link go}.
+   *
+   *  ```typescript
+   *  const light = sm`
+   *    off 'start' -> red;
+   *    red 'next' -> green 'next' -> yellow 'next' -> red;
+   *    [red yellow green] 'shutdown' ~> off;
+   *  `;
+   *
+   *  light.state();       // 'off'
+   *  light.go('red');     // true
+   *  light.state();       // 'red'
+   *  light.go('green');   // true
+   *  light.state();       // 'green'
+   *  light.go('blue');    // !! false - no such state
+   *  light.state();       // 'green'
+   *  light.go('red');     // !! false - green may not go directly to red, only to yellow
+   *  light.state();       // 'green'
    *  ```
    *
    *  @typeparam mDT The type of the machine data member; usually omitted
@@ -2419,6 +2970,34 @@ class Machine {
 
 
 
+  /********
+   *
+   *  Instruct the machine to complete a transition.  Synonym for {@link transition}.
+   *
+   *  ```typescript
+   *  const light = sm`red -> green -> yellow -> red; [red yellow green] 'shutdown' ~> off 'start' -> red;`;
+   *
+   *  light.state();       // 'red'
+   *  light.go('green');   // true
+   *  light.state();       // 'green'
+   *  ```
+   *
+   *  @typeparam mDT The type of the machine data member; usually omitted
+   *
+   *  @param newState The state to switch to
+   *
+   *  @param newData The data change to insert during the transition
+   *
+   */
+
+  go(newState: StateType, newData?: mDT): boolean {
+    return this.transition_impl(newState, newData, false, false);
+  }
+
+
+
+
+
   /********
    *
    *  Instruct the machine to complete a forced transition (which will reject if
@@ -2457,7 +3036,7 @@ class Machine {
       : undefined;
   }
 
-  current_action_edge_for(action: StateType): JssmTransition {
+  current_action_edge_for(action: StateType): JssmTransition {
     const idx: number = this.current_action_for(action);
     if ((idx === undefined) || (idx === null)) { throw new JssmError(this, `No such action ${JSON.stringify(action)}`); }
     return this._edges[idx];
@@ -2472,7 +3051,7 @@ class Machine {
   valid_transition(newState: StateType, _newData?: mDT): boolean {  // todo comeback unignore newData
     // todo whargarbl implement data stuff
     // todo major incomplete whargarbl comeback
-    const transition_for: JssmTransition = this.lookup_transition_for(this.state(), newState);
+    const transition_for: JssmTransition = this.lookup_transition_for(this.state(), newState);
 
     if (!(transition_for)) { return false; }
     if (transition_for.forced_only) { return false; }
@@ -2519,7 +3098,7 @@ class Machine {
  *  ```typescript
  *  import * as jssm from 'jssm';
  *
- *  const switch = jssm.from('on <=> off;');
+ *  const lswitch = jssm.from('on <=> off;');
  *  ```
  *
  *  @typeparam mDT The type of the machine data member; usually omitted
@@ -2567,7 +3146,7 @@ function sm(template_strings: TemplateStringsArray, ...remainder /* , argum
  *  ```typescript
  *  import * as jssm from 'jssm';
  *
- *  const switch = jssm.from('on <=> off;');
+ *  const lswitch = jssm.from('on <=> off;');
  *  ```
  *
  *  @typeparam mDT The type of the machine data member; usually omitted
@@ -2578,12 +3157,18 @@ function sm(template_strings: TemplateStringsArray, ...remainder /* , argum
  *
  */
 
-function from(MachineAsString: string, ExtraConstructorFields?: Partial< JssmGenericConfig > | undefined): Machine {
+function from(MachineAsString: string, ExtraConstructorFields?: Partial< JssmGenericConfig > | undefined): Machine {
 
-  const to_decorate = make( MachineAsString );
+  const to_decorate = make( MachineAsString );
 
   if (ExtraConstructorFields !== undefined) {
-    Object.keys(ExtraConstructorFields).map(key => to_decorate[key] = ExtraConstructorFields[key]);
+    Object.keys(ExtraConstructorFields).map(key => {
+      if (key === 'allows_override') {
+        to_decorate['config_allows_override'] = ExtraConstructorFields['allows_override'];
+      } else {
+        to_decorate[key] = ExtraConstructorFields[key];
+      }
+    });
   }
 
   return new Machine( to_decorate );
@@ -2662,13 +3247,32 @@ function abstract_hook_step(maybe_hook: HookHandler | undefined, hook_
 
 
 
+function deserialize(machine_string: string, ser: JssmSerialization): Machine {
+
+  const machine  = from(machine_string, { data: ser.data, history: ser.history_capacity });
+  machine._state = ser.state;
+
+  ser.history.forEach( history_item =>
+    machine._history.push(history_item)
+  );
+
+  return machine;
+
+}
+
+
+
+
+
 export {
 
   version,
+    build_time,
 
   transfer_state_properties,
 
   Machine,
+  deserialize,
 
   make,
   wrap_parse as parse,
@@ -2683,17 +3287,25 @@ export {
 
   // WHARGARBL TODO these should be exported to a utility library
   seq,
+  unique, find_repeated,
   weighted_rand_select,
   histograph,
   weighted_sample_select,
   weighted_histo_key,
 
+  constants,
+
   shapes,
   gviz_shapes,
   named_colors,
 
   is_hook_rejection,
     is_hook_complex_result,
-    abstract_hook_step
+    abstract_hook_step,
+
+  state_style_condense,
+
+  FslDirections
+//  FslThemes
 
 };
diff --git a/src/ts/jssm_arrow.ts b/src/ts/jssm_arrow.ts
new file mode 100644
index 00000000..400683e0
--- /dev/null
+++ b/src/ts/jssm_arrow.ts
@@ -0,0 +1,192 @@
+
+import { JssmArrow, JssmArrowDirection, JssmArrowKind } from './jssm_types';
+import { JssmError }                                    from './jssm_error';
+
+
+
+
+
+/* eslint-disable complexity */
+
+/*********
+ *
+ *  Return the direction of an arrow - `right`, `left`, or `both`.
+ *
+ *  ```typescript
+ *  import { arrow_direction } from 'jssm';
+ *
+ *  arrow_direction('->');    // 'right'
+ *  arrow_direction('<~=>');  // 'both'
+ *  ```
+ *
+ *  @param arrow The arrow to be evaluated
+ *
+ */
+
+function arrow_direction(arrow: JssmArrow): JssmArrowDirection {
+
+  switch (String(arrow)) {
+
+    case '->': case '→':
+    case '=>': case '⇒':
+    case '~>': case '↛':
+      return 'right';
+
+    case '<-': case '←':
+    case '<=': case '⇐':
+    case '<~': case '↚':
+      return 'left';
+
+    case '<->': case '↔':
+    case '<-=>': case '←⇒': case '←=>': case '<-⇒':
+    case '<-~>': case '←↛': case '←~>': case '<-↛':
+
+    case '<=>': case '⇔':
+    case '<=->': case '⇐→': case '⇐->': case '<=→':
+    case '<=~>': case '⇐↛': case '⇐~>': case '<=↛':
+
+    case '<~>': case '↮':
+    case '<~->': case '↚→': case '↚->': case '<~→':
+    case '<~=>': case '↚⇒': case '↚=>': case '<~⇒':
+      return 'both';
+
+    default:
+      throw new JssmError(undefined, `arrow_direction: unknown arrow type ${arrow}`);
+
+  }
+
+}
+
+/* eslint-enable complexity */
+
+
+
+
+
+/* eslint-disable complexity */
+
+/*********
+ *
+ *  Return the direction of an arrow - `right`, `left`, or `both`.
+ *
+ *  ```typescript
+ *  import { arrow_left_kind } from 'jssm';
+ *
+ *  arrow_left_kind('<-');    // 'legal'
+ *  arrow_left_kind('<=');    // 'main'
+ *  arrow_left_kind('<~');    // 'forced'
+ *  arrow_left_kind('<->');   // 'legal'
+ *  arrow_left_kind('->');    // 'none'
+ *  ```
+ *
+ *  @param arrow The arrow to be evaluated
+ *
+ */
+
+function arrow_left_kind(arrow: JssmArrow): JssmArrowKind {
+
+  switch (String(arrow)) {
+
+    case '->': case '→':
+    case '=>': case '⇒':
+    case '~>': case '↛':
+      return 'none';
+
+    case '<-': case '←':
+    case '<->': case '↔':
+    case '<-=>': case '←⇒':
+    case '<-~>': case '←↛':
+      return 'legal';
+
+    case '<=': case '⇐':
+    case '<=>': case '⇔':
+    case '<=->': case '⇐→':
+    case '<=~>': case '⇐↛':
+      return 'main';
+
+    case '<~': case '↚':
+    case '<~>': case '↮':
+    case '<~->': case '↚→':
+    case '<~=>': case '↚⇒':
+      return 'forced';
+
+    default:
+      throw new JssmError(undefined, `arrow_direction: unknown arrow type ${arrow}`);
+
+  }
+
+}
+
+/* eslint-enable complexity */
+
+
+
+
+
+/* eslint-disable complexity */
+
+/*********
+ *
+ *  Return the direction of an arrow - `right`, `left`, or `both`.
+ *
+ *  ```typescript
+ *  import { arrow_left_kind } from 'jssm';
+ *
+ *  arrow_left_kind('->');    // 'legal'
+ *  arrow_left_kind('=>');    // 'main'
+ *  arrow_left_kind('~>');    // 'forced'
+ *  arrow_left_kind('<->');   // 'legal'
+ *  arrow_left_kind('<-');    // 'none'
+ *  ```
+ *
+ *  @param arrow The arrow to be evaluated
+ *
+ */
+
+function arrow_right_kind(arrow: JssmArrow): JssmArrowKind {
+
+  switch (String(arrow)) {
+
+    case '<-': case '←':
+    case '<=': case '⇐':
+    case '<~': case '↚':
+      return 'none';
+
+    case '->': case '→':
+    case '<->': case '↔':
+    case '<=->': case '⇐→':
+    case '<~->': case '↚→':
+      return 'legal';
+
+    case '=>': case '⇒':
+    case '<=>': case '⇔':
+    case '<-=>': case '←⇒':
+    case '<~=>': case '↚⇒':
+      return 'main';
+
+    case '~>': case '↛':
+    case '<~>': case '↮':
+    case '<-~>': case '←↛':
+    case '<=~>': case '⇐↛':
+      return 'forced';
+
+    default:
+      throw new JssmError(undefined, `arrow_direction: unknown arrow type ${arrow}`);
+
+  }
+
+}
+
+/* eslint-enable complexity */
+
+
+
+
+
+export {
+
+  arrow_direction,
+    arrow_left_kind,
+    arrow_right_kind
+
+};
diff --git a/src/ts/jssm_compiler.ts b/src/ts/jssm_compiler.ts
new file mode 100644
index 00000000..3191b1b9
--- /dev/null
+++ b/src/ts/jssm_compiler.ts
@@ -0,0 +1,537 @@
+
+import { JssmError } from './jssm_error';
+import { parse }     from './fsl_parser';
+
+import {
+  arrow_direction,
+  arrow_left_kind,
+  arrow_right_kind
+} from './jssm_arrow';
+
+import {
+  find_repeated,
+  name_bind_prop_and_state
+} from './jssm_util';
+
+import {
+  JssmTransition,
+    JssmTransitions,
+  JssmArrowKind,
+  JssmCompileSe,
+    JssmCompileSeStart,
+  JssmCompileRule,
+  JssmParseTree,
+  JssmStateConfig,
+  JssmGenericConfig,
+  JssmStateDeclaration,
+  JssmLayout,
+  JssmPropertyDefinition,
+  JssmAllowsOverride
+} from './jssm_types';
+
+import { reduce as reduce_to_639 } from 'reduce-to-639-1';
+
+
+
+
+
+/*********
+ *
+ *  Internal method meant to perform factory assembly of an edge.  Not meant for
+ *  external use.
+ *
+ *  @internal
+ *
+ *  @typeparam mDT The type of the machine data member; usually omitted
+ *
+ */
+
+// TODO add at-param to docblock
+
+function makeTransition(
+
+  this_se    : JssmCompileSe,
+  from       : StateType,
+  to         : StateType,
+  isRight    : boolean,
+  _wasList?  : Array,
+  _wasIndex? : number
+
+): JssmTransition {
+
+  const kind: JssmArrowKind = isRight
+                            ? arrow_right_kind(this_se.kind)
+                            : arrow_left_kind(this_se.kind),
+
+        edge: JssmTransition = {
+          from,
+          to,
+          kind,
+          forced_only : kind === 'forced',
+          main_path   : kind === 'main'
+        };
+
+  //  if ((wasList  !== undefined) && (wasIndex === undefined)) { throw new JssmError(undefined, `Must have an index if transition was in a list"); }
+  //  if ((wasIndex !== undefined) && (wasList  === undefined)) { throw new JssmError(undefined, `Must be in a list if transition has an index");   }
+  /*
+    if (typeof edge.to === 'object') {
+
+      if (edge.to.key === 'cycle') {
+        if (wasList === undefined) { throw new JssmError(undefined, "Must have a waslist if a to is type cycle"); }
+        const nextIndex = wrapBy(wasIndex, edge.to.value, wasList.length);
+        edge.to = wasList[nextIndex];
+      }
+
+    }
+  */
+
+  const action      : string = isRight ? 'r_action'      : 'l_action',
+        probability : string = isRight ? 'r_probability' : 'l_probability';
+
+  if (this_se[action])      { edge.action      = this_se[action]; }
+  if (this_se[probability]) { edge.probability = this_se[probability]; }
+
+  return edge;
+
+}
+
+
+
+
+
+/*********
+ *
+ *  This method wraps the parser call that comes from the peg grammar,
+ *  {@link parse}.  Generally neither this nor that should be used directly
+ *  unless you mean to develop plugins or extensions for the machine.
+ *
+ *  Parses the intermediate representation of a compiled string down to a
+ *  machine configuration object.  If you're using this (probably don't,) you're
+ *  probably also using {@link compile} and {@link Machine.constructor}.
+ *
+ *  ```typescript
+ *  import { parse, compile, Machine } from 'jssm';
+ *
+ *  const intermediate = wrap_parse('a -> b;', {});
+ *  // [ {key:'transition', from:'a', se:{kind:'->',to:'b'}} ]
+ *
+ *  const cfg = compile(intermediate);
+ *  // { start_states:['a'], transitions: [{ from:'a', to:'b', kind:'legal', forced_only:false, main_path:false }] }
+ *
+ *  const machine = new Machine(cfg);
+ *  // Machine { _instance_name: undefined, _state: 'a', ...
+ *  ```
+ *
+ *  This method is mostly for plugin and intermediate tool authors, or people
+ *  who need to work with the machine's intermediate representation.
+ *
+ *  # Hey!
+ *
+ *  Most people looking at this want either the `sm` operator or method `from`,
+ *  which perform all the steps in the chain.  The library's author mostly uses
+ *  operator `sm`, and mostly falls back to `.from` when needing to parse
+ *  strings dynamically instead of from template literals.
+ *
+ *  Operator {@link sm}:
+ *
+ *  ```typescript
+ *  import { sm } from 'jssm';
+ *
+ *  const lswitch = sm`on <=> off;`;
+ *  ```
+ *
+ *  Method {@link from}:
+ *
+ *  ```typescript
+ *  import * as jssm from 'jssm';
+ *
+ *  const toggle = jssm.from('up <=> down;');
+ *  ```
+ *
+ *  `wrap_parse` itself is an internal convenience method for alting out an
+ *  object as the options call.  Not generally meant for external use.
+ *
+ *  @param input The FSL code to be evaluated
+ *
+ *  @param options Things to control about the instance
+ *
+ */
+
+function wrap_parse(input: string, options?: Object) {
+  return parse(input, options || {});
+}
+
+
+
+
+
+/*********
+ *
+ *  Internal method performing one step in compiling rules for transitions.  Not
+ *  generally meant for external use.
+ *
+ *  @internal
+ *
+ *  @typeparam mDT The type of the machine data member; usually omitted
+ *
+ */
+
+function compile_rule_transition_step(
+
+  acc     : Array>,
+  from    : StateType,
+  to      : StateType,
+  this_se : JssmCompileSe,
+  next_se : JssmCompileSe
+
+): Array> { // todo typescript describe the parser representation of a transition step extension
+
+  const edges: Array> = [];
+
+  const uFrom : Array = ( Array.isArray(from) ? from : [from] ),
+        uTo   : Array = ( Array.isArray(to)   ? to   : [to]   );
+
+  uFrom.map( (f: StateType) => {
+    uTo.map( (t: StateType) => {
+
+      const right: JssmTransition = makeTransition(this_se, f, t, true);
+      if (right.kind !== 'none') { edges.push(right); }
+
+      const left: JssmTransition = makeTransition(this_se, t, f, false);
+      if (left.kind !== 'none') { edges.push(left); }
+
+    });
+  });
+
+  const new_acc: Array> = acc.concat(edges);
+
+  if (next_se) {
+    return compile_rule_transition_step(new_acc, to, next_se.to, next_se, next_se.se);
+  } else {
+    return new_acc;
+  }
+
+}
+
+
+
+/*********
+ *
+ *  Internal method performing one step in compiling rules for transitions.  Not
+ *  generally meant for external use.
+ *
+ *  @internal
+ *
+ */
+
+function compile_rule_handle_transition(rule: JssmCompileSeStart): any { // TODO FIXME no any // todo typescript describe the parser representation of a transition
+  return compile_rule_transition_step([], rule.from, rule.se.to, rule.se, rule.se.se);
+}
+
+
+
+/*********
+ *
+ *  Internal method performing one step in compiling rules for transitions.  Not
+ *  generally meant for external use.
+ *
+ *  @internal
+ *
+ */
+
+function compile_rule_handler(rule: JssmCompileSeStart): JssmCompileRule {
+
+  if (rule.key === 'transition') {
+    return { agg_as: 'transition', val: compile_rule_handle_transition(rule) };
+  }
+
+  if (rule.key === 'machine_language') {
+    return { agg_as: 'machine_language', val: reduce_to_639(rule.value) };
+  }
+
+  // manually rehandled to make `undefined` as a property safe
+  if (rule.key === 'property_definition') {
+    const ret: { agg_as: string, val: { name: string, default_value?: unknown, required?: boolean } }
+             = { agg_as: 'property_definition', val: { name: rule.name } };
+
+    if (rule.hasOwnProperty('default_value')) {
+      ret.val.default_value = rule.default_value;
+    }
+
+    if (rule.hasOwnProperty('required')) {
+      ret.val.required = rule.required;
+    }
+
+    return ret;
+  }
+
+  // state properties are in here
+  if (rule.key === 'state_declaration') {
+    if (!rule.name) { throw new JssmError(undefined, 'State declarations must have a name'); }
+    return { agg_as: 'state_declaration', val: { state: rule.name, declarations: rule.value } };
+  }
+
+  if (['arrange_declaration', 'arrange_start_declaration',
+    'arrange_end_declaration'].includes(rule.key)) {
+    return { agg_as: rule.key, val: [rule.value] };
+  }
+
+  // things that can only exist once and are just a value under their own name
+  const tautologies: Array = [
+    'graph_layout', 'start_states', 'end_states', 'machine_name', 'machine_version',
+    'machine_comment', 'machine_author', 'machine_contributor', 'machine_definition',
+    'machine_reference', 'machine_license', 'fsl_version', 'state_config', 'theme',
+    'flow', 'dot_preamble', 'allows_override', 'default_state_config',
+    'default_start_state_config', 'default_end_state_config',
+    'default_hooked_state_config', 'default_active_state_config',
+    'default_terminal_state_config'
+  ];
+
+  if (tautologies.includes(rule.key)) {
+    return { agg_as: rule.key, val: rule.value };
+  }
+
+  throw new JssmError(undefined, `compile_rule_handler: Unknown rule: ${JSON.stringify(rule)}`);
+
+}
+
+
+
+
+
+/*********
+ *
+ *  Compile a machine's JSON intermediate representation to a config object.  If
+ *  you're using this (probably don't,) you're probably also using
+ *  {@link parse} to get the IR, and the object constructor
+ *  {@link Machine.construct} to turn the config object into a workable machine.
+ *
+ *  ```typescript
+ *  import { parse, compile, Machine } from 'jssm';
+ *
+ *  const intermediate = parse('a -> b;');
+ *  // [ {key:'transition', from:'a', se:{kind:'->',to:'b'}} ]
+ *
+ *  const cfg = compile(intermediate);
+ *  // { start_states:['a'], transitions: [{ from:'a', to:'b', kind:'legal', forced_only:false, main_path:false }] }
+ *
+ *  const machine = new Machine(cfg);
+ *  // Machine { _instance_name: undefined, _state: 'a', ...
+ *  ```
+ *
+ *  This method is mostly for plugin and intermediate tool authors, or people
+ *  who need to work with the machine's intermediate representation.
+ *
+ *  # Hey!
+ *
+ *  Most people looking at this want either the `sm` operator or method `from`,
+ *  which perform all the steps in the chain.  The library's author mostly uses
+ *  operator `sm`, and mostly falls back to `.from` when needing to parse
+ *  strings dynamically instead of from template literals.
+ *
+ *  Operator {@link sm}:
+ *
+ *  ```typescript
+ *  import { sm } from 'jssm';
+ *
+ *  const lswitch = sm`on <=> off;`;
+ *  ```
+ *
+ *  Method {@link from}:
+ *
+ *  ```typescript
+ *  import * as jssm from 'jssm';
+ *
+ *  const toggle = jssm.from('up <=> down;');
+ *  ```
+ *
+ *  @typeparam mDT The type of the machine data member; usually omitted
+ *
+ *  @param tree The parse tree to be boiled down into a machine config
+ *
+ */
+
+function compile(tree: JssmParseTree): JssmGenericConfig {
+
+  const results: {
+    graph_layout                  : Array,
+    transition                    : Array>,
+    start_states                  : Array,
+    end_states                    : Array,
+    state_config                  : Array,           // TODO COMEBACK no any
+    state_declaration             : Array,
+    fsl_version                   : Array,
+    machine_author                : Array,
+    machine_comment               : Array,
+    machine_contributor           : Array,
+    machine_definition            : Array,
+    machine_language              : Array,
+    machine_license               : Array,
+    machine_name                  : Array,
+    machine_reference             : Array,
+    property_definition           : Array,
+    state_property                : { [name: string]: JssmPropertyDefinition },
+    theme                         : Array,
+    flow                          : Array,
+    dot_preamble                  : Array,
+    arrange_declaration           : Array>, // TODO COMEBACK CHECKME
+    arrange_start_declaration     : Array>, // TODO COMEBACK CHECKME
+    arrange_end_declaration       : Array>, // TODO COMEBACK CHECKME
+    machine_version               : Array,        // TODO COMEBACK semver
+    default_state_config          : Array,
+    default_active_state_config   : Array,
+    default_hooked_state_config   : Array,
+    default_terminal_state_config : Array,
+    default_start_state_config    : Array,
+    default_end_state_config      : Array,
+    allows_override               : Array
+  } = {
+    graph_layout                  : [],
+    transition                    : [],
+    start_states                  : [],
+    end_states                    : [],
+    state_config                  : [],
+    state_declaration             : [],
+    fsl_version                   : [],
+    machine_author                : [],
+    machine_comment               : [],
+    machine_contributor           : [],
+    machine_definition            : [],
+    machine_language              : [],
+    machine_license               : [],
+    machine_name                  : [],
+    machine_reference             : [],
+    property_definition           : [],
+    state_property                : {},
+    theme                         : [],
+    flow                          : [],
+    dot_preamble                  : [],
+    arrange_declaration           : [],
+    arrange_start_declaration     : [],
+    arrange_end_declaration       : [],
+    machine_version               : [],
+    default_state_config          : [],
+    default_active_state_config   : [],
+    default_hooked_state_config   : [],
+    default_terminal_state_config : [],
+    default_start_state_config    : [],
+    default_end_state_config      : [],
+    allows_override               : []
+  };
+
+  tree.map((tr: JssmCompileSeStart) => {
+
+    const rule   : JssmCompileRule = compile_rule_handler(tr),
+          agg_as : string                     = rule.agg_as,
+          val    : any                        = rule.val;                  // TODO FIXME no any
+
+    results[agg_as] = results[agg_as].concat(val)
+
+  });
+
+  const property_keys = results['property_definition'].map(pd => pd.name),
+        repeat_props  = find_repeated(property_keys);
+
+  if (repeat_props.length) {
+    throw new JssmError(undefined, `Cannot repeat property definitions.  Saw ${JSON.stringify(repeat_props)}`);
+  }
+
+  const assembled_transitions: JssmTransitions = [].concat(...results['transition']);
+
+  const result_cfg: JssmGenericConfig = {
+    start_states   : results.start_states.length ? results.start_states : [assembled_transitions[0].from],
+    end_states     : results.end_states,
+    transitions    : assembled_transitions,
+    state_property : [],
+  };
+
+  const oneOnlyKeys: Array = [
+    'graph_layout', 'machine_name', 'machine_version', 'machine_comment',
+    'fsl_version', 'machine_license', 'machine_definition', 'machine_language',
+    'flow', 'dot_preamble', 'allows_override'
+  ];
+
+  oneOnlyKeys.map((oneOnlyKey: string) => {
+    if (results[oneOnlyKey].length > 1) {
+      throw new JssmError(undefined,
+        `May only have one ${oneOnlyKey} statement maximum: ${JSON.stringify(results[oneOnlyKey])}`
+      );
+    } else {
+      if (results[oneOnlyKey].length) {
+        result_cfg[oneOnlyKey] = results[oneOnlyKey][0];
+      }
+    }
+  });
+
+  ['arrange_declaration', 'arrange_start_declaration', 'arrange_end_declaration',
+   'machine_author', 'machine_contributor', 'machine_reference', 'theme',
+   'state_declaration', 'property_definition', 'default_state_config',
+   'default_start_state_config', 'default_end_state_config',
+   'default_hooked_state_config', 'default_terminal_state_config',
+   'default_active_state_config'].map(
+      (multiKey: string) => {
+        if (results[multiKey].length) {
+          result_cfg[multiKey] = results[multiKey];
+        }
+      }
+    );
+
+  // re-walk state declarations, already wrapped up, to get state properties,
+  // which go out in a different datastructure
+  results.state_declaration.forEach(sd => {
+    sd.declarations.forEach(decl => {
+
+      if (decl.key === 'state_property') {
+        const label = name_bind_prop_and_state(decl.name, sd.state)
+
+        if (result_cfg.state_property.findIndex(c => c.name === label) !== -1) {
+          throw new JssmError(undefined, `A state may only bind a property once (${sd.state} re-binds ${decl.name})`);
+        } else {
+          result_cfg.state_property.push({ name: label, default_value: decl.value });
+        }
+      }
+
+    });
+  });
+
+  return result_cfg;
+
+}
+
+
+
+
+
+/*********
+ *
+ *  An internal convenience wrapper for parsing then compiling a machine string.
+ *  Not generally meant for external use.  Please see {@link compile} or
+ *  {@link sm}.
+ *
+ *  @typeparam mDT The type of the machine data member; usually omitted
+ *
+ *  @param plan The FSL code to be evaluated and built into a machine config
+ *
+ */
+
+function make(plan: string): JssmGenericConfig {
+  return compile(wrap_parse(plan));
+}
+
+
+
+
+
+export {
+
+  compile,
+    // compile_rule_handler,
+    // compile_rule_transition_step,
+    // compile_rule_handle_transition,
+
+  make,
+    makeTransition,
+
+  wrap_parse
+
+};
diff --git a/src/ts/jssm_constants.ts b/src/ts/jssm_constants.ts
index c55c3a41..9b4d72fc 100644
--- a/src/ts/jssm_constants.ts
+++ b/src/ts/jssm_constants.ts
@@ -1,4 +1,24 @@
 
+export const NegInfinity = Number.NEGATIVE_INFINITY,
+             PosInfinity = Number.POSITIVE_INFINITY,
+             Epsilon     = Number.EPSILON,
+             Pi          = Math.PI,
+             E           = Math.E,
+             Root2       = Math.SQRT2,
+             RootHalf    = Math.SQRT1_2,
+             Ln2         = Math.LN2,
+             Ln10        = Math.LN10,
+             Log2E       = Math.LOG2E,
+             Log10E      = Math.LOG10E,
+             MaxSafeInt  = Number.MAX_SAFE_INTEGER,
+             MinSafeInt  = Number.MIN_SAFE_INTEGER,
+             MaxPosNum   = Number.MAX_VALUE,
+             MinPosNum   = Number.MIN_VALUE,
+             Phi         = 1.61803398874989484820,
+             EulerC      = 0.57721566490153286060;
+
+
+
 const gviz_shapes = [
   "box3d",
   "polygon",
@@ -102,4 +122,11 @@ const named_colors = [
 
 
 
-export { gviz_shapes, shapes, named_colors };
+export {
+
+  gviz_shapes,
+    shapes,
+
+  named_colors,
+
+};
diff --git a/src/ts/jssm_theme.ts b/src/ts/jssm_theme.ts
new file mode 100644
index 00000000..95acc4af
--- /dev/null
+++ b/src/ts/jssm_theme.ts
@@ -0,0 +1,32 @@
+
+import { FslTheme, JssmBaseTheme } from './jssm_types';
+
+
+
+
+
+import { base_theme }    from './themes/jssm_base_stylesheet';
+
+import { default_theme } from './themes/jssm_theme_default';
+import { modern_theme }  from './themes/jssm_theme_modern';
+import { ocean_theme }   from './themes/jssm_theme_ocean';
+import { plain_theme }   from './themes/jssm_theme_plain';
+import { bold_theme }    from './themes/jssm_theme_bold';
+
+
+
+
+
+const theme_mapping: Map = new Map();
+
+theme_mapping.set('default', default_theme);
+theme_mapping.set('modern',  modern_theme);
+theme_mapping.set('ocean',   ocean_theme);
+theme_mapping.set('plain',   plain_theme);
+theme_mapping.set('bold',    bold_theme);
+
+
+
+
+
+export { theme_mapping, base_theme };
diff --git a/src/ts/jssm_types.ts b/src/ts/jssm_types.ts
index 65c6530c..b80915d6 100644
--- a/src/ts/jssm_types.ts
+++ b/src/ts/jssm_types.ts
@@ -1,4 +1,10 @@
 
+import { circular_buffer } from 'circular_buffer_js';
+
+
+
+
+
 type StateType = string;
 
 
@@ -47,18 +53,43 @@ type JssmLayout         = 'dot' | 'circo' | 'twopi' | 'fdp';  // todo add the re
 type JssmCorner         = 'regular' | 'rounded' | 'lined';
 type JssmLineStyle      = 'solid' | 'dashed' | 'dotted';
 
+type JssmAllowsOverride = true | false | undefined;
+
+
+
+
+
+const FslDirections     = ['up', 'right', 'down', 'left'] as const;
+type  FslDirection      = typeof FslDirections[number];
+
+const FslThemes         = ['default', 'ocean', 'modern', 'plain', 'bold'] as const;
+type  FslTheme          = typeof FslThemes[number];
+
 
 
 
 
-type FslDirection       = 'up' | 'right' | 'down' | 'left';
-type FslTheme           = 'default' | 'ocean' | 'modern' | 'none';
+type JssmSerialization = {
 
+  jssm_version     : string,
+  timestamp        : number,
+  comment?         : string | undefined,
+  state            : StateType,
+  history          : [string, DataType][],
+  history_capacity : number,
+  data             : DataType
+
+};
 
 
 
 
-type State = string;
+
+type JssmPropertyDefinition = {
+  name           : string,
+  default_value? : any,
+  required?      : boolean
+};
 
 
 
@@ -75,11 +106,11 @@ type JssmTransitionPermitterMaybeArray =
 
 
 
-type JssmTransition = {
+type JssmTransition = {
 
   from         : StateType,
   to           : StateType,
-  name?        : string,
+  name?        : StateType,
   action?      : StateType,
   check?       : JssmTransitionPermitterMaybeArray,  // validate this edge's transition; usually about data
   probability? : number,                                       // for stoch modelling, would like to constrain to [0..1], dunno how // TODO FIXME
@@ -89,8 +120,8 @@ type JssmTransition = {
 
 };
 
-type JssmTransitions =
-  Array< JssmTransition >;
+type JssmTransitions =
+  JssmTransition[];
 
 type JssmTransitionList = {
   entrances : Array,
@@ -133,7 +164,7 @@ type JssmMachineInternalState = {
   edge_map                    : Map< StateType, Map >,
   actions                     : Map< StateType, Map >,
   reverse_actions             : Map< StateType, Map >,
-  edges                       : Array< JssmTransition >
+  edges                       : Array< JssmTransition >
 
 };
 
@@ -153,7 +184,7 @@ type JssmGenericMachine = {
   state            : StateType,
   data?            : DataType,
   nodes?           : Array,
-  transitions      : JssmTransitions,
+  transitions      : JssmTransitions,
   check?           : JssmStatePermitterMaybeArray,
 
   min_transitions? : number,
@@ -172,8 +203,9 @@ type JssmGenericMachine = {
 
 
 type JssmStateDeclarationRule = {
-  key   : string,
-  value : any  // TODO FIXME COMEBACK enumerate types against concrete keys
+  key       : string,
+  value     : any,  // TODO FIXME COMEBACK enumerate types against concrete keys
+  name?     : string
 };
 
 type JssmStateDeclaration = {
@@ -183,69 +215,134 @@ type JssmStateDeclaration = {
   shape?           : JssmShape,
   color?           : JssmColor,
   corners?         : JssmCorner,
-  linestyle?       : JssmLineStyle,
+  lineStyle?       : JssmLineStyle,
+
+  stateLabel?      : string,
 
   textColor?       : JssmColor,
   backgroundColor? : JssmColor,
   borderColor?     : JssmColor,
 
-  state            : StateType
+  state            : StateType,
+  property?        : { name: string, value: unknown }
 
 };
 
+type JssmStateConfig = Partial;
+
+type JssmStateStyleShape           = { key: 'shape',            value: JssmShape     };
+type JssmStateStyleColor           = { key: 'color',            value: JssmColor     };
+type JssmStateStyleTextColor       = { key: 'text-color',       value: JssmColor     };
+type JssmStateStyleCorners         = { key: 'corners',          value: JssmCorner    };
+type JssmStateStyleLineStyle       = { key: 'line-style',       value: JssmLineStyle };
+type JssmStateStyleStateLabel      = { key: 'state-label',      value: string        };
+type JssmStateStyleBackgroundColor = { key: 'background-color', value: JssmColor     };
+type JssmStateStyleBorderColor     = { key: 'border-color',     value: JssmColor     };
+
+type JssmStateStyleKey     = JssmStateStyleShape | JssmStateStyleColor
+                           | JssmStateStyleTextColor | JssmStateStyleCorners
+                           | JssmStateStyleLineStyle | JssmStateStyleBackgroundColor
+                           | JssmStateStyleStateLabel | JssmStateStyleBorderColor;
 
+type JssmStateStyleKeyList = JssmStateStyleKey[];
 
 
 
-type JssmGenericConfig = {
 
-  graph_layout?              : JssmLayout,
 
-  complete?                  : Array,
-  transitions                : JssmTransitions,
+type JssmBaseTheme = {
 
-  theme?                     : FslTheme,
-  flow?                      : FslDirection,
+  name            : string,
 
-  name?                      : string,
-  data?                      : DataType,
-  nodes?                     : Array,  // uncommon
-  check?                     : JssmStatePermitterMaybeArray,
-  history?                   : number,
+  state           : JssmStateConfig,
+  hooked          : JssmStateConfig,
+  start           : JssmStateConfig,
+  end             : JssmStateConfig,
+  terminal        : JssmStateConfig,
 
-//locked?                    : bool = true,
-  min_exits?                 : number,
-  max_exits?                 : number,
-  allow_islands?             : false,
-  allow_force?               : false,
-  actions?                   : JssmPermittedOpt,
+  active          : JssmStateConfig,
+  active_hooked   : JssmStateConfig,
+  active_start    : JssmStateConfig,
+  active_end      : JssmStateConfig,
+  active_terminal : JssmStateConfig,
 
-  simplify_bidi?             : boolean,
+  graph           : undefined,
 
-  dot_preamble?              : string,
+  legal           : undefined,
+  main            : undefined,
+  forced          : undefined,
+
+  action          : undefined,
+  title           : undefined
+
+};
 
-  start_states               : Array,
-  end_states?                : Array,
+type JssmTheme = Partial;
 
-  state_declaration?         : Array,
 
-  arrange_declaration?       : Array>,
-  arrange_start_declaration? : Array>,
-  arrange_end_declaration?   : Array>,
 
-  machine_author?            : string | Array,
-  machine_comment?           : string,
-  machine_contributor?       : string | Array,
-  machine_definition?        : string,
-  machine_language?          : string,   // TODO FIXME COMEBACK
-  machine_license?           : string,   // TODO FIXME COMEBACK
-  machine_name?              : string,
-  machine_version?           : string,   // TODO FIXME COMEBACK
 
-  fsl_version?               : string,   // TODO FIXME COMEBACK
 
-  auto_api?                  : boolean | string, // TODO FIXME COMEBACK // boolean false means don't; boolean true means do; string means do-with-this-prefix
-  instance_name?             : string | undefined
+type JssmGenericConfig = {
+
+  graph_layout?                  : JssmLayout,
+
+  complete?                      : Array,
+  transitions                    : JssmTransitions,
+
+  theme?                         : FslTheme[],
+  flow?                          : FslDirection,
+
+  name?                          : string,
+  data?                          : DataType,
+  nodes?                         : Array,  // uncommon
+  check?                         : JssmStatePermitterMaybeArray,
+  history?                       : number,
+
+//locked?                        : bool = true,
+  min_exits?                     : number,
+  max_exits?                     : number,
+  allow_islands?                 : false,
+  allow_force?                   : false,
+  actions?                       : JssmPermittedOpt,
+
+  simplify_bidi?                 : boolean,
+  allows_override?               : JssmAllowsOverride,
+  config_allows_override?        : JssmAllowsOverride,
+
+  dot_preamble?                  : string,
+
+  start_states                   : Array,
+  end_states?                    : Array,
+
+  state_declaration?             : Object[],
+  property_definition?           : JssmPropertyDefinition[],
+  state_property?                : JssmPropertyDefinition[]
+
+  arrange_declaration?           : Array>,
+  arrange_start_declaration?     : Array>,
+  arrange_end_declaration?       : Array>,
+
+  machine_author?                : string | Array,
+  machine_comment?               : string,
+  machine_contributor?           : string | Array,
+  machine_definition?            : string,
+  machine_language?              : string,   // TODO FIXME COMEBACK
+  machine_license?               : string,   // TODO FIXME COMEBACK
+  machine_name?                  : string,
+  machine_version?               : string,   // TODO FIXME COMEBACK
+
+  fsl_version?                   : string,   // TODO FIXME COMEBACK
+
+  auto_api?                      : boolean | string, // TODO FIXME COMEBACK // boolean false means don't; boolean true means do; string means do-with-this-prefix
+  instance_name?                 : string | undefined,
+
+  default_state_config?          : JssmStateStyleKeyList,
+  default_start_state_config?    : JssmStateStyleKeyList,
+  default_end_state_config?      : JssmStateStyleKeyList,
+  default_hooked_state_config?   : JssmStateStyleKeyList,
+  default_terminal_state_config? : JssmStateStyleKeyList,
+  default_active_state_config?   : JssmStateStyleKeyList
 
 };
 
@@ -253,7 +350,7 @@ type JssmGenericConfig = {
 
 
 
-type JssmCompileRule = {
+type JssmCompileRule = {
 
   agg_as : string,
   val    : any      // TODO COMEBACK FIXME
@@ -264,10 +361,10 @@ type JssmCompileRule = {
 
 
 
-type JssmCompileSe = {
+type JssmCompileSe = {
 
   to            : StateType,
-  se            : JssmCompileSe,
+  se            : JssmCompileSe,
   kind          : JssmArrow,
   l_action?     : StateType,
   r_action?     : StateType,
@@ -280,13 +377,16 @@ type JssmCompileSe = {
 
 
 
-type JssmCompileSeStart = {
+type JssmCompileSeStart = {
 
-  from   : DataType,
-  se     : JssmCompileSe,
-  key    : string,
-  value? : string | number,
-  name?  : string
+  from           : StateType,
+  se             : JssmCompileSe,
+  key            : string,
+  value?         : string | number,
+  name?          : string,
+  state?         : string,
+  default_value? : any,     // for properties
+  required?      : boolean  // for properties
 
 };
 
@@ -294,17 +394,17 @@ type JssmCompileSeStart = {
 
 
 
-type JssmParseTree =
+type JssmParseTree =
 
-  Array< JssmCompileSeStart >;
+  Array< JssmCompileSeStart >;
 
 
 
 
 
-type JssmParseFunctionType =
+type JssmParseFunctionType =
 
-  (string) => JssmParseTree;
+  (string) => JssmParseTree;
 
 
 
@@ -460,9 +560,10 @@ type HookDescription
 
 /* Governs the return value from a hook when non-trivial; potentially carries final state, data; definitely carries whether passed */
 type HookComplexResult = {
-  pass   : boolean,    // DO NOT MAKE OPTIONAL, prevents accidental other objects
-  state? : StateType,
-  data?  : mDT,
+  pass       : boolean,    // DO NOT MAKE OPTIONAL, prevents accidental other objects
+  state?     : StateType,
+  data?      : mDT,
+  next_data? : mDT
 };
 
 type HookResult = true | false | undefined | void | HookComplexResult;  /** Documents whether a hook succeeded, either with a primitive or a reference to the hook complex object */
@@ -472,7 +573,8 @@ type HookResult = true | false | undefined | void | HookComplexResult;
 
 
 type HookContext = {
-  data: mDT
+  data      : mDT,
+  next_data : mDT
 };
 
 
@@ -497,6 +599,12 @@ type JssmErrorExtendedInfo = {
 
 
 
+type JssmHistory = circular_buffer<[StateType, mDT]>;
+
+
+
+
+
 export {
 
   JssmColor,
@@ -526,16 +634,31 @@ export {
 
   JssmStateDeclaration,
     JssmStateDeclarationRule,
+    JssmStateConfig,
+
+  JssmStateStyleKey,
+    JssmStateStyleKeyList,
+
+  JssmBaseTheme,
+    JssmTheme,
 
   JssmLayout,
 
+  JssmHistory,
+  JssmSerialization,
+  JssmPropertyDefinition,
+  JssmAllowsOverride,
+
   JssmParseFunctionType,
 
   JssmMachineInternalState,
 
   JssmErrorExtendedInfo,
 
-  FslDirection,
+  FslDirections,
+    FslDirection,
+
+  FslThemes,
     FslTheme,
 
   HookDescription,
diff --git a/src/ts/jssm_util.ts b/src/ts/jssm_util.ts
index df8aa17c..20b6d909 100644
--- a/src/ts/jssm_util.ts
+++ b/src/ts/jssm_util.ts
@@ -1,4 +1,10 @@
 
+import { JssmError } from './jssm_error';
+
+
+
+
+
 /*******
  *
  *  Predicate for validating an array for uniqueness.  Not generally meant for
@@ -136,6 +142,31 @@ const weighted_histo_key: Function = (n: number, opts: Array, prob_prop: st
 
 
 
+/*******
+ *
+ *  Internal method generating names for edges for the hook lookup map.  Not
+ *  meant for external use.
+ *
+ */
+
+function name_bind_prop_and_state(prop: string, state: string): string {
+
+  if (typeof prop  !== 'string') {
+    throw new JssmError(undefined, `Name of property must be a string; got ${prop}`);
+  }
+
+  if (typeof state !== 'string') {
+    throw new JssmError(undefined, `Name of state must be a string; got ${prop}`);
+  }
+
+  return JSON.stringify([prop, state]);
+
+}
+
+
+
+
+
 /*******
  *
  *  Internal method generating names for edges for the hook lookup map.  Not
@@ -192,13 +223,96 @@ const make_mulberry_rand = (a?: number | undefined) =>
 
 
 
+/*******
+ *
+ *  Reduces an array to its unique contents.  Compares with `===` and makes no
+ *  effort to deep-compare contents; two matching arrays or objects contained
+ *  will be treated as distinct, according to javascript rules.  This also means
+ *  that `NaNs` will be ***dropped***, because they do not self-compare.
+ *
+ *  ```typescript
+ *  unique( [] );                     // []
+ *  unique( [0,0] );                  // [0]
+ *  unique( [0,1,2, 0,1,2, 0,1,2] );  // [0,1,2]
+ *  unique( [ [1], [1] ] );           // [ [1], [1] ] because arrays don't match
+ *  unique( [0,NaN,2] );              // [0,2]
+ *  ```
+ *
+ */
+
+const unique = (arr?: T[]) =>
+
+  arr.filter( (v, i, a) => a.indexOf(v) === i );
+
+
+
+
+
+/*******
+ *
+ *  Lists all repeated items in an array along with their counts.  Subject to
+ *  matching rules of Map.  `NaN` is manually removed because of conflict rules
+ *  around {@link unique}.  Because these are compared with `===` and because
+ *  arrays and objects never match that way unless they're the same object,
+ *  arrays and objects are never considered repeats.
+ *
+ *  ```typescript
+ *  find_repeated([ ]);                     // []
+ *  find_repeated([ "one" ]);               // []
+ *  find_repeated([ "one", "two" ]);        // []
+ *  find_repeated([ "one", "one" ]);        // [ ["one", 2] ]
+ *  find_repeated([ "one", "two", "one" ]); // [ ["one", 2] ]
+ *  find_repeated([ 0, NaN, 0, NaN ]);      // [ [0,     2] ]
+ *  ```
+ *
+ */
+
+function find_repeated(arr: T[]): [T, number][] {
+
+  const uniqued = unique(arr);
+
+  if (uniqued.length !== arr.length) {
+
+    const residue_keys = new Map();
+
+    arr.forEach(k =>
+      residue_keys.set(
+        k,
+        residue_keys.has(k)
+          ? (residue_keys.get(k)+1)
+          : 1
+      )
+    );
+
+    uniqued.forEach(k =>
+      residue_keys.set(
+        k,
+        residue_keys.get(k) - 1
+      )
+    );
+
+    return [ ... residue_keys.entries() ]
+             .filter( (e) => ( (e[1] > 0) && (!(Number.isNaN(e[0]))) ) )
+             .map( (e) => [e[0], e[1]+1] );
+
+  } else {
+    return [];
+  }
+
+}
+
+
+
+
+
 export {
   seq,
+  unique, find_repeated,
   arr_uniq_p,
   histograph, weighted_histo_key,
   weighted_rand_select, weighted_sample_select,
   array_box_if_string,
-  hook_name, named_hook_name,
+  name_bind_prop_and_state, hook_name, named_hook_name,
   make_mulberry_rand
 };
 
diff --git a/src/ts/tests/UnicodeBlocks-14.0.0.txt b/src/ts/tests/UnicodeBlocks-14.0.0.txt
new file mode 100644
index 00000000..394dab13
--- /dev/null
+++ b/src/ts/tests/UnicodeBlocks-14.0.0.txt
@@ -0,0 +1,356 @@
+# Blocks-14.0.0.txt
+# Date: 2021-01-22, 23:29:00 GMT [KW]
+# © 2021 Unicode®, Inc.
+# For terms of use, see http://www.unicode.org/terms_of_use.html
+#
+# Unicode Character Database
+# For documentation, see http://www.unicode.org/reports/tr44/
+#
+# Format:
+# Start Code..End Code; Block Name
+
+# ================================================
+
+# Note:   When comparing block names, casing, whitespace, hyphens,
+#         and underbars are ignored.
+#         For example, "Latin Extended-A" and "latin extended a" are equivalent.
+#         For more information on the comparison of property values,
+#            see UAX #44: http://www.unicode.org/reports/tr44/
+#
+#  All block ranges start with a value where (cp MOD 16) = 0,
+#  and end with a value where (cp MOD 16) = 15. In other words,
+#  the last hexadecimal digit of the start of range is ...0
+#  and the last hexadecimal digit of the end of range is ...F.
+#  This constraint on block ranges guarantees that allocations
+#  are done in terms of whole columns, and that code chart display
+#  never involves splitting columns in the charts.
+#
+#  All code points not explicitly listed for Block
+#  have the value No_Block.
+
+# Property: Block
+#
+# @missing: 0000..10FFFF; No_Block
+
+0000..007F; Basic Latin
+0080..00FF; Latin-1 Supplement
+0100..017F; Latin Extended-A
+0180..024F; Latin Extended-B
+0250..02AF; IPA Extensions
+02B0..02FF; Spacing Modifier Letters
+0300..036F; Combining Diacritical Marks
+0370..03FF; Greek and Coptic
+0400..04FF; Cyrillic
+0500..052F; Cyrillic Supplement
+0530..058F; Armenian
+0590..05FF; Hebrew
+0600..06FF; Arabic
+0700..074F; Syriac
+0750..077F; Arabic Supplement
+0780..07BF; Thaana
+07C0..07FF; NKo
+0800..083F; Samaritan
+0840..085F; Mandaic
+0860..086F; Syriac Supplement
+0870..089F; Arabic Extended-B
+08A0..08FF; Arabic Extended-A
+0900..097F; Devanagari
+0980..09FF; Bengali
+0A00..0A7F; Gurmukhi
+0A80..0AFF; Gujarati
+0B00..0B7F; Oriya
+0B80..0BFF; Tamil
+0C00..0C7F; Telugu
+0C80..0CFF; Kannada
+0D00..0D7F; Malayalam
+0D80..0DFF; Sinhala
+0E00..0E7F; Thai
+0E80..0EFF; Lao
+0F00..0FFF; Tibetan
+1000..109F; Myanmar
+10A0..10FF; Georgian
+1100..11FF; Hangul Jamo
+1200..137F; Ethiopic
+1380..139F; Ethiopic Supplement
+13A0..13FF; Cherokee
+1400..167F; Unified Canadian Aboriginal Syllabics
+1680..169F; Ogham
+16A0..16FF; Runic
+1700..171F; Tagalog
+1720..173F; Hanunoo
+1740..175F; Buhid
+1760..177F; Tagbanwa
+1780..17FF; Khmer
+1800..18AF; Mongolian
+18B0..18FF; Unified Canadian Aboriginal Syllabics Extended
+1900..194F; Limbu
+1950..197F; Tai Le
+1980..19DF; New Tai Lue
+19E0..19FF; Khmer Symbols
+1A00..1A1F; Buginese
+1A20..1AAF; Tai Tham
+1AB0..1AFF; Combining Diacritical Marks Extended
+1B00..1B7F; Balinese
+1B80..1BBF; Sundanese
+1BC0..1BFF; Batak
+1C00..1C4F; Lepcha
+1C50..1C7F; Ol Chiki
+1C80..1C8F; Cyrillic Extended-C
+1C90..1CBF; Georgian Extended
+1CC0..1CCF; Sundanese Supplement
+1CD0..1CFF; Vedic Extensions
+1D00..1D7F; Phonetic Extensions
+1D80..1DBF; Phonetic Extensions Supplement
+1DC0..1DFF; Combining Diacritical Marks Supplement
+1E00..1EFF; Latin Extended Additional
+1F00..1FFF; Greek Extended
+2000..206F; General Punctuation
+2070..209F; Superscripts and Subscripts
+20A0..20CF; Currency Symbols
+20D0..20FF; Combining Diacritical Marks for Symbols
+2100..214F; Letterlike Symbols
+2150..218F; Number Forms
+2190..21FF; Arrows
+2200..22FF; Mathematical Operators
+2300..23FF; Miscellaneous Technical
+2400..243F; Control Pictures
+2440..245F; Optical Character Recognition
+2460..24FF; Enclosed Alphanumerics
+2500..257F; Box Drawing
+2580..259F; Block Elements
+25A0..25FF; Geometric Shapes
+2600..26FF; Miscellaneous Symbols
+2700..27BF; Dingbats
+27C0..27EF; Miscellaneous Mathematical Symbols-A
+27F0..27FF; Supplemental Arrows-A
+2800..28FF; Braille Patterns
+2900..297F; Supplemental Arrows-B
+2980..29FF; Miscellaneous Mathematical Symbols-B
+2A00..2AFF; Supplemental Mathematical Operators
+2B00..2BFF; Miscellaneous Symbols and Arrows
+2C00..2C5F; Glagolitic
+2C60..2C7F; Latin Extended-C
+2C80..2CFF; Coptic
+2D00..2D2F; Georgian Supplement
+2D30..2D7F; Tifinagh
+2D80..2DDF; Ethiopic Extended
+2DE0..2DFF; Cyrillic Extended-A
+2E00..2E7F; Supplemental Punctuation
+2E80..2EFF; CJK Radicals Supplement
+2F00..2FDF; Kangxi Radicals
+2FF0..2FFF; Ideographic Description Characters
+3000..303F; CJK Symbols and Punctuation
+3040..309F; Hiragana
+30A0..30FF; Katakana
+3100..312F; Bopomofo
+3130..318F; Hangul Compatibility Jamo
+3190..319F; Kanbun
+31A0..31BF; Bopomofo Extended
+31C0..31EF; CJK Strokes
+31F0..31FF; Katakana Phonetic Extensions
+3200..32FF; Enclosed CJK Letters and Months
+3300..33FF; CJK Compatibility
+3400..4DBF; CJK Unified Ideographs Extension A
+4DC0..4DFF; Yijing Hexagram Symbols
+4E00..9FFF; CJK Unified Ideographs
+A000..A48F; Yi Syllables
+A490..A4CF; Yi Radicals
+A4D0..A4FF; Lisu
+A500..A63F; Vai
+A640..A69F; Cyrillic Extended-B
+A6A0..A6FF; Bamum
+A700..A71F; Modifier Tone Letters
+A720..A7FF; Latin Extended-D
+A800..A82F; Syloti Nagri
+A830..A83F; Common Indic Number Forms
+A840..A87F; Phags-pa
+A880..A8DF; Saurashtra
+A8E0..A8FF; Devanagari Extended
+A900..A92F; Kayah Li
+A930..A95F; Rejang
+A960..A97F; Hangul Jamo Extended-A
+A980..A9DF; Javanese
+A9E0..A9FF; Myanmar Extended-B
+AA00..AA5F; Cham
+AA60..AA7F; Myanmar Extended-A
+AA80..AADF; Tai Viet
+AAE0..AAFF; Meetei Mayek Extensions
+AB00..AB2F; Ethiopic Extended-A
+AB30..AB6F; Latin Extended-E
+AB70..ABBF; Cherokee Supplement
+ABC0..ABFF; Meetei Mayek
+AC00..D7AF; Hangul Syllables
+D7B0..D7FF; Hangul Jamo Extended-B
+D800..DB7F; High Surrogates
+DB80..DBFF; High Private Use Surrogates
+DC00..DFFF; Low Surrogates
+E000..F8FF; Private Use Area
+F900..FAFF; CJK Compatibility Ideographs
+FB00..FB4F; Alphabetic Presentation Forms
+FB50..FDFF; Arabic Presentation Forms-A
+FE00..FE0F; Variation Selectors
+FE10..FE1F; Vertical Forms
+FE20..FE2F; Combining Half Marks
+FE30..FE4F; CJK Compatibility Forms
+FE50..FE6F; Small Form Variants
+FE70..FEFF; Arabic Presentation Forms-B
+FF00..FFEF; Halfwidth and Fullwidth Forms
+FFF0..FFFF; Specials
+10000..1007F; Linear B Syllabary
+10080..100FF; Linear B Ideograms
+10100..1013F; Aegean Numbers
+10140..1018F; Ancient Greek Numbers
+10190..101CF; Ancient Symbols
+101D0..101FF; Phaistos Disc
+10280..1029F; Lycian
+102A0..102DF; Carian
+102E0..102FF; Coptic Epact Numbers
+10300..1032F; Old Italic
+10330..1034F; Gothic
+10350..1037F; Old Permic
+10380..1039F; Ugaritic
+103A0..103DF; Old Persian
+10400..1044F; Deseret
+10450..1047F; Shavian
+10480..104AF; Osmanya
+104B0..104FF; Osage
+10500..1052F; Elbasan
+10530..1056F; Caucasian Albanian
+10570..105BF; Vithkuqi
+10600..1077F; Linear A
+10780..107BF; Latin Extended-F
+10800..1083F; Cypriot Syllabary
+10840..1085F; Imperial Aramaic
+10860..1087F; Palmyrene
+10880..108AF; Nabataean
+108E0..108FF; Hatran
+10900..1091F; Phoenician
+10920..1093F; Lydian
+10980..1099F; Meroitic Hieroglyphs
+109A0..109FF; Meroitic Cursive
+10A00..10A5F; Kharoshthi
+10A60..10A7F; Old South Arabian
+10A80..10A9F; Old North Arabian
+10AC0..10AFF; Manichaean
+10B00..10B3F; Avestan
+10B40..10B5F; Inscriptional Parthian
+10B60..10B7F; Inscriptional Pahlavi
+10B80..10BAF; Psalter Pahlavi
+10C00..10C4F; Old Turkic
+10C80..10CFF; Old Hungarian
+10D00..10D3F; Hanifi Rohingya
+10E60..10E7F; Rumi Numeral Symbols
+10E80..10EBF; Yezidi
+10F00..10F2F; Old Sogdian
+10F30..10F6F; Sogdian
+10F70..10FAF; Old Uyghur
+10FB0..10FDF; Chorasmian
+10FE0..10FFF; Elymaic
+11000..1107F; Brahmi
+11080..110CF; Kaithi
+110D0..110FF; Sora Sompeng
+11100..1114F; Chakma
+11150..1117F; Mahajani
+11180..111DF; Sharada
+111E0..111FF; Sinhala Archaic Numbers
+11200..1124F; Khojki
+11280..112AF; Multani
+112B0..112FF; Khudawadi
+11300..1137F; Grantha
+11400..1147F; Newa
+11480..114DF; Tirhuta
+11580..115FF; Siddham
+11600..1165F; Modi
+11660..1167F; Mongolian Supplement
+11680..116CF; Takri
+11700..1174F; Ahom
+11800..1184F; Dogra
+118A0..118FF; Warang Citi
+11900..1195F; Dives Akuru
+119A0..119FF; Nandinagari
+11A00..11A4F; Zanabazar Square
+11A50..11AAF; Soyombo
+11AB0..11ABF; Unified Canadian Aboriginal Syllabics Extended-A
+11AC0..11AFF; Pau Cin Hau
+11C00..11C6F; Bhaiksuki
+11C70..11CBF; Marchen
+11D00..11D5F; Masaram Gondi
+11D60..11DAF; Gunjala Gondi
+11EE0..11EFF; Makasar
+11FB0..11FBF; Lisu Supplement
+11FC0..11FFF; Tamil Supplement
+12000..123FF; Cuneiform
+12400..1247F; Cuneiform Numbers and Punctuation
+12480..1254F; Early Dynastic Cuneiform
+12F90..12FFF; Cypro-Minoan
+13000..1342F; Egyptian Hieroglyphs
+13430..1343F; Egyptian Hieroglyph Format Controls
+14400..1467F; Anatolian Hieroglyphs
+16800..16A3F; Bamum Supplement
+16A40..16A6F; Mro
+16A70..16ACF; Tangsa
+16AD0..16AFF; Bassa Vah
+16B00..16B8F; Pahawh Hmong
+16E40..16E9F; Medefaidrin
+16F00..16F9F; Miao
+16FE0..16FFF; Ideographic Symbols and Punctuation
+17000..187FF; Tangut
+18800..18AFF; Tangut Components
+18B00..18CFF; Khitan Small Script
+18D00..18D7F; Tangut Supplement
+1AFF0..1AFFF; Kana Extended-B
+1B000..1B0FF; Kana Supplement
+1B100..1B12F; Kana Extended-A
+1B130..1B16F; Small Kana Extension
+1B170..1B2FF; Nushu
+1BC00..1BC9F; Duployan
+1BCA0..1BCAF; Shorthand Format Controls
+1CF00..1CFCF; Znamenny Musical Notation
+1D000..1D0FF; Byzantine Musical Symbols
+1D100..1D1FF; Musical Symbols
+1D200..1D24F; Ancient Greek Musical Notation
+1D2E0..1D2FF; Mayan Numerals
+1D300..1D35F; Tai Xuan Jing Symbols
+1D360..1D37F; Counting Rod Numerals
+1D400..1D7FF; Mathematical Alphanumeric Symbols
+1D800..1DAAF; Sutton SignWriting
+1DF00..1DFFF; Latin Extended-G
+1E000..1E02F; Glagolitic Supplement
+1E100..1E14F; Nyiakeng Puachue Hmong
+1E290..1E2BF; Toto
+1E2C0..1E2FF; Wancho
+1E7E0..1E7FF; Ethiopic Extended-B
+1E800..1E8DF; Mende Kikakui
+1E900..1E95F; Adlam
+1EC70..1ECBF; Indic Siyaq Numbers
+1ED00..1ED4F; Ottoman Siyaq Numbers
+1EE00..1EEFF; Arabic Mathematical Alphabetic Symbols
+1F000..1F02F; Mahjong Tiles
+1F030..1F09F; Domino Tiles
+1F0A0..1F0FF; Playing Cards
+1F100..1F1FF; Enclosed Alphanumeric Supplement
+1F200..1F2FF; Enclosed Ideographic Supplement
+1F300..1F5FF; Miscellaneous Symbols and Pictographs
+1F600..1F64F; Emoticons
+1F650..1F67F; Ornamental Dingbats
+1F680..1F6FF; Transport and Map Symbols
+1F700..1F77F; Alchemical Symbols
+1F780..1F7FF; Geometric Shapes Extended
+1F800..1F8FF; Supplemental Arrows-C
+1F900..1F9FF; Supplemental Symbols and Pictographs
+1FA00..1FA6F; Chess Symbols
+1FA70..1FAFF; Symbols and Pictographs Extended-A
+1FB00..1FBFF; Symbols for Legacy Computing
+20000..2A6DF; CJK Unified Ideographs Extension B
+2A700..2B73F; CJK Unified Ideographs Extension C
+2B740..2B81F; CJK Unified Ideographs Extension D
+2B820..2CEAF; CJK Unified Ideographs Extension E
+2CEB0..2EBEF; CJK Unified Ideographs Extension F
+2F800..2FA1F; CJK Compatibility Ideographs Supplement
+30000..3134F; CJK Unified Ideographs Extension G
+E0000..E007F; Tags
+E0100..E01EF; Variation Selectors Supplement
+F0000..FFFFF; Supplementary Private Use Area-A
+100000..10FFFF; Supplementary Private Use Area-B
+
+# EOF
\ No newline at end of file
diff --git a/src/ts/tests/actions.spec.ts b/src/ts/tests/actions.spec.ts
index 9191cfcf..3e162639 100644
--- a/src/ts/tests/actions.spec.ts
+++ b/src/ts/tests/actions.spec.ts
@@ -3,6 +3,8 @@
 
 import * as jssm from '../jssm';
 
+const sm = jssm.sm;
+
 
 
 
@@ -155,6 +157,25 @@ describe('Reports on action edges', () => {
 
 
 
+describe('uses_actions', () => {
+
+  const does   = sm`a 'next' -> b;`,
+        doesnt = sm`a -> b;`;
+
+  test('uses_actions true when does', () =>
+    expect( does.uses_actions )
+      .toBe(true) );
+
+  test('uses_actions false when doesn\'t', () =>
+    expect( doesnt.uses_actions )
+      .toBe(false) );
+
+});
+
+
+
+
+
 describe('Two nodes should be able to have matching edges with differing action labels', () => {
 
   // const machine = sm`a 'first' -> a; a 'second' -> a;`;
diff --git a/src/ts/tests/compile.spec.ts b/src/ts/tests/compile.spec.ts
index bafbac1a..2ede5e3e 100644
--- a/src/ts/tests/compile.spec.ts
+++ b/src/ts/tests/compile.spec.ts
@@ -46,6 +46,13 @@ describe('compile/1', () => {
     }).not.toThrow() );
   });
 
+  describe('direct make callpoint', () => {
+    const match = { start_states: [ 'a' ], end_states: [], transitions: [ { from: 'a', to: 'b', kind: 'legal', forced_only: false, main_path: false } ], state_property: [] };
+    test('direct match', () => {
+      expect(jssm.make('a->b;')).toStrictEqual(match);
+    })
+  });
+
 });
 
 
@@ -74,6 +81,12 @@ describe('error catchery', () => {
     } ).toThrow() );
   });
 
+  describe('direct make failure throws', () => {
+    test('direct match', () => {
+      expect( () => jssm.make('kaboom')).toThrow();
+    })
+  });
+
 });
 
 // stochable
diff --git a/src/ts/tests/constants.spec.ts b/src/ts/tests/constants.spec.ts
index 9ff013ba..a51cdbf7 100644
--- a/src/ts/tests/constants.spec.ts
+++ b/src/ts/tests/constants.spec.ts
@@ -22,7 +22,7 @@ const Shapes      = jssm.shapes,
 
 
 
-const Themes         = ['default', 'ocean', 'none', 'modern'],
+const Themes         = ['default', 'ocean', 'none', 'modern', 'bold'],
       FlowDirections = ['up','down','left','right'],
       LineStyles     = ['solid', 'dotted', 'dashed'];
 
diff --git a/src/ts/tests/data.spec.ts b/src/ts/tests/data.spec.ts
index abfc5857..e8032af2 100644
--- a/src/ts/tests/data.spec.ts
+++ b/src/ts/tests/data.spec.ts
@@ -1,6 +1,8 @@
 
 import * as jssm from '../jssm';
 
+const sm = jssm.sm;
+
 
 
 
@@ -102,6 +104,95 @@ describe('Constructor data', () => {
 
 
 
+describe('next_data for each hook', () => {
+
+  test("any action hook", () => {
+    const m = jssm.from("a 'nx' -> b;");
+    let nd: string;
+    m.hook_any_action( ({ next_data }) => { nd = next_data; });
+    m.action('nx', 'foo');
+    expect(nd).toBe('foo');
+  });
+
+  test("global specific action hook", () => {
+    const m = jssm.from("a 'nx' -> b;");
+    let nd: string;
+    m.hook_global_action( 'nx', ({ next_data }) => { nd = next_data; });
+    m.action('nx', 'foo');
+    expect(nd).toBe('foo');
+  });
+
+  test("any transition hook", () => {
+    const m = jssm.from('a -> b;');
+    let nd: string;
+    m.hook_any_transition( ({ next_data }) => { nd = next_data; });
+    m.go('b', 'foo');
+    expect(nd).toBe('foo');
+  });
+
+  test("exit hook", () => {
+    const m = jssm.from("a 'nx' -> b;");
+    let nd: string;
+    m.hook_exit( 'a', ({ next_data }) => { nd = next_data; });
+    m.go('b', 'foo');
+    expect(nd).toBe('foo');
+  });
+
+  test("action hook", () => {
+    const m = jssm.from("a 'nx' -> b;");
+    let nd: string;
+    m.hook_action( 'a', 'b', 'nx', ({ next_data }) => { nd = next_data; });
+    m.action('nx', 'foo');
+    expect(nd).toBe('foo');
+  });
+
+  test("regular ol' transition hook", () => {
+    const m = jssm.from('a -> b;');
+    let nd: string;
+    m.hook( 'a', 'b', ({ next_data }) => { nd = next_data; });
+    m.go('b', 'foo');
+    expect(nd).toBe('foo');
+  });
+
+  test("hook any standard transition", () => {
+    const m = jssm.from('a -> b;');
+    let nd: string;
+    m.hook_standard_transition( ({ next_data }) => { nd = next_data; });
+    m.go('b', 'foo');
+    expect(nd).toBe('foo');
+  });
+
+  test("hook any main transition", () => {
+    const m = jssm.from('a => b;');
+    let nd: string;
+    m.hook_main_transition( ({ next_data }) => { nd = next_data; });
+    m.go('b', 'foo');
+    expect(nd).toBe('foo');
+  });
+
+  test("hook any forced transition", () => {
+    const m = jssm.from('a ~> b;');
+    let nd: string;
+    m.hook_forced_transition( ({ next_data }) => { nd = next_data; });
+    m.force_transition('b', 'foo');
+    expect(nd).toBe('foo');
+  });
+
+  test("entry hook", () => {
+    const m = jssm.from("a 'nx' -> b;");
+    let nd: string;
+    m.hook_entry( 'b', ({ next_data }) => { nd = next_data; });
+    m.go('b', 'foo');
+    expect(nd).toBe('foo');
+  });
+
+
+});
+
+
+
+
+
 describe('data/0 for reading current data', () => {
 
   test('data/0 for data 1', () => {
diff --git a/src/ts/tests/display_text.spec.ts b/src/ts/tests/display_text.spec.ts
new file mode 100644
index 00000000..8bfef4be
--- /dev/null
+++ b/src/ts/tests/display_text.spec.ts
@@ -0,0 +1,25 @@
+
+import { sm, Machine } from '../jssm';
+
+
+
+
+
+// most of the supporting defect-attrition test stuff is on the labels, not the
+// caller, so there's no sense repeating what's in state_label.spec
+
+describe('Display text', () => {
+
+  test(`Atom labels read out correctly`, () =>
+    expect( sm`a -> b; state a: { label: atomtest; };`.display_text('a') )
+      .toBe('atomtest') );
+
+  test(`String labels read out correctly`, () =>
+    expect( sm`a -> b; state a: { label: "string test"; };`.display_text('a') )
+      .toBe('string test') );
+
+  test(`Missing labels read out as undefined`, () =>
+    expect( sm`a -> b; state a: { label: atomtest; };`.display_text('b') )
+      .toBe('b') );
+
+});
\ No newline at end of file
diff --git a/src/ts/tests/flow.spec.ts b/src/ts/tests/flow.spec.ts
index ae6c17e5..b71897bb 100644
--- a/src/ts/tests/flow.spec.ts
+++ b/src/ts/tests/flow.spec.ts
@@ -1,6 +1,6 @@
 
-import { FlowDirections } from './constants.spec';
-import { sm }             from '../jssm';
+import { FlowDirections }    from './constants.spec';
+import { sm, FslDirections } from '../jssm';
 
 
 
@@ -19,4 +19,14 @@ describe('Flow directions', () => {
   test('Fake flow direction throws', () =>
     expect( () => { const _foo = sm`flow: yourFlowIsWhackSon; a-> b;`; } ).toThrow() );
 
+  test('FslDirections', () => {
+
+    const foo  = sm`a->b;`,
+          dirs = FslDirections;
+
+    expect( Array.isArray(FslDirections) ).toBe(true);
+    expect( typeof FslDirections[0] ).toBe('string');
+
+  });
+
 });
diff --git a/src/ts/tests/forced transitions.spec.ts b/src/ts/tests/forced transitions.spec.ts
index 316becad..2f638692 100644
--- a/src/ts/tests/forced transitions.spec.ts	
+++ b/src/ts/tests/forced transitions.spec.ts	
@@ -24,3 +24,25 @@ describe('reject and accept correctly', () => {
   test('now in c',                       () => expect( machine.state()               ).toBe('c')   );
 
 });
+
+
+
+
+
+describe('uses_forced_transitions', () => {
+
+  test( 'standard transition', () => expect(sm`a -> b;`.uses_forced_transitions).toBe(false) );
+  test( 'main transition',     () => expect(sm`a => b;`.uses_forced_transitions).toBe(false) );
+  test( 'forced transition',   () => expect(sm`a ~> b;`.uses_forced_transitions).toBe(true)  );
+
+  test( 'standard and main transition',   () => expect(sm`a -> b; c => d;`.uses_forced_transitions).toBe(false) );
+  test( 'forced and main transition',     () => expect(sm`a ~> b; c => d;`.uses_forced_transitions).toBe(true)  );
+  test( 'main and forced transition',     () => expect(sm`a => b; c ~> d;`.uses_forced_transitions).toBe(true)  );
+  test( 'standard and forced transition', () => expect(sm`a -> b; c ~> d;`.uses_forced_transitions).toBe(true)  );
+
+  test( 'standard and main transition, chain',   () => expect(sm`a -> c => d;`.uses_forced_transitions).toBe(false) );
+  test( 'forced and main transition, chain',     () => expect(sm`a ~> c => d;`.uses_forced_transitions).toBe(true)  );
+  test( 'main and forced transition, chain',     () => expect(sm`a => c ~> d;`.uses_forced_transitions).toBe(true)  );
+  test( 'standard and forced transition, chain', () => expect(sm`a -> c ~> d;`.uses_forced_transitions).toBe(true)  );
+
+});
diff --git a/src/ts/tests/general.spec.ts b/src/ts/tests/general.spec.ts
index 05ec916e..fd888dac 100644
--- a/src/ts/tests/general.spec.ts
+++ b/src/ts/tests/general.spec.ts
@@ -15,6 +15,14 @@ test('build-set version number is present', () =>
 
 
 
+test('build_time is present', () =>
+  expect(typeof jssm.build_time)
+    .toBe('number'));
+
+
+
+
+
 describe('Stochastic weather', () => {
 
   new jssm.Machine({
@@ -286,13 +294,13 @@ describe('reports state_is_final', () => {
     expect(machine.state_is_final('off') )
       .toBe(false) );
 
-  test('final false for just terminal', () =>
+  test('final true for just terminal', () =>
     expect(machine.state_is_final('mid') )
-      .toBe(false) );
+      .toBe(true) );
 
-  test('final false for just complete', () =>
+  test('final true for just complete', () =>
     expect(machine.state_is_final('fin') )
-      .toBe(false) );
+      .toBe(true) );
 
   test('final true', () =>
     expect(machine.state_is_final('red') )
diff --git a/src/ts/tests/hooks.spec.ts b/src/ts/tests/hooks.spec.ts
index 4baa23ab..03bf0adc 100644
--- a/src/ts/tests/hooks.spec.ts
+++ b/src/ts/tests/hooks.spec.ts
@@ -1063,46 +1063,46 @@ describe('is_hook_rejection', () => {
 describe('abstract_hook_step', () => {
 
   test('generates pass for undefined', () =>
-    expect( jssm.abstract_hook_step(undefined, {data: undefined}) )
+    expect( jssm.abstract_hook_step(undefined, { data: undefined, next_data: undefined }) )
       .toStrictEqual({ pass: true }) );
 
   test('generates pass for function returning undefined', () => {
     const fn = jest.fn();
-    expect( jssm.abstract_hook_step(fn, {data: undefined}) )
+    expect( jssm.abstract_hook_step(fn, { data: undefined, next_data: undefined }) )
       .toStrictEqual({ pass: true })
     expect(fn).toHaveBeenCalled();
   });
 
   test('generates pass for function returning true', () => {
     const fn = jest.fn( () => true );
-    expect( jssm.abstract_hook_step(fn, {data: undefined}) )
+    expect( jssm.abstract_hook_step(fn, { data: undefined, next_data: undefined }) )
       .toStrictEqual({ pass: true })
     expect(fn).toHaveBeenCalled();
   });
 
   test('generates reject for function returning false', () => {
     const fn = jest.fn( () => false );
-    expect( jssm.abstract_hook_step(fn, {data: undefined}) )
+    expect( jssm.abstract_hook_step(fn, { data: undefined, next_data: undefined }) )
       .toStrictEqual({ pass: false })
     expect(fn).toHaveBeenCalled();
   });
 
   test('generates pass for function returning complex pass', () => {
     const fn = jest.fn( () => ({pass: true}) );
-    expect( jssm.abstract_hook_step(fn, {data: undefined}) )
+    expect( jssm.abstract_hook_step(fn, { data: undefined, next_data: undefined }) )
       .toStrictEqual({ pass: true })
     expect(fn).toHaveBeenCalled();
   });
 
   test('generates reject for function returning complex reject', () => {
     const fn = jest.fn( () => ({pass: false}) );
-    expect( jssm.abstract_hook_step(fn, {data: undefined}) )
+    expect( jssm.abstract_hook_step(fn, { data: undefined, next_data: undefined }) )
       .toStrictEqual({ pass: false })
     expect(fn).toHaveBeenCalled();
   });
 
   test('throws for hook returning illegal value', () => {
-    expect( () => jssm.abstract_hook_step( () => "squid" as any, {data: undefined}) )
+    expect( () => jssm.abstract_hook_step( () => "squid" as any, { data: undefined, next_data: undefined }) )
       .toThrow()
   });
 
diff --git a/src/ts/tests/override.spec.ts b/src/ts/tests/override.spec.ts
new file mode 100644
index 00000000..63789900
--- /dev/null
+++ b/src/ts/tests/override.spec.ts
@@ -0,0 +1,279 @@
+
+import * as jssm         from '../jssm';
+import { JssmArrowKind } from '../jssm_types';
+
+const sm = jssm.sm;
+
+
+
+
+
+describe('.allows_override', () => {
+
+  test('1 undefined in code, no config reads out false', () => {
+    const machine = jssm.from(`a -> b;`);
+    expect(machine.allows_override).toBe(false);
+  });
+
+  test('2 undefined in code, missing in config reads out false', () => {
+    const machine = jssm.from(`a -> b;`, { });
+    expect(machine.allows_override).toBe(false);
+  });
+
+  test('3 undefined in code, undefined in config reads out false', () => {
+    const machine = jssm.from(`a -> b;`, { allows_override: undefined });
+    expect(machine.allows_override).toBe(false);
+  });
+
+  test('4 undefined in code, allowed in config reads out true', () => {
+    const machine = jssm.from(`a -> b;`, { allows_override: true });
+    expect(machine.allows_override).toBe(true);
+  });
+
+  test('5 undefined in code, disallowed in config reads out false', () => {
+    const machine = jssm.from(`a -> b;`, { allows_override: false });
+    expect(machine.allows_override).toBe(false);
+  });
+
+
+
+  test('6 allowed in code, no config reads out true', () => {
+    const machine = jssm.from(`allows_override: true; a -> b;`);
+    expect(machine.allows_override).toBe(true);
+  });
+
+  test('7 allowed in code, missing in config reads out true', () => {
+    const machine = jssm.from(`allows_override: true; a -> b;`, { });
+    expect(machine.allows_override).toBe(true);
+  });
+
+  test('8 allowed in code, undefined in config reads out true', () => {
+    const machine = jssm.from(`allows_override: true; a -> b;`, { allows_override: undefined });
+    expect(machine.allows_override).toBe(true);
+  });
+
+  test('9 allowed in code, allowed in config reads out true', () => {
+    const machine = jssm.from(`allows_override: true; a -> b;`, { allows_override: true });
+    expect(machine.allows_override).toBe(true);
+  });
+
+  test('10 allowed in code, disallowed in config reads out false', () => {
+    const machine = jssm.from(`allows_override: true; a -> b;`, { allows_override: false });
+    expect(machine.allows_override).toBe(false);
+  });
+
+
+
+  test('11 disallowed in code, no config reads out false', () => {
+    const machine = jssm.from(`allows_override: false; a -> b;`);
+    expect(machine.allows_override).toBe(false);
+  });
+
+  test('12 disallowed in code, missing in config reads out false', () => {
+    const machine = jssm.from(`allows_override: false; a -> b;`, { });
+    expect(machine.allows_override).toBe(false);
+  });
+
+  test('13 disallowed in code, undefined in config reads out false', () => {
+    const machine = jssm.from(`allows_override: false; a -> b;`, { allows_override: undefined });
+    expect(machine.allows_override).toBe(false);
+  });
+
+  test('14 disallowed in code, allowed in config throws an error', () => {
+    expect( () => jssm.from(`allows_override: false; a -> b;`, { allows_override: true }).allows_override )
+      .toThrow();
+  });
+
+  test('15 disallowed in code, allowed in config throws an error', () => {
+    expect( () => jssm.from(`allows_override: false; a -> b;`, { allows_override: true }) )
+      .toThrow();
+  });
+
+  test('16 in datastructure - disallowed in code, allowed in config throws an error', () => {
+
+    const made = {
+      start_states           : [ 'a' ],
+      end_states             : [],
+      transitions            : [ { from        : 'a',
+                                   to          : 'b',
+                                   kind        : 'legal' as JssmArrowKind,
+                                   forced_only : false,
+                                   main_path   : false } ],
+      state_property         : [],
+      allows_override        : false,
+      config_allows_override : true
+    };
+
+    expect( () => new jssm.Machine(made) )
+      .toThrow();
+
+  });
+
+  test('17 disallowed in code, disallowed in config reads out false', () => {
+    const machine = jssm.from(`allows_override: false; a -> b;`, { allows_override: false });
+    expect(machine.allows_override).toBe(false);
+  });
+
+});
+
+
+
+
+
+describe('.config_allows_override', () => {
+
+  test('18 whole config missing', () => {
+    const machine = jssm.from(`a -> b;`);
+    expect(machine.config_allows_override).toBe(undefined);
+  });
+
+  test('19 config field missing', () => {
+    const machine = jssm.from(`a -> b;`, { });
+    expect(machine.config_allows_override).toBe(undefined);
+  });
+
+  test('20 config undefined', () => {
+    const machine = jssm.from(`a -> b;`, { allows_override: undefined });
+    expect(machine.config_allows_override).toBe(undefined);
+  });
+
+  test('21 config true', () => {
+    const machine = jssm.from(`a -> b;`, { allows_override: true });
+    expect(machine.config_allows_override).toBe(true);
+  });
+
+  test('22 config false', () => {
+    const machine = jssm.from(`a -> b;`, { allows_override: false });
+    expect(machine.config_allows_override).toBe(false);
+  });
+
+});
+
+
+
+
+
+describe('.code_allows_override', () => {
+
+  test('23 code missing', () => {
+    const machine = sm`a -> b;`;
+    expect(machine.code_allows_override).toBe(undefined);
+  });
+
+  test('24 code undefined', () => {
+    const machine = sm`allows_override: undefined; a -> b;`;
+    expect(machine.code_allows_override).toBe(undefined);
+  });
+
+  test('25 code true', () => {
+    const machine = sm`allows_override: true; a -> b;`;
+    expect(machine.code_allows_override).toBe(true);
+  });
+
+  test('26 code false', () => {
+    const machine = sm`allows_override: false; a -> b;`;
+    expect(machine.code_allows_override).toBe(false);
+  });
+
+});
+
+
+
+
+
+describe('.allows_override negative tests', () => {
+
+  test('27 cannot have two allows_override statements', () => {
+    expect( () => sm`allows_override: false; allows_override: false; a -> b;` )
+      .toThrow()
+  });
+
+});
+
+
+
+
+
+describe('.override/2', () => {
+
+  test('working override without data', () => {
+    const machine = sm`allows_override: true; a -> b -> c;`;
+    machine.go('b');
+    machine.go('c');
+    expect(machine.state()).toBe('c');
+    machine.override('a', undefined);
+    expect(machine.state()).toBe('a');
+  });
+
+  test('working override with data', () => {
+    const machine = jssm.from(`allows_override: true; a -> b -> c;`, { data: 'foo' });
+    machine.go('b');
+    machine.go('c');
+    expect(machine.state()).toBe('c');
+    expect(machine.data()).toBe('foo');
+    machine.override('a', 'bar');
+    expect(machine.state()).toBe('a');
+    expect(machine.data()).toBe('bar');
+  });
+
+  test('working override to distinct chain', () => {
+    const machine = sm`allows_override: true; a -> b -> c -> a; d -> e -> f -> d;`;
+    machine.go('b');
+    machine.go('c');
+    expect(machine.state()).toBe('c');
+    machine.override('d', undefined);
+    machine.go('e')
+    expect(machine.state()).toBe('e');
+  });
+
+  test('working override to distinct chain then back', () => {
+    const machine = sm`allows_override: true; a -> b -> c -> a; d -> e -> f -> d;`;
+    machine.go('b');
+    machine.go('c');
+    expect(machine.state()).toBe('c');
+    machine.override('d', undefined);
+    machine.go('e')
+    expect(machine.state()).toBe('e');
+    machine.override('a', undefined);
+    machine.go('b')
+    expect(machine.state()).toBe('b');
+  });
+
+});
+
+
+
+
+
+describe('.override/2 negative tests', () => {
+
+  test('allowed, but to state that does not exist', () => {
+    const machine = sm`allows_override: true; a -> b;`;
+    expect(machine.state()).toBe('a');
+    expect( () => machine.override('c') ).toThrow();
+  });
+
+  test('disallowed in code', () => {
+    const machine = sm`allows_override: false; a -> b;`;
+    expect(machine.state()).toBe('a');
+    expect( () => machine.override('b') ).toThrow();
+  });
+
+  test('disallowed in config', () => {
+    const machine = jssm.from(`a -> b;`, { allows_override: false });
+    expect(machine.state()).toBe('a');
+    expect( () => machine.override('b') ).toThrow();
+  });
+
+  test('disallowed by default', () => {
+    const machine = jssm.from(`a -> b;`);
+    expect(machine.state()).toBe('a');
+    expect( () => machine.override('b') ).toThrow();
+  });
+
+  test('disallowed in code and config', () => {
+    const machine = jssm.from(`allows_override: false; a -> b;`, { allows_override: false });
+    expect( () => machine.override('b') ).toThrow();
+  });
+
+});
diff --git a/src/ts/tests/properties.spec.ts b/src/ts/tests/properties.spec.ts
new file mode 100644
index 00000000..961a53c0
--- /dev/null
+++ b/src/ts/tests/properties.spec.ts
@@ -0,0 +1,525 @@
+
+import * as jssm from '../jssm';
+const sm = jssm.sm;
+
+import { JssmGenericConfig } from '../jssm_types';
+
+
+
+
+
+describe('Creating with properties doesn\'t throw', () => {
+
+
+
+
+
+  test('Creating with no default', () => {
+
+    expect( () => jssm.from("property foo; a -> b;") )
+      .not.toThrow();
+
+  });
+
+
+
+  test('Creating with boolean default', () => {
+
+    expect( () => jssm.from("property foo default true; a -> b;") )
+      .not.toThrow();
+
+  });
+
+
+
+  test('Creating with string default', () => {
+
+    expect( () => jssm.from("property foo default \"one\"; a -> b;") )
+      .not.toThrow();
+
+  });
+
+
+
+  test('Creating with number default', () => {
+
+    expect( () => jssm.from("property foo default 1; a -> b;") )
+      .not.toThrow();
+
+  });
+
+
+
+  test('Creating with special number default infinity', () => {
+
+    expect( () => jssm.from("property foo default Inf; a -> b;") )
+      .not.toThrow();
+
+  });
+
+
+
+  test('Creating with special number default negative infinity', () => {
+
+    expect( () => jssm.from("property foo default NInf; a -> b;") )
+      .not.toThrow();
+
+  });
+
+
+
+  test('Creating with special number default NaN', () => {
+
+    expect( () => jssm.from("property foo default NaN; a -> b;") )
+      .not.toThrow();
+
+  });
+
+
+
+  test('Creating with special number default min safe integer', () => {
+
+    expect( () => jssm.from("property foo default MinSafeInt; a -> b;") )
+      .not.toThrow();
+
+  });
+
+
+
+  test('Creating with special number default max safe integer', () => {
+
+    expect( () => jssm.from("property foo default MaxSafeInt; a -> b;") )
+      .not.toThrow();
+
+  });
+
+
+
+  test('Creating with special number default min pos num', () => {
+
+    expect( () => jssm.from("property foo default MinPosNum; a -> b;") )
+      .not.toThrow();
+
+  });
+
+
+
+  test('Creating with special number default max pos num', () => {
+
+    expect( () => jssm.from("property foo default MaxPosNum; a -> b;") )
+      .not.toThrow();
+
+  });
+
+
+
+  test('Creating with special number default epsilon', () => {
+
+    expect( () => jssm.from("property foo default Epsilon; a -> b;") )
+      .not.toThrow();
+
+  });
+
+
+
+  test('Creating with null default', () => {
+
+    expect( () => jssm.from("property foo default null; a -> b;") )
+      .not.toThrow();
+
+  });
+
+
+
+  test('Creating with undefined default', () => {
+
+    expect( () => jssm.from("property foo default undefined; a -> b;") )
+      .not.toThrow();
+
+  });
+
+
+
+
+
+});
+
+
+
+
+
+describe('Basic usage', () => {
+
+  const traffic_light = sm`
+
+    property can_go     default true;
+    property hesitate   default true;
+    property stop_first default false;
+
+    Off -> Red => Green => Yellow => Red;
+    [Red Yellow Green] ~> Off;
+
+    state Red:         { property: stop_first true;  property: can_go false; };
+    state Off:         { property: stop_first true;  };
+    state Green:       { property: hesitate   false; };
+
+  `;
+
+  describe('Off state props', () => {
+    expect(traffic_light.state()).toBe('Off');
+    expect(traffic_light.props()).toStrictEqual({ can_go: true, hesitate: true, stop_first: true });
+  });
+
+  traffic_light.go('Red');
+
+  describe('Red state props', () => {
+    expect(traffic_light.state()).toBe('Red');
+    expect(traffic_light.props()).toStrictEqual({ can_go: false, hesitate: true, stop_first: true });
+  });
+
+  traffic_light.go('Green');
+
+  describe('Green state props', () => {
+    expect(traffic_light.state()).toBe('Green');
+    expect(traffic_light.props()).toStrictEqual({ can_go: true, hesitate: false, stop_first: false });
+  });
+
+  traffic_light.go('Yellow');
+
+  describe('Yellow state props', () => {
+    expect(traffic_light.state()).toBe('Yellow');
+    expect(traffic_light.props()).toStrictEqual({ can_go: true, hesitate: true, stop_first: false });
+  });
+
+});
+
+
+
+
+
+describe('Read property defaults', () => {
+
+
+
+  test('string', () => {
+    const m = sm`property foo default "a"; a -> b;`;
+    expect(m.prop('foo')).toBe('a');
+  });
+
+
+  test('number', () => {
+    const m = sm`property foo default 1; a -> b;`;
+    expect(m.prop('foo')).toBe(1);
+  });
+
+
+  test('boolean', () => {
+    const m = sm`property foo default false; a -> b;`;
+    expect(m.prop('foo')).toBe(false);
+  });
+
+
+  test('undefined', () => {
+    const m = sm`property foo default undefined; a -> b;`;
+    expect(m.prop('foo')).toBe(undefined);
+  });
+
+
+  test('null', () => {
+    const m = sm`property foo default null; a -> b;`;
+    expect(m.prop('foo')).toBe(null);
+  });
+
+
+  test('no default given but present on state', () => {
+    const m = sm`property foo; a -> b; state b: { property: foo 1; };`;
+    m.go('b');
+    expect(m.prop('foo')).toBe(1);
+  });
+
+
+  test('default given but overridden on state', () => {
+    const m = sm`property foo default 1; a -> b; state b: { property: foo 2; };`;
+    m.go('b');
+    expect(m.prop('foo')).toBe(2);
+  });
+
+
+  test('no default given, should supplant undefined', () => {
+    const m = sm`property foo; a -> b;`;
+    expect(m.prop('foo')).toBe(undefined);
+  });
+
+
+
+});
+
+
+
+
+
+describe('Property requirement', () => {
+
+
+
+  test('string', () => {
+    const m = sm`property foo required; a -> b; state a: { property: foo "a"; }; state b: { property: foo "b"; };`;
+    expect(m.prop('foo')).toBe('a');
+    m.go('b');
+    expect(m.prop('foo')).toBe('b');
+  });
+
+
+  test('number', () => {
+    const m = sm`property foo required; a -> b; state a: { property: foo 1; }; state b: { property: foo 2; };`;
+    expect(m.prop('foo')).toBe(1);
+    m.go('b');
+    expect(m.prop('foo')).toBe(2);
+  });
+
+
+  test('boolean', () => {
+    const m = sm`property foo required; a -> b; state a: { property: foo true; }; state b: { property: foo false; };`;
+    expect(m.prop('foo')).toBe(true);
+    m.go('b');
+    expect(m.prop('foo')).toBe(false);
+  });
+
+
+  test('undefined and null', () => {
+    const m = sm`property foo required; a -> b; state a: { property: foo undefined; }; state b: { property: foo null; };`;
+    expect(m.prop('foo')).toBe(undefined);
+    m.go('b');
+    expect(m.prop('foo')).toBe(null);
+  });
+
+
+
+});
+
+
+
+
+
+describe('Strictly read property', () => {
+
+
+
+  test('string', () => {
+    const m = sm`property foo default "a"; a -> b;`;
+    expect(m.strict_prop('foo')).toBe('a');
+  });
+
+
+  test('number', () => {
+    const m = sm`property foo default 1; a -> b;`;
+    expect(m.strict_prop('foo')).toBe(1);
+  });
+
+
+  test('boolean', () => {
+    const m = sm`property foo default false; a -> b;`;
+    expect(m.strict_prop('foo')).toBe(false);
+  });
+
+
+  test('undefined', () => {
+    const m = sm`property foo default undefined; a -> b;`;
+    expect(m.strict_prop('foo')).toBe(undefined);
+  });
+
+
+  test('null', () => {
+    const m = sm`property foo default null; a -> b;`;
+    expect(m.strict_prop('foo')).toBe(null);
+  });
+
+
+  test('no default given', () => {
+    const m = sm`property foo; a -> b;`;
+    expect( () => m.strict_prop('foo') ).toThrow();
+  });
+
+
+  test('no default given but present on state', () => {
+    const m = sm`property foo; a -> b; state b: { property: foo 1; };`;
+    m.go('b');
+    expect(m.strict_prop('foo')).toBe(1);
+  });
+
+
+  test('default given but overridden on state', () => {
+    const m = sm`property foo default 1; a -> b; state b: { property: foo 2; };`;
+    m.go('b');
+    expect(m.strict_prop('foo')).toBe(2);
+  });
+
+
+  test('no default given, should throw', () => {
+    const m = sm`property foo; a -> b;`;
+    expect(() => m.strict_prop('foo')).toThrow();
+  });
+
+
+
+});
+
+
+
+
+
+describe('Get all properties', () => {
+
+
+
+  describe('from defaults', () => {
+
+    test('One prop', () => {
+      const m = sm`property foo default "a"; a -> b;`;
+      expect(m.props()).toStrictEqual({foo: 'a'});
+    });
+
+    test('Two props with defaults', () => {
+      const m = sm`property foo default "a"; property bar default "b"; a -> b;`;
+      expect(m.props()).toStrictEqual({foo: 'a', bar: 'b'});
+    });
+
+    test('Two props, one with a default', () => {
+      const m = sm`property foo default "a"; property bar; a -> b;`;
+      expect(m.props()).toStrictEqual({foo: 'a', bar: undefined});
+    });
+
+    test('No props', () => {
+      const m = sm`a -> b;`;
+      expect(m.props()).toStrictEqual({});
+    });
+
+  });
+
+
+
+});
+
+
+
+
+
+describe('List known properties', () => {
+
+  test('One prop', () => {
+    const m = sm`property foo default "a"; a -> b;`;
+    expect(m.known_props()).toStrictEqual(['foo']);
+  });
+
+  test('Two props', () => {
+    const m = sm`property foo default 1; property bar; a -> b;`,
+          k = m.known_props();
+    k.sort();
+    expect(k).toStrictEqual(['bar','foo']);
+  });
+
+  test('No props', () => {
+    const m = sm`a -> b;`;
+    expect(m.known_props()).toStrictEqual([]);
+  });
+
+});
+
+
+
+
+
+describe('Check whether a property is known', () => {
+
+  test('Known property with default', () => {
+    const example = sm`property foo default 1; a->b;`;
+    expect(example.known_prop('foo')).toBe(true);
+  });
+
+  test('Known property without default', () => {
+    const example = sm`property foo; a->b;`;
+    expect(example.known_prop('foo')).toBe(true);
+  });
+
+  test('Unknown property on machine with properties', () => {
+    const example = sm`property foo default 1; a->b;`;
+    expect(example.known_prop('bar')).toBe(false);
+  });
+
+  test('Unknown property on machine without properties', () => {
+    const example = sm`a->b;`;
+    expect(example.known_prop('bar')).toBe(false);
+  });
+
+});
+
+
+
+
+
+describe('Invalid property errors', () => {
+
+  test('Repeated prop', () => {
+    expect(() => {
+      const m = sm`property foo default "a"; property foo default "a"; a -> b;`;
+    }).toThrow();
+  });
+
+  test('Conflicted prop', () => {
+    expect(() => {
+      const m = sm`property foo default "a"; property foo default "b"; a -> b;`;
+    }).toThrow();
+  });
+
+  test('Repeated state prop', () => {
+    expect(() => {
+      const m = sm`property foo default "a"; a -> b; state a: { property: a 1; property: a 1; };`;
+    }).toThrow();
+  });
+
+  test('Conflicted state prop', () => {
+    expect(() => {
+      const m = sm`property foo default "a"; a -> b; state a: { property: a 1; property: a 2; };`;
+    }).toThrow();
+  });
+
+  test('Property requirement and default simultaneously', () => {
+    expect(() => {
+      const m = sm`property foo default "a" required; a -> b;`;
+    }).toThrow();
+  });
+
+  test('Use of undeclared property', () => {
+    expect(() => {
+      const m = sm`a -> b; state a: { property: foo 2; };`;
+    }).toThrow();
+  });
+
+  test('Missing required property', () => {
+    expect(() => {
+      const m = sm`property foo required; a -> b;`;
+    }).toThrow();
+  });
+
+});
+
+
+
+
+
+test('Indiana General Assembly of 1897 Bill 246', () => {
+
+  // https://en.wikipedia.org/wiki/Indiana_Pi_Bill
+
+  const TheLaw = sm`
+    property pi default Pi;
+    Earth->Indiana;
+    state Indiana: { property: pi 3.2; };
+  `;
+
+  expect(TheLaw.prop('pi')).toBe(Math.PI);
+
+  TheLaw.go('Indiana');
+  expect(TheLaw.prop('pi')).toBe(3.2);
+
+});
diff --git a/src/ts/tests/serialize.spec.ts b/src/ts/tests/serialize.spec.ts
new file mode 100644
index 00000000..e5343b97
--- /dev/null
+++ b/src/ts/tests/serialize.spec.ts
@@ -0,0 +1,164 @@
+
+import * as jssm from '../jssm';
+
+
+
+
+
+describe('Serialization', () => {
+
+
+
+
+
+  test('Creating serializes', () => {
+
+    const foo = jssm.from("a 'next' <-> 'next' b;");
+
+    foo.do('next');
+    foo.do('next');
+
+    const ser = foo.serialize(),
+          s2  = foo.serialize("test");
+
+    expect(ser.jssm_version)
+      .toBe(jssm.version);
+
+    expect(typeof ser.timestamp)
+      .toBe('number');
+
+    expect(typeof ser.comment)
+      .toBe('undefined');
+
+    expect(s2.comment)
+      .toBe('test');
+
+    expect(ser.state)
+      .toBe('a');
+
+    expect(ser.history)
+      .toStrictEqual( [] );
+
+    expect(ser.history_capacity)
+      .toBe(0);
+
+    expect(ser.data)
+      .toBe(undefined);
+
+  });
+
+
+
+  test('Creating with history and data serializes', () => {
+
+    const foo = jssm.from("a 'next' <-> 'next' b;", { history: 5, data: 2 });
+
+    foo.do('next');
+    foo.do('next');
+
+    const ser = foo.serialize(),
+          s2  = foo.serialize("test");
+
+    expect(ser.jssm_version)
+      .toBe(jssm.version);
+
+    expect(typeof ser.timestamp)
+      .toBe('number');
+
+    expect(typeof ser.comment)
+      .toBe('undefined');
+
+    expect(s2.comment)
+      .toBe('test');
+
+    expect(ser.state)
+      .toBe('a');
+
+    expect(ser.history)
+      .toStrictEqual([ ['a',2], ['b',2] ]);
+
+    expect(ser.history_capacity)
+      .toBe(5);
+
+    expect(ser.data)
+      .toBe(2);
+
+  });
+
+
+
+
+
+} );
+
+
+
+
+
+describe('Deserialization', () => {
+
+
+
+
+
+  test('Creating deserializes', () => {
+
+    const machine_str = "a 'next' <-> 'next' b;"
+
+    const foo = jssm.from(machine_str);
+
+    foo.do('next');
+    foo.do('next');
+    foo.do('next');
+
+    const ser = foo.serialize(),
+          bar = jssm.deserialize(machine_str, ser);
+
+    expect(foo.state)
+      .toBe(bar.state);
+
+    expect(foo.history)
+      .toStrictEqual(bar.history);
+
+    expect(foo._history.capacity)
+      .toBe(bar._history.capacity);
+
+    expect(foo.data)
+      .toStrictEqual(bar.data);
+
+  });
+
+
+
+  test('Creating with history and data deserializes', () => {
+
+    const machine_str = "a 'next' <-> 'next' b;"
+
+    const foo = jssm.from(machine_str, { history: 5, data: 2 });
+
+    foo.do('next');
+    foo.do('next');
+    foo.do('next');
+
+    const ser = foo.serialize(),
+          bar = jssm.deserialize(machine_str, ser);
+
+    expect(foo.state)
+      .toBe(bar.state);
+
+    expect(foo.history)
+      .toStrictEqual(bar.history);
+
+    expect(foo._history.capacity)
+      .toBe(bar._history.capacity);
+
+    expect(foo.data)
+      .toStrictEqual(bar.data);
+
+  });
+
+
+
+
+
+} );
diff --git a/src/ts/tests/shapes.spec.ts b/src/ts/tests/shapes.spec.ts
index a912509f..49351adc 100644
--- a/src/ts/tests/shapes.spec.ts
+++ b/src/ts/tests/shapes.spec.ts
@@ -84,12 +84,12 @@ describe('Corners', () => {
 describe('Line style', () => {
 
   test('solid', () =>
-    expect(sm`state a: { linestyle: solid; }; a->b;`.state_declaration("a").linestyle).toBe("solid"));
+    expect(sm`state a: { line-style: solid; }; a->b;`.state_declaration("a").lineStyle).toBe("solid"));
 
   test('dashed', () =>
-    expect(sm`state a: { linestyle: dashed; }; a->b;`.state_declaration("a").linestyle).toBe("dashed"));
+    expect(sm`state a: { line-style: dashed; }; a->b;`.state_declaration("a").lineStyle).toBe("dashed"));
 
   test('dotted', () =>
-    expect(sm`state a: { linestyle: dotted; }; a->b;`.state_declaration("a").linestyle).toBe("dotted"));
+    expect(sm`state a: { line-style: dotted; }; a->b;`.state_declaration("a").lineStyle).toBe("dotted"));
 
 });
diff --git a/src/ts/tests/start_states.spec.ts b/src/ts/tests/start_states.spec.ts
new file mode 100644
index 00000000..5e839b5d
--- /dev/null
+++ b/src/ts/tests/start_states.spec.ts
@@ -0,0 +1,90 @@
+
+/* eslint-disable max-len */
+
+import { sm } from '../jssm';
+
+
+
+
+
+describe('Start states', () => {
+
+  test('List single, agreeing', () => {
+    expect( sm`a -> b; start_states: [a];`.state() )
+      .toBe('a')
+  } );
+
+  test('List single, disagreeing', () => {
+    expect( sm`a -> b; start_states: [b];`.state() )
+      .toBe('b')
+  } );
+
+  test('List multiple, agreeing', () => {
+    expect( sm`a -> b -> c; start_states: [a c];`.state() )
+      .toBe('a')
+  } );
+
+  test('List multiple, disagreeing', () => {
+    expect( sm`a -> b -> c; start_states: [b c];`.state() )
+      .toBe('b')
+  } );
+
+});
+
+
+
+
+
+describe('Invalid start states', () => {
+
+  test('Singleton, nonsense', () => {
+    expect( () => sm`a -> b; start_states: c;`.state() )
+      .toThrow()
+  } );
+
+  test('List single, nonsense', () => {
+    expect( () => sm`a -> b; start_states: [c];`.state() )
+      .toThrow()
+  } );
+
+  test('List multiple, agreeing and nonsense', () => {
+    expect( () => sm`a -> b; start_states: [a c];`.state() )
+      .toThrow()
+  } );
+
+  test('List multiple, disagreeing and nonsense', () => {
+    expect( () => sm`a -> b; start_states: [b c];`.state() )
+      .toThrow()
+  } );
+
+  test('List multiple, nonsense and agreeing', () => {
+    expect( () => sm`a -> b; start_states: [c a];`.state() )
+      .toThrow()
+  } );
+
+  test('List multiple, nonsense and disagreeing', () => {
+    expect( () => sm`a -> b; start_states: [c b];`.state() )
+      .toThrow()
+  } );
+
+  test('List multiple, dual nonsense', () => {
+    expect( () => sm`a -> b; start_states: [c d];`.state() )
+      .toThrow()
+  } );
+
+  test('List multiple, repeating agreeing', () => {
+    expect( () => sm`a -> b; start_states: [a a];`.state() )
+      .toThrow()
+  } );
+
+  test('List multiple, repeating disagreeing', () => {
+    expect( () => sm`a -> b; start_states: [b b];`.state() )
+      .toThrow()
+  } );
+
+  test('List multiple, repeating nonsense', () => {
+    expect( () => sm`a -> b; start_states: [c c];`.state() )
+      .toThrow()
+  } );
+
+});
diff --git a/src/ts/tests/state_labels.spec.ts b/src/ts/tests/state_labels.spec.ts
new file mode 100644
index 00000000..9abf9431
--- /dev/null
+++ b/src/ts/tests/state_labels.spec.ts
@@ -0,0 +1,62 @@
+
+import { sm, Machine } from '../jssm';
+
+
+
+
+
+describe('State style', () => {
+
+  test(`Atom labels don't throw`, () =>
+    expect( () => { const _foo = sm`a -> b; state a: { label: atomtest; };`; })
+      .not.toThrow() );
+
+  test(`String labels don't throw`, () =>
+    expect( () => { const _foo = sm`a -> b; state a: { label: "string test"; };`; })
+      .not.toThrow() );
+
+  test(`Atom labels read out correctly`, () =>
+    expect( sm`a -> b; state a: { label: atomtest; };`.label_for('a') )
+      .toBe('atomtest') );
+
+  test(`String labels read out correctly`, () =>
+    expect( sm`a -> b; state a: { label: "string test"; };`.label_for('a') )
+      .toBe('string test') );
+
+  test(`Missing labels read out as undefined`, () =>
+    expect( sm`a -> b; state a: { label: atomtest; };`.label_for('b') )
+      .toBe(undefined) );
+
+});
+
+
+
+
+
+describe('State style defects', () => {
+
+  test(`Atom labels can't repeat`, () =>
+    expect( () => { const _foo = sm`a -> b; state a: { label: atomtest; label: atomtest; };`; })
+      .toThrow() );
+
+  test(`String labels can't repeat`, () =>
+    expect( () => { const _foo = sm`a -> b; state a: { label: "string test"; label: "string test"; };`; })
+      .toThrow() );
+
+  test(`Atom labels can't cohabitate with string labels`, () =>
+    expect( () => { const _foo = sm`a -> b; state a: { label: atomtest; label: "string test"; };`; })
+      .toThrow() );
+
+  test(`Can't repeat from datastructure notation either`, () =>
+    expect( () => {
+      new Machine( {
+        "start_states"      : ["a"],
+        "end_states"        : [],
+        "transitions"       : [{"from":"a","to":"b","kind":"legal","forced_only":false,"main_path":false}],
+        "state_property"    : [],
+        "state_declaration" : [{"state":"a","declarations":[{"key":"state-label","value":"foo"},{"key":"state-label","value":"foo"}]}]
+      });
+    })
+      .toThrow() );
+
+});
diff --git a/src/ts/tests/state_style.spec.ts b/src/ts/tests/state_style.spec.ts
index 19833a9a..5aa7cd4d 100644
--- a/src/ts/tests/state_style.spec.ts
+++ b/src/ts/tests/state_style.spec.ts
@@ -1,7 +1,15 @@
 
 import { Shapes, LineStyles } from './constants.spec';
 
-import { sm } from '../jssm';
+import { sm, state_style_condense } from '../jssm';
+
+import {
+  base_state_style,
+  base_start_state_style,
+  base_end_state_style,
+  base_terminal_state_style,
+  base_active_state_style
+} from '../themes/jssm_base_stylesheet';
 
 
 
@@ -45,29 +53,44 @@ describe('State style', () => {
 
     // TODO FIXME it turns out state: , start_state: , and end_state: are on vestigial productions.  fix it
 
-    // test(`can set regular state border line style to ${linestyle}`, () =>
-    //   expect( () => {
-    //     const _foo = sm`machine_name: bob; state: { linestyle: ${linestyle}; }; a->b;`;
-    //   }).not.toThrow() );
+    test(`can set regular state border line style to ${linestyle} using no-dash`, () =>
+      expect( () => {
+        const _foo = sm`machine_name: bob; state: { linestyle: ${linestyle}; }; a->b;`;
+      }).not.toThrow() );
+
+    test(`can set regular state border line style to ${linestyle}`, () =>
+      expect( () => {
+        const _foo = sm`machine_name: bob; a->b; state a: { line-style: ${linestyle}; }; `;
+      }).not.toThrow() );
 
-    // test(`can set start state border line style to ${linestyle}`, () =>
-    //   expect( () => {
-    //     const _foo = sm`machine_name: bob; start_state: { linestyle: ${linestyle}; }; a->b;`;
-    //   }).not.toThrow() );
+    test(`can set active state border line style to ${linestyle}`, () =>
+      expect( () => {
+        const _foo = sm`machine_name: bob; a->b; active_state: { line-style: ${linestyle}; }; `;
+      }).not.toThrow() );
 
-    // test(`can set end state border line style to ${linestyle}`, () =>
-    //   expect( () => {
-    //     const _foo = sm`machine_name: bob; end_state: { linestyle: ${linestyle}; }; a->b;`;
-    //   }).not.toThrow() );
+    test(`can set terminal state border line style to ${linestyle}`, () =>
+      expect( () => {
+        const _foo = sm`machine_name: bob; a->b; terminal_state: { line-style: ${linestyle}; }; `;
+      }).not.toThrow() );
 
-    test(`can set specific state border line style to ${linestyle}`, () =>
+    test(`can set start state border line style to ${linestyle} using no-dash`, () =>
+      expect( () => {
+        const _foo = sm`machine_name: bob; start_state: { linestyle: ${linestyle}; }; a->b;`;
+      }).not.toThrow() );
+
+    test(`can set end state border line style to ${linestyle} using no-dash`, () =>
+      expect( () => {
+        const _foo = sm`machine_name: bob; end_state: { linestyle: ${linestyle}; }; a->b;`;
+      }).not.toThrow() );
+
+    test(`can set specific state border line style to ${linestyle} using no-dash notation`, () =>
       expect( () => {
         const _foo = sm`machine_name: bob; a->b; state a: { linestyle: ${linestyle}; }; `;
       }).not.toThrow() );
 
     test(`can set transition line style to ${linestyle}`, () =>
       expect( () => {
-        const _foo = sm`machine_name: bob; a{ linestyle: ${linestyle}; }->b;`;
+        const _foo = sm`machine_name: bob; a{ line-style: ${linestyle}; }->b;`;
       }).not.toThrow() );
 
 
@@ -79,4 +102,281 @@ describe('State style', () => {
 
 
 
-test.todo('Read the actual values back out');
+
+
+describe('Default state style', () => {
+
+  test(`can set default state style`, () =>
+    expect( () => {
+      const _foo = sm`state: { shape: circle; }; a->b;`;
+    }).not.toThrow() );
+
+  test(`can set hooked state style`, () =>
+    expect( () => {
+      const _foo = sm`hooked_state: { shape: circle; }; a->b;`;
+    }).not.toThrow() );
+
+  test(`can set active state style`, () =>
+    expect( () => {
+      const _foo = sm`active_state: { shape: circle; }; a->b;`;
+    }).not.toThrow() );
+
+  test(`can set terminal state style`, () =>
+    expect( () => {
+      const _foo = sm`terminal_state: { shape: circle; }; a->b;`;
+    }).not.toThrow() );
+
+  test(`can set start state style`, () =>
+    expect( () => {
+      const _foo = sm`start_state: { shape: circle; }; a->b;`;
+    }).not.toThrow() );
+
+  test(`can set end state style`, () =>
+    expect( () => {
+      const _foo = sm`end_state: { shape: circle; }; a->b;`;
+    }).not.toThrow() );
+
+  describe(`All style sets read back out`, () => {
+
+    const foo = sm`
+      a->b;
+      state: { shape: circle; background-color: red; };
+      active_state: { shape: ellipse; };
+      start_state: { shape: box; };
+      end_state: { shape: box3d; };
+      terminal_state: { shape: house; };
+      hooked_state: { shape: plain; };
+    `;
+
+    test('standard reads out', () => {
+      expect( foo.standard_state_style ).toStrictEqual( { shape: 'circle', backgroundColor: '#ff0000ff' } );
+    });
+
+    test('active reads out', () => {
+      expect( foo.active_state_style ).toStrictEqual( { shape: 'ellipse' } );
+    });
+
+    test('start reads out', () => {
+      expect( foo.start_state_style ).toStrictEqual( { shape: 'box' } );
+    });
+
+    test('end reads out', () => {
+      expect( foo.end_state_style ).toStrictEqual( { shape: 'box3d' } );
+    });
+
+    test('terminal reads out', () => {
+      expect( foo.terminal_state_style ).toStrictEqual( { shape: 'house' } );
+    });
+
+    test('hooked reads out', () => {
+      expect( foo.hooked_state_style ).toStrictEqual( { shape: 'plain' } );
+    });
+
+  });
+
+  describe(`All properties read back out`, () => {
+
+    const foo = sm`
+      a->b;
+      state: { shape: circle; background-color: red; color: blue; text-color: green; corners: rounded; line-style: dashed; border-color: yellow; };
+    `;
+
+    test('shape reads out', () => {
+      expect( foo.standard_state_style.shape ).toEqual( 'circle' );
+    });
+
+    test('background-color reads out', () => {
+      expect( foo.standard_state_style.backgroundColor ).toEqual( '#ff0000ff' );
+    });
+
+    test('color reads out', () => {
+      expect( foo.standard_state_style.color ).toEqual( '#0000ffff' );
+    });
+
+    test('text-color reads out', () => {
+      expect( foo.standard_state_style.textColor ).toEqual( '#008000ff' );
+    });
+
+    test('corners read out', () => {
+      expect( foo.standard_state_style.corners ).toEqual( 'rounded' );
+    });
+
+    test('line-style reads out', () => {
+      expect( foo.standard_state_style.lineStyle ).toEqual( 'dashed' );
+    });
+
+    test('border-color reads out', () => {
+      expect( foo.standard_state_style.borderColor ).toEqual( '#ffff00ff' );
+    });
+
+  });
+
+  describe(`All properties overridable from inline`, () => {
+
+    const foo = sm`
+      a->b;
+      state   : { shape: circle;    background-color: red;    color: blue;   text-color: green; corners: rounded; line-style: dashed; border-color: yellow; };
+      state a : { shape: rectangle; background-color: purple; color: orange; text-color: cyan;  corners: lined;   line-style: dotted; border-color: brown;  };
+    `;
+
+    const sa = foo.style_for('a');
+
+    test('shape reads out', () => {
+      expect( sa.shape ).toEqual( 'rectangle' );
+    });
+
+    test('background-color reads out', () => {
+      expect( sa.backgroundColor ).toEqual( '#800080ff' );
+    });
+
+    test('color reads out', () => {
+      expect( sa.color ).toEqual( '#ffa500ff' );
+    });
+
+    test('text-color reads out', () => {
+      expect( sa.textColor ).toEqual( '#00ffffff' );
+    });
+
+    test('corners read out', () => {
+      expect( sa.corners ).toEqual( 'lined' );
+    });
+
+    test('line-style reads out', () => {
+      expect( sa.lineStyle ).toEqual( 'dotted' );
+    });
+
+    test('border-color reads out', () => {
+      expect( sa.borderColor ).toEqual( '#a52a2aff' );
+    });
+
+  });
+
+  describe(`All properties block doublings`, () => {
+
+    test('shape blocks doublings', () => {
+      expect( () => sm`a->b; state: { shape: circle; shape: circle; };` ).toThrow();
+    });
+
+    test('background-color blocks doublings', () => {
+      expect( () => sm`a->b; state: { background-color: red; background-color: red; };` ).toThrow();
+    });
+
+    test('color blocks doublings', () => {
+      expect( () => sm`a->b; state: { color: blue; color: blue; };` ).toThrow();
+    });
+
+    test('text-color blocks doublings', () => {
+      expect( () => sm`a->b; state: { text-color: green; text-color: green; };` ).toThrow();
+    });
+
+    test('corners block doublings', () => {
+      expect( () => sm`a->b; state: { corners: rounded; corners: rounded; };` ).toThrow();
+    });
+
+    test('line-style blocks doublings', () => {
+      expect( () => sm`a->b; state: { line-style: dashed; line-style: dashed; };` ).toThrow();
+    });
+
+    test('label blocks doublings', () => {
+      expect( () => sm`a->b; state: { label: butt; label: chunks; };` ).toThrow();
+    });
+
+    test('border-color blocks doublings', () => {
+      expect( () => sm`a->b; state: { border-color: yellow; border-color: yellow; };` ).toThrow();
+    });
+
+  });
+
+});
+
+
+
+
+
+describe('application order', () => {
+
+  // end state should override terminal, so e is end, but f is terminal
+
+  // TODO doesn't cover themes
+  // TODO doesn't cover hooked nodes
+  const zed = sm`start_states: [a b]; end_states: [e]; [a b] -> c -> d -> [e f];`;
+  zed.go('c');
+
+  test('start states style appropriately', () => {
+    expect( zed.style_for('a').backgroundColor )
+      .toEqual( base_start_state_style.backgroundColor );
+  });
+
+  test('end states style appropriately', () => {
+    expect( zed.style_for('e').backgroundColor )
+      .toEqual( base_end_state_style.backgroundColor );
+  });
+
+  test('terminal states style appropriately', () => {
+    expect( zed.style_for('f').backgroundColor )
+      .toEqual( base_terminal_state_style.backgroundColor );
+  });
+
+  test('standard states style appropriately', () => {
+    expect( zed.style_for('d').backgroundColor )
+      .toEqual( base_state_style.backgroundColor );
+  });
+
+  test('active states style appropriately', () => {
+    expect( zed.style_for('c').backgroundColor )
+      .toEqual( base_active_state_style.backgroundColor );
+  });
+
+});
+
+
+
+
+
+describe('state_style_condense is immune to nonsense properties', () => {
+
+  test('failed key', () => {
+
+    expect(
+
+      () =>
+        state_style_condense([{key: 'this is not a valid key'}] as any)
+
+    ).toThrow();
+
+  });
+
+  test('missing key', () => {
+
+    expect(
+
+      () =>
+        state_style_condense([{there_is_no_key: 'there is no spoon'}] as any)
+
+    ).toThrow();
+
+  });
+
+  test('not an object item', () => {
+
+    expect(
+
+      () =>
+        state_style_condense([false] as any)
+
+    ).toThrow();
+
+  });
+
+  test('not an array', () => {
+
+    expect(
+
+      () =>
+        state_style_condense(false as any)
+
+    ).toThrow();
+
+  });
+
+});
diff --git a/src/ts/tests/synonym.spec.ts b/src/ts/tests/synonym.spec.ts
new file mode 100644
index 00000000..88189906
--- /dev/null
+++ b/src/ts/tests/synonym.spec.ts
@@ -0,0 +1,30 @@
+
+import * as jssm from '../jssm';
+
+
+
+
+
+test('go (synonym of transition)', () => {
+
+  const machine = jssm.sm`a -> b;`,
+        result  = machine.go('b');
+
+  expect( result ).toBe( true );
+  expect( machine.state() ).toBe('b');
+
+});
+
+
+
+
+
+test('do (synonym of action)', () => {
+
+  const machine = jssm.sm`a 'next' -> b;`,
+        result  = machine.do('next');
+
+  expect( result ).toBe( true );
+  expect( machine.state() ).toBe('b');
+
+});
diff --git a/src/ts/tests/theme.spec.ts b/src/ts/tests/theme.spec.ts
index 6225ee41..1d03d1fe 100644
--- a/src/ts/tests/theme.spec.ts
+++ b/src/ts/tests/theme.spec.ts
@@ -1,25 +1,26 @@
 
-import { Themes } from './constants.spec';
+import { Themes }             from './constants.spec';
 
-import { sm } from '../jssm';
+import { sm, compile, parse } from '../jssm';
+import { FslThemes }          from '../jssm_types';
 
 
 
 
 
 const baseline       = sm`theme: ocean; z -> q;`,
-      baseline_theme = baseline.theme();
+      baseline_theme = baseline.themes;
 
 test('Themes sound like the ocean', () =>
-  expect(baseline_theme).toBe('ocean') );
+  expect(baseline_theme).toStrictEqual(['ocean']) );
 
 
 
 const no_baseline       = sm`z -> q;`,
-      no_baseline_theme = no_baseline.theme();
+      no_baseline_theme = no_baseline.themes;
 
 test('No theme sounds like none', () =>
-  expect(no_baseline_theme).toBe('default') );
+  expect(no_baseline_theme).toStrictEqual(['default']) );
 
 
 
@@ -33,13 +34,64 @@ describe('Named themes', () => {
 
   Themes.map(thisTheme =>
     test(`Theme "${thisTheme}" shows correct theme`, () =>
-      expect( sm`theme: ${thisTheme}; a-> b;`.theme() ).toBe(thisTheme) ) );
+      expect( sm`theme: ${thisTheme}; a-> b;`.themes ).toStrictEqual([thisTheme]) ) );
 
   Themes.map(thisTheme =>
     test(`Missing theme shows theme "default"`, () =>
-      expect( sm`a-> b;`.theme() ).toBe("default") ) );
+      expect( sm`a-> b;`.themes ).toStrictEqual(["default"]) ) );
 
-  test('Fake theme throws', () =>
+  test('Fake theme throws at the parser level', () =>
     expect( () => { const _foo = sm`theme: zeghezgqqqqthirteen; a-> b;`; }).toThrow() );
 
+  test('Fake theme throws at the VM level', () =>
+    expect( () => { const _foo = compile(parse(`theme: zeghezgqqqqthirteen; a->b;`)); } ).toThrow() );
+
+});
+
+
+
+
+
+describe('Multiple themes', () => {
+
+  test(`Theme "[ocean modern]" parses as a theme`, () =>
+    expect( () => { const _foo = sm`theme: [ocean modern]; a-> b;`; }).not.toThrow() );
+
+  test(`Theme "[ocean modern]" shows first theme as dominant`, () =>
+    expect( sm`theme: [ocean modern]; a->b;`.themes ).toStrictEqual(['ocean','modern']) );
+
+  test(`Theme "[ocean modern]" shows first theme as dominant`, () =>
+    expect( sm`theme: [ocean modern]; a->b;`.style_for('a').backgroundColor ).toBe('deepskyblue') );
+
+  test('Fake theme throws at the parser level', () =>
+    expect( () => { const _foo = sm`theme: [ocean zeghezgqqqqthirteen]; a-> b;`; }).toThrow() );
+
+});
+
+
+
+
+
+describe('Check theme registration', () => {
+
+  test('FslThemes list matches sm``.all_themes(), post-sort', () =>
+    expect( sm`a->b;`.all_themes().sort() ).toStrictEqual([... FslThemes].sort()) );
+
+});
+
+
+
+
+
+test('Theme change', () => {
+
+  const foo = sm`a->b;`;
+  expect(foo.themes).toStrictEqual(['default']);
+
+  foo.themes = 'ocean';
+  expect(foo.themes).toStrictEqual(['ocean']);
+
+  foo.themes = ['ocean', 'default'];
+  expect(foo.themes).toStrictEqual(['ocean', 'default']);
+
 });
diff --git a/src/ts/tests/unicode-actions.uspec.ts b/src/ts/tests/unicode-actions.uspec.ts
new file mode 100644
index 00000000..d1645c74
--- /dev/null
+++ b/src/ts/tests/unicode-actions.uspec.ts
@@ -0,0 +1,38 @@
+
+import { sm, compile, parse } from '../jssm';
+
+import { test_range_with, atom_skips } from './unicode.uspec-driver';
+
+
+
+
+
+const atom_test = (idx: number): boolean => {
+
+  const cp = String.fromCodePoint(idx);
+
+  if (!(atom_skips.includes(cp))) {
+
+    let test;
+
+    try {
+      test = sm`source '${cp}' -> target;`;
+    } catch (e) {
+      throw new Error(`Broke on ${idx} "${cp}"`);
+    }
+
+    expect( test.actions().includes(cp) ).toBe(true);
+
+  }
+
+  return true;
+
+};
+
+
+
+
+
+describe('Characters as atoms', () => {
+  test_range_with(1, atom_test);
+});
diff --git a/src/ts/tests/unicode-atom-labels.uspec.ts b/src/ts/tests/unicode-atom-labels.uspec.ts
new file mode 100644
index 00000000..4e9338ce
--- /dev/null
+++ b/src/ts/tests/unicode-atom-labels.uspec.ts
@@ -0,0 +1,38 @@
+
+import { sm, compile, parse } from '../jssm';
+
+import { test_range_with, atom_skips } from './unicode.uspec-driver';
+
+
+
+
+
+const atom_test = (idx: number): boolean => {
+
+  const cp = String.fromCodePoint(idx);
+
+  if (!(atom_skips.includes(cp))) {
+
+    let test;
+
+    try {
+      test = sm`source -> target; state source: { label: ${cp}; };`;
+    } catch (e) {
+      throw new Error(`Broke on ${idx} "${cp}"`);
+    }
+
+    expect( test.actions().includes(cp) ).toBe(true);
+
+  }
+
+  return true;
+
+};
+
+
+
+
+
+describe('Characters as atom labels', () => {
+  test_range_with(1, atom_test);
+});
diff --git a/src/ts/tests/unicode-atoms.uspec.ts b/src/ts/tests/unicode-atoms.uspec.ts
new file mode 100644
index 00000000..ac4b0da1
--- /dev/null
+++ b/src/ts/tests/unicode-atoms.uspec.ts
@@ -0,0 +1,42 @@
+
+import { sm, compile, parse } from '../jssm';
+
+import { test_range_with, atom_skips } from './unicode.uspec-driver';
+
+
+
+
+
+const atom_test = (idx: number): boolean => {
+
+  const cp = String.fromCodePoint(idx);
+
+  if (!(atom_skips.includes(cp))) {
+
+    let left_test, middle_test, right_test;
+
+    try {
+      left_test   = sm`${cp} -> target;`,
+      middle_test = sm`source -> ${cp} -> target;`,
+      right_test  = sm`source -> ${cp};`;
+    } catch (e) {
+      throw new Error(`Broke on ${idx} "${cp}"`);
+    }
+
+    expect( left_test.has_state(cp)   ).toBe(true);
+    expect( right_test.has_state(cp)  ).toBe(true);
+    expect( middle_test.has_state(cp) ).toBe(true);
+
+  }
+
+  return true;
+
+};
+
+
+
+
+
+describe('Characters as atoms', () => {
+  test_range_with(3, atom_test);
+});
diff --git a/src/ts/tests/unicode-string-labels.uspec.ts b/src/ts/tests/unicode-string-labels.uspec.ts
new file mode 100644
index 00000000..05318e69
--- /dev/null
+++ b/src/ts/tests/unicode-string-labels.uspec.ts
@@ -0,0 +1,38 @@
+
+import { sm, compile, parse } from '../jssm';
+
+import { test_range_with, atom_skips } from './unicode.uspec-driver';
+
+
+
+
+
+const atom_test = (idx: number): boolean => {
+
+  const cp = String.fromCodePoint(idx);
+
+  if (!(atom_skips.includes(cp))) {
+
+    let test;
+
+    try {
+      test = sm`source -> target; state source: { label: "${cp}"; };`;
+    } catch (e) {
+      throw new Error(`Broke on ${idx} "${cp}"`);
+    }
+
+    expect( test.actions().includes(cp) ).toBe(true);
+
+  }
+
+  return true;
+
+};
+
+
+
+
+
+describe('Characters as string labels', () => {
+  test_range_with(1, atom_test);
+});
diff --git a/src/ts/tests/unicode-strings.uspec.ts b/src/ts/tests/unicode-strings.uspec.ts
new file mode 100644
index 00000000..ac4b0da1
--- /dev/null
+++ b/src/ts/tests/unicode-strings.uspec.ts
@@ -0,0 +1,42 @@
+
+import { sm, compile, parse } from '../jssm';
+
+import { test_range_with, atom_skips } from './unicode.uspec-driver';
+
+
+
+
+
+const atom_test = (idx: number): boolean => {
+
+  const cp = String.fromCodePoint(idx);
+
+  if (!(atom_skips.includes(cp))) {
+
+    let left_test, middle_test, right_test;
+
+    try {
+      left_test   = sm`${cp} -> target;`,
+      middle_test = sm`source -> ${cp} -> target;`,
+      right_test  = sm`source -> ${cp};`;
+    } catch (e) {
+      throw new Error(`Broke on ${idx} "${cp}"`);
+    }
+
+    expect( left_test.has_state(cp)   ).toBe(true);
+    expect( right_test.has_state(cp)  ).toBe(true);
+    expect( middle_test.has_state(cp) ).toBe(true);
+
+  }
+
+  return true;
+
+};
+
+
+
+
+
+describe('Characters as atoms', () => {
+  test_range_with(3, atom_test);
+});
diff --git a/src/ts/tests/unicode.uspec-driver.ts b/src/ts/tests/unicode.uspec-driver.ts
new file mode 100644
index 00000000..ab10e5c8
--- /dev/null
+++ b/src/ts/tests/unicode.uspec-driver.ts
@@ -0,0 +1,82 @@
+
+import { sm, compile, parse } from '../jssm';
+import { readFileSync }       from 'fs';
+
+const block_data = `${readFileSync('./src/ts/tests/UnicodeBlocks-14.0.0.txt')}`.split('\n'),
+      block_rows = block_data.filter(remove_blanks_and_comments),
+      blocks     = block_rows.reduce(accumulate_block_object, {});
+
+
+
+
+
+function remove_blanks_and_comments(line: string): boolean {
+
+  if (line.charAt(0) === '#')   { return false; }
+  if (line.trim().length === 0) { return false; }
+
+  return true;
+
+}
+
+
+
+
+
+function accumulate_block_object(acc: Object, cur: string): Object {
+
+  const pair    = cur.trim().split('; '),
+        range   = pair[0],
+        label   = pair[1],
+        range_p = range.split('..'),
+        range_l = parseInt(range_p[0], 16),
+        range_r = parseInt(range_p[1], 16);
+
+  if ((range !== undefined) && (label !== undefined)) {
+    acc[label.trim()] = [range_l, range_r];
+    return acc;
+  } else {
+    throw new Error(`Bad row: ${cur}`);
+  }
+
+}
+
+
+
+
+
+const atom_start = 32,
+      atom_skips = ' "#%&\'()+-/:;<=>@[\\]`{|}~⌂\x7F'.split('');
+
+
+
+
+
+function test_range_with(tmult: number, func: (number) => boolean) {
+
+  Object.keys(blocks).forEach(blockname => {
+
+    const lo = blocks[blockname][0],
+          hi = blocks[blockname][1],
+          sz = hi - lo;
+
+    test(`${blockname}, ${sz} ch, ${sz*tmult} tests`, () => {
+
+      for (let idx = Math.max(blocks[blockname][0], atom_start); idx <= blocks[blockname][1]; ++idx) {
+        func(idx);
+      }
+
+    });
+
+  });
+
+}
+
+
+
+
+
+export {
+  test_range_with,
+  atom_skips, atom_start
+};
diff --git a/src/ts/tests/util.spec.ts b/src/ts/tests/util.spec.ts
index 906e471c..f1d1612f 100644
--- a/src/ts/tests/util.spec.ts
+++ b/src/ts/tests/util.spec.ts
@@ -1,5 +1,82 @@
 
-import { seq, make_mulberry_rand } from '../jssm_util';
+import {
+  seq,
+  unique,
+  find_repeated,
+  make_mulberry_rand,
+  name_bind_prop_and_state
+} from '../jssm_util';
+
+import { unique        as jssm_unique        } from '../jssm';
+import { find_repeated as jssm_find_repeated } from '../jssm';
+
+
+
+
+
+describe('seq', () => {
+
+  test('zero', () => {
+    expect(seq(0)).toStrictEqual([]);
+  });
+
+  test('one', () => {
+    expect(seq(1)).toStrictEqual([0]);
+  });
+
+  test('five', () => {
+    expect(seq(5)).toStrictEqual([0,1,2,3,4]);
+  });
+
+  test('fractions must throw', () => {
+    expect( () => seq( 1.5 ) ).toThrow();
+  });
+
+  test('negatives must throw', () => {
+    expect( () => seq( -2 ) ).toThrow();
+  });
+
+  test('NaN must throw', () => {
+    expect( () => seq( NaN ) ).toThrow();
+  });
+
+  test('positive infinity must throw', () => {
+    expect( () => seq( Number.POSITIVE_INFINITY ) ).toThrow();
+  });
+
+  test('negative infinity must throw', () => {
+    expect( () => seq( Number.NEGATIVE_INFINITY ) ).toThrow();
+  });
+
+  test('strings must throw', () => {
+    expect( () => seq( "2" as any ) ).toThrow();
+  });
+
+  test('arrays must throw', () => {
+    expect( () => seq( [2] as any ) ).toThrow();
+  });
+
+  test('objects must throw', () => {
+    expect( () => seq( {two: 2} as any ) ).toThrow();
+  });
+
+  test('booleans must throw', () => {
+    expect( () => seq( false as any ) ).toThrow();
+  });
+
+  test('symbols must throw', () => {
+    expect( () => seq( Symbol('two') as any ) ).toThrow();
+  });
+
+  test('undefined must throw', () => {
+    expect( () => seq( undefined as any ) ).toThrow();
+  });
+
+  test('null must throw', () => {
+    expect( () => seq( null as any ) ).toThrow();
+  });
+
+});
 
 
 
@@ -7,51 +84,199 @@ import { seq, make_mulberry_rand } from '../jssm_util';
 
 describe('make_mulberry_rand', () => {
 
+
+
   seq(3).map(n =>
 
     test(`Seed ${n} - Generates 500 numbers [0,1)`, () => {
+
       const rnd  = make_mulberry_rand(n);
       let   fail = false;
+
       seq(500).forEach(_ => {
+
         const r = rnd();
+
         if (typeof r !== 'number') { fail = true; }
         if (r < 0)                 { fail = true; }
         if (r >= 1)                { fail = true; }
+
       });
+
       expect(fail).toBe(false);
+
     })
 
   );
 
-  const rnd = () => Math.floor(make_mulberry_rand( new Date().getTime() )() * Number.MAX_SAFE_INTEGER );
 
-  [ rnd(), rnd(), rnd(), rnd(), rnd() ].map( n => {
+
+  const rnd = (n) => Math.floor(make_mulberry_rand( new Date().getTime()+n )() * Number.MAX_SAFE_INTEGER );
+
+  [ rnd(0), rnd(1), rnd(2), rnd(3), rnd(4) ].map( n =>
 
     test(`Seed ${n} - Generates 500 numbers [0,1)`, () => {
+
       const rnd  = make_mulberry_rand(n);
       let   fail = false;
+
       seq(500).forEach(_ => {
+
         const r = rnd();
+
         if (typeof r !== 'number') { fail = true; }
         if (r < 0)                 { fail = true; }
         if (r >= 1)                { fail = true; }
+
       });
+
       expect(fail).toBe(false);
-    });
 
-  });
+    })
+
+  );
+
+
 
   test(`Seed undefined - Generates 500 numbers [0,1)`, () => {
+
     const rnd  = make_mulberry_rand();
     let   fail = false;
+
     seq(500).forEach(_ => {
+
       const r = rnd();
+
       if (typeof r !== 'number') { fail = true; }
       if (r < 0)                 { fail = true; }
       if (r >= 1)                { fail = true; }
+
     });
+
     expect(fail).toBe(false);
+
   });
 
 
+
+});
+
+
+
+
+
+describe('unique', () => {
+
+  test('empty', () => {
+    expect(unique([])).toStrictEqual([]);
+  });
+
+  test('1', () => {
+    expect(unique([1])).toStrictEqual([1]);
+  });
+
+  test('1,1', () => {
+    expect(unique([1,1])).toStrictEqual([1]);
+  });
+
+  test('1,2', () => {
+    expect(unique([1,2])).toStrictEqual([1,2]);
+  });
+
+  test('1,2,1,2', () => {
+    expect(unique([1,2,1,2])).toStrictEqual([1,2]);
+  });
+
+  test('1,2,1.0,2.0', () => {
+    expect(unique([1,2,1.0,2.0])).toStrictEqual([1,2]);
+  });
+
+  test('external call 1,2,1.0,2.0', () => {
+    expect(jssm_unique([1,2,1.0,2.0])).toStrictEqual([1,2]);
+  });
+
+  test('"one","two","one"', () => {
+    expect(unique(["one","two","one"])).toStrictEqual(["one","two"]);
+  });
+
+  test('false,true,false', () => {
+    expect(unique([false,true,false])).toStrictEqual([false,true]);
+  });
+
+  test('NaN,undefined,null,NaN,undefined,null mixed type', () => {
+    expect(unique([NaN,undefined,null,NaN,undefined,null])).toStrictEqual([undefined,null]);
+  });
+
+  test('[1],[1]', () => {
+    expect(unique([ [1],[1] ])).toStrictEqual([ [1],[1] ]);
+  });
+
+  test('{one:1},{one:1}', () => {
+    expect(unique([{one:1},{one:1}])).toStrictEqual([ {one:1},{one:1} ]);
+  });
+
+});
+
+
+
+
+
+describe('find_repeated', () => {
+
+  test('empty', () => {
+    expect(find_repeated([])).toStrictEqual([]);
+  });
+
+  test('"a"', () => {
+    expect(find_repeated(["a"])).toStrictEqual([]);
+  });
+
+  test('"a","a"', () => {
+    expect(find_repeated(["a","a"])).toStrictEqual([ ["a",2] ]);
+  });
+
+  test('"a","a","a"', () => {
+    expect(find_repeated(["a","a","a"])).toStrictEqual([ ["a", 3] ]);
+  });
+
+  test('"a","b","a"', () => {
+    expect(find_repeated(["a","b","a"])).toStrictEqual([ ["a", 2] ]);
+  });
+
+  test('"a","b","a","b"', () => {
+    expect(find_repeated(["a","b","a","b"])).toStrictEqual([ ["a",2], ["b",2] ]);
+  });
+
+  test('"a","b","c","b","a"', () => {
+    expect(find_repeated(["a","b","c","b","a"])).toStrictEqual([ ["a",2], ["b",2] ]);
+  });
+
+  test('"a","b","c","b","a"', () => {
+    expect(find_repeated([0, NaN, 0, NaN])).toStrictEqual([ [0,2] ]);
+  });
+
+  test('External call "a","b","c","b","a"', () => {
+    expect(jssm_find_repeated([0, NaN, 0, NaN])).toStrictEqual([ [0,2] ]);
+  });
+
+});
+
+
+
+
+
+describe('name_bind_prop_and_state', () => {
+
+  test('a,b', () => {
+    expect(name_bind_prop_and_state('a','b')).toBe('["a","b"]');
+  });
+
+  test('false,b', () => {
+    expect(() => name_bind_prop_and_state(false as any, 'b')).toThrow();
+  });
+
+  test('a,false', () => {
+    expect(() => name_bind_prop_and_state('a', false as any)).toThrow();
+  });
+
 });
diff --git a/src/ts/themes/jssm_base_stylesheet.ts b/src/ts/themes/jssm_base_stylesheet.ts
new file mode 100644
index 00000000..92637b0d
--- /dev/null
+++ b/src/ts/themes/jssm_base_stylesheet.ts
@@ -0,0 +1,146 @@
+
+import {
+  JssmStateConfig,
+  JssmBaseTheme
+} from '../jssm_types';
+
+
+
+
+
+const base_state_style: JssmStateConfig = {
+  shape           : 'rectangle',
+  backgroundColor : 'white',
+  textColor       : 'black',
+  borderColor     : 'black'
+};
+
+
+
+
+
+const base_active_state_style: JssmStateConfig = {
+  textColor       : 'white',
+  backgroundColor : 'dodgerblue4'
+};
+
+
+
+
+
+const base_hooked_state_style: JssmStateConfig = {
+  shape : 'component'
+};
+
+
+
+
+
+const base_terminal_state_style: JssmStateConfig = {
+  textColor       : 'white',
+  backgroundColor : 'crimson'
+};
+
+
+
+
+
+const base_active_terminal_state_style: JssmStateConfig = {
+  textColor       : 'white',
+  backgroundColor : 'indigo'
+};
+
+
+
+
+
+const base_start_state_style: JssmStateConfig = {
+  backgroundColor : 'yellow'
+};
+
+
+
+
+
+const base_active_start_state_style: JssmStateConfig = {
+  backgroundColor : 'yellowgreen'
+};
+
+
+
+
+
+const base_active_hooked_state_style: JssmStateConfig = {
+  backgroundColor : 'yellowgreen'
+};
+
+
+
+
+
+const base_end_state_style: JssmStateConfig = {
+  textColor       : 'white',
+  backgroundColor : 'darkolivegreen'
+};
+
+
+
+
+
+const base_active_end_state_style: JssmStateConfig = {
+  textColor       : 'white',
+  backgroundColor : 'darkgreen'
+};
+
+
+
+
+
+const base_theme: JssmBaseTheme = {
+
+  name            : 'base',
+
+  state           : base_state_style,
+  start           : base_start_state_style,
+  end             : base_end_state_style,
+  terminal        : base_terminal_state_style,
+  hooked          : base_hooked_state_style,
+
+  active          : base_active_state_style,
+  active_start    : base_active_start_state_style,
+  active_end      : base_active_end_state_style,
+  active_terminal : base_active_terminal_state_style,
+  active_hooked   : base_active_hooked_state_style,
+
+  legal           : undefined,                  // TODO FIXME
+  main            : undefined,                  // TODO FIXME
+  forced          : undefined,                  // TODO FIXME
+
+  action          : undefined,                  // TODO FIXME
+  graph           : undefined,                  // TODO FIXME
+  title           : undefined                   // TODO FIXME
+
+};
+
+
+
+
+
+export {
+
+  base_state_style,
+  base_active_state_style,
+
+  base_terminal_state_style,
+  base_active_terminal_state_style,
+
+  base_start_state_style,
+  base_active_start_state_style,
+
+  base_end_state_style,
+  base_active_end_state_style,
+
+  base_theme,
+    base_theme as theme
+
+};
diff --git a/src/ts/themes/jssm_theme_bold.ts b/src/ts/themes/jssm_theme_bold.ts
new file mode 100644
index 00000000..b4d3c43c
--- /dev/null
+++ b/src/ts/themes/jssm_theme_bold.ts
@@ -0,0 +1,146 @@
+
+import {
+  JssmStateConfig,
+  JssmBaseTheme
+} from '../jssm_types';
+
+
+
+
+
+const base_state_style: JssmStateConfig = {
+  shape           : 'rectangle',
+  backgroundColor : 'khaki',
+  textColor       : 'black',
+  borderColor     : 'black'
+};
+
+
+
+
+
+const base_active_state_style: JssmStateConfig = {
+  textColor       : 'white',
+  backgroundColor : 'dodgerblue4'
+};
+
+
+
+
+
+const base_hooked_state_style: JssmStateConfig = {
+  shape : 'component'
+};
+
+
+
+
+
+const base_terminal_state_style: JssmStateConfig = {
+  textColor       : 'white',
+  backgroundColor : 'crimson'
+};
+
+
+
+
+
+const base_active_terminal_state_style: JssmStateConfig = {
+  textColor       : 'white',
+  backgroundColor : 'indigo'
+};
+
+
+
+
+
+const base_start_state_style: JssmStateConfig = {
+  backgroundColor : 'yellow'
+};
+
+
+
+
+
+const base_active_start_state_style: JssmStateConfig = {
+  backgroundColor : 'yellowgreen'
+};
+
+
+
+
+
+const base_active_hooked_state_style: JssmStateConfig = {
+  backgroundColor : 'yellowgreen'
+};
+
+
+
+
+
+const base_end_state_style: JssmStateConfig = {
+  textColor       : 'white',
+  backgroundColor : 'darkolivegreen'
+};
+
+
+
+
+
+const base_active_end_state_style: JssmStateConfig = {
+  textColor       : 'white',
+  backgroundColor : 'darkgreen'
+};
+
+
+
+
+
+const bold_theme: JssmBaseTheme = {
+
+  name            : 'bold',
+
+  state           : base_state_style,
+  start           : base_start_state_style,
+  end             : base_end_state_style,
+  terminal        : base_terminal_state_style,
+  hooked          : base_hooked_state_style,
+
+  active          : base_active_state_style,
+  active_start    : base_active_start_state_style,
+  active_end      : base_active_end_state_style,
+  active_terminal : base_active_terminal_state_style,
+  active_hooked   : base_active_hooked_state_style,
+
+  legal           : undefined,                  // TODO FIXME
+  main            : undefined,                  // TODO FIXME
+  forced          : undefined,                  // TODO FIXME
+
+  action          : undefined,                  // TODO FIXME
+  graph           : undefined,                  // TODO FIXME
+  title           : undefined                   // TODO FIXME
+
+};
+
+
+
+
+
+export {
+
+  base_state_style,
+  base_active_state_style,
+
+  base_terminal_state_style,
+  base_active_terminal_state_style,
+
+  base_start_state_style,
+  base_active_start_state_style,
+
+  base_end_state_style,
+  base_active_end_state_style,
+
+  bold_theme,
+    bold_theme as theme
+
+};
diff --git a/src/ts/themes/jssm_theme_default.ts b/src/ts/themes/jssm_theme_default.ts
new file mode 100644
index 00000000..9e275830
--- /dev/null
+++ b/src/ts/themes/jssm_theme_default.ts
@@ -0,0 +1,146 @@
+
+import {
+  JssmStateConfig,
+  JssmBaseTheme
+} from '../jssm_types';
+
+
+
+
+
+const base_state_style: JssmStateConfig = {
+  shape           : 'rectangle',
+  backgroundColor : 'white',
+  textColor       : 'black',
+  borderColor     : 'black'
+};
+
+
+
+
+
+const base_active_state_style: JssmStateConfig = {
+  textColor       : 'white',
+  backgroundColor : 'dodgerblue4'
+};
+
+
+
+
+
+const base_hooked_state_style: JssmStateConfig = {
+  shape : 'component'
+};
+
+
+
+
+
+const base_terminal_state_style: JssmStateConfig = {
+  textColor       : 'white',
+  backgroundColor : 'crimson'
+};
+
+
+
+
+
+const base_active_terminal_state_style: JssmStateConfig = {
+  textColor       : 'white',
+  backgroundColor : 'indigo'
+};
+
+
+
+
+
+const base_start_state_style: JssmStateConfig = {
+  backgroundColor : 'yellow'
+};
+
+
+
+
+
+const base_active_start_state_style: JssmStateConfig = {
+  backgroundColor : 'yellowgreen'
+};
+
+
+
+
+
+const base_active_hooked_state_style: JssmStateConfig = {
+  backgroundColor : 'yellowgreen'
+};
+
+
+
+
+
+const base_end_state_style: JssmStateConfig = {
+  textColor       : 'white',
+  backgroundColor : 'darkolivegreen'
+};
+
+
+
+
+
+const base_active_end_state_style: JssmStateConfig = {
+  textColor       : 'white',
+  backgroundColor : 'darkgreen'
+};
+
+
+
+
+
+const default_theme: JssmBaseTheme = {
+
+  name            : 'default',
+
+  state           : base_state_style,
+  start           : base_start_state_style,
+  end             : base_end_state_style,
+  terminal        : base_terminal_state_style,
+  hooked          : base_hooked_state_style,
+
+  active          : base_active_state_style,
+  active_start    : base_active_start_state_style,
+  active_end      : base_active_end_state_style,
+  active_terminal : base_active_terminal_state_style,
+  active_hooked   : base_active_hooked_state_style,
+
+  legal           : undefined,                  // TODO FIXME
+  main            : undefined,                  // TODO FIXME
+  forced          : undefined,                  // TODO FIXME
+
+  action          : undefined,                  // TODO FIXME
+  graph           : undefined,                  // TODO FIXME
+  title           : undefined                   // TODO FIXME
+
+};
+
+
+
+
+
+export {
+
+  base_state_style,
+  base_active_state_style,
+
+  base_terminal_state_style,
+  base_active_terminal_state_style,
+
+  base_start_state_style,
+  base_active_start_state_style,
+
+  base_end_state_style,
+  base_active_end_state_style,
+
+  default_theme,
+    default_theme as theme
+
+};
diff --git a/src/ts/themes/jssm_theme_modern.ts b/src/ts/themes/jssm_theme_modern.ts
new file mode 100644
index 00000000..2dbd254e
--- /dev/null
+++ b/src/ts/themes/jssm_theme_modern.ts
@@ -0,0 +1,146 @@
+
+import {
+  JssmStateConfig,
+  JssmBaseTheme
+} from '../jssm_types';
+
+
+
+
+
+const base_state_style: JssmStateConfig = {
+  shape           : 'rectangle',
+  backgroundColor : 'khaki',
+  textColor       : 'black',
+  borderColor     : 'black'
+};
+
+
+
+
+
+const base_active_state_style: JssmStateConfig = {
+  textColor       : 'white',
+  backgroundColor : 'dodgerblue4'
+};
+
+
+
+
+
+const base_hooked_state_style: JssmStateConfig = {
+  shape : 'component'
+};
+
+
+
+
+
+const base_terminal_state_style: JssmStateConfig = {
+  textColor       : 'white',
+  backgroundColor : 'crimson'
+};
+
+
+
+
+
+const base_active_terminal_state_style: JssmStateConfig = {
+  textColor       : 'white',
+  backgroundColor : 'indigo'
+};
+
+
+
+
+
+const base_start_state_style: JssmStateConfig = {
+  backgroundColor : 'yellow'
+};
+
+
+
+
+
+const base_active_start_state_style: JssmStateConfig = {
+  backgroundColor : 'yellowgreen'
+};
+
+
+
+
+
+const base_active_hooked_state_style: JssmStateConfig = {
+  backgroundColor : 'yellowgreen'
+};
+
+
+
+
+
+const base_end_state_style: JssmStateConfig = {
+  textColor       : 'white',
+  backgroundColor : 'darkolivegreen'
+};
+
+
+
+
+
+const base_active_end_state_style: JssmStateConfig = {
+  textColor       : 'white',
+  backgroundColor : 'darkgreen'
+};
+
+
+
+
+
+const modern_theme: JssmBaseTheme = {
+
+  name            : 'modern',
+
+  state           : base_state_style,
+  start           : base_start_state_style,
+  end             : base_end_state_style,
+  terminal        : base_terminal_state_style,
+  hooked          : base_hooked_state_style,
+
+  active          : base_active_state_style,
+  active_start    : base_active_start_state_style,
+  active_end      : base_active_end_state_style,
+  active_terminal : base_active_terminal_state_style,
+  active_hooked   : base_active_hooked_state_style,
+
+  legal           : undefined,                  // TODO FIXME
+  main            : undefined,                  // TODO FIXME
+  forced          : undefined,                  // TODO FIXME
+
+  action          : undefined,                  // TODO FIXME
+  graph           : undefined,                  // TODO FIXME
+  title           : undefined                   // TODO FIXME
+
+};
+
+
+
+
+
+export {
+
+  base_state_style,
+  base_active_state_style,
+
+  base_terminal_state_style,
+  base_active_terminal_state_style,
+
+  base_start_state_style,
+  base_active_start_state_style,
+
+  base_end_state_style,
+  base_active_end_state_style,
+
+  modern_theme,
+    modern_theme as theme
+
+};
diff --git a/src/ts/themes/jssm_theme_ocean.ts b/src/ts/themes/jssm_theme_ocean.ts
new file mode 100644
index 00000000..9e71a437
--- /dev/null
+++ b/src/ts/themes/jssm_theme_ocean.ts
@@ -0,0 +1,144 @@
+
+import {
+  JssmStateConfig,
+  JssmBaseTheme
+} from '../jssm_types';
+
+
+
+
+
+const base_state_style: JssmStateConfig = {
+  backgroundColor : 'cadetblue1',
+};
+
+
+
+
+
+const base_active_state_style: JssmStateConfig = {
+  textColor       : 'white',
+  backgroundColor : 'deepskyblue'
+};
+
+
+
+
+
+const base_hooked_state_style: JssmStateConfig = {
+  shape           : 'component',
+  backgroundColor : 'mediumaquamarine'
+};
+
+
+
+
+
+const base_terminal_state_style: JssmStateConfig = {
+  textColor       : 'white',
+  backgroundColor : 'darkviolet'
+};
+
+
+
+
+
+const base_active_terminal_state_style: JssmStateConfig = {
+  textColor       : 'white',
+  backgroundColor : 'deeppink'
+};
+
+
+
+
+
+const base_start_state_style: JssmStateConfig = {
+  backgroundColor : 'darkseagreen1'
+};
+
+
+
+
+
+const base_active_start_state_style: JssmStateConfig = {
+  backgroundColor : 'aquamarine'
+};
+
+
+
+
+
+const base_active_hooked_state_style: JssmStateConfig = {
+  backgroundColor : 'aquamarine'
+};
+
+
+
+
+
+const base_end_state_style: JssmStateConfig = {
+  textColor       : 'white',
+  backgroundColor : 'chartreuse1'
+};
+
+
+
+
+
+const base_active_end_state_style: JssmStateConfig = {
+  textColor       : 'white',
+  backgroundColor : 'darkgreen'
+};
+
+
+
+
+
+const ocean_theme: JssmBaseTheme = {
+
+  name            : 'ocean',
+
+  state           : base_state_style,
+  start           : base_start_state_style,
+  end             : base_end_state_style,
+  terminal        : base_terminal_state_style,
+  hooked          : base_hooked_state_style,
+
+  active          : base_active_state_style,
+  active_start    : base_active_start_state_style,
+  active_end      : base_active_end_state_style,
+  active_terminal : base_active_terminal_state_style,
+  active_hooked   : base_active_hooked_state_style,
+
+  legal           : undefined,                  // TODO FIXME
+  main            : undefined,                  // TODO FIXME
+  forced          : undefined,                  // TODO FIXME
+
+  action          : undefined,                  // TODO FIXME
+  graph           : undefined,                  // TODO FIXME
+  title           : undefined                   // TODO FIXME
+
+};
+
+
+
+
+
+export {
+
+  base_state_style,
+  base_active_state_style,
+
+  base_terminal_state_style,
+  base_active_terminal_state_style,
+
+  base_start_state_style,
+  base_active_start_state_style,
+
+  base_end_state_style,
+  base_active_end_state_style,
+
+  ocean_theme,
+    ocean_theme as theme
+
+};
diff --git a/src/ts/themes/jssm_theme_plain.ts b/src/ts/themes/jssm_theme_plain.ts
new file mode 100644
index 00000000..b11b96b8
--- /dev/null
+++ b/src/ts/themes/jssm_theme_plain.ts
@@ -0,0 +1,158 @@
+
+import {
+  JssmStateConfig,
+  JssmBaseTheme
+} from '../jssm_types';
+
+
+
+
+
+const base_state_style: JssmStateConfig = {
+  textColor       : 'black',
+  backgroundColor : 'transparent',
+  shape           : 'plaintext'
+};
+
+
+
+
+
+const base_active_state_style: JssmStateConfig = {
+  textColor       : 'black',
+  backgroundColor : 'transparent',
+  shape           : 'plaintext'
+};
+
+
+
+
+
+const base_hooked_state_style: JssmStateConfig = {
+  textColor       : 'black',
+  backgroundColor : 'transparent',
+  shape           : 'plaintext'
+};
+
+
+
+
+
+const base_terminal_state_style: JssmStateConfig = {
+  textColor       : 'black',
+  backgroundColor : 'transparent',
+  shape           : 'plaintext'
+};
+
+
+
+
+
+const base_active_terminal_state_style: JssmStateConfig = {
+  textColor       : 'black',
+  backgroundColor : 'transparent',
+  shape           : 'plaintext'
+};
+
+
+
+
+
+const base_start_state_style: JssmStateConfig = {
+  textColor       : 'black',
+  backgroundColor : 'transparent',
+  shape           : 'plaintext'
+};
+
+
+
+
+
+const base_active_start_state_style: JssmStateConfig = {
+  textColor       : 'black',
+  backgroundColor : 'transparent',
+  shape           : 'plaintext'
+};
+
+
+
+
+
+const base_active_hooked_state_style: JssmStateConfig = {
+  textColor       : 'black',
+  backgroundColor : 'transparent',
+  shape           : 'plaintext'
+};
+
+
+
+
+
+const base_end_state_style: JssmStateConfig = {
+  textColor       : 'black',
+  backgroundColor : 'transparent',
+  shape           : 'plaintext'
+};
+
+
+
+
+
+const base_active_end_state_style: JssmStateConfig = {
+  textColor       : 'black',
+  backgroundColor : 'transparent',
+  shape           : 'plaintext'
+};
+
+
+
+
+
+const plain_theme: JssmBaseTheme = {
+
+  name            : 'plain',
+
+  state           : base_state_style,
+  start           : base_start_state_style,
+  end             : base_end_state_style,
+  terminal        : base_terminal_state_style,
+  hooked          : base_hooked_state_style,
+
+  active          : base_active_state_style,
+  active_start    : base_active_start_state_style,
+  active_end      : base_active_end_state_style,
+  active_terminal : base_active_terminal_state_style,
+  active_hooked   : base_active_hooked_state_style,
+
+  legal           : undefined,                  // TODO FIXME
+  main            : undefined,                  // TODO FIXME
+  forced          : undefined,                  // TODO FIXME
+
+  action          : undefined,                  // TODO FIXME
+  graph           : undefined,                  // TODO FIXME
+  title           : undefined                   // TODO FIXME
+
+};
+
+
+
+
+
+export {
+
+  base_state_style,
+  base_active_state_style,
+
+  base_terminal_state_style,
+  base_active_terminal_state_style,
+
+  base_start_state_style,
+  base_active_start_state_style,
+
+  base_end_state_style,
+  base_active_end_state_style,
+
+  plain_theme,
+    plain_theme as theme
+
+};
diff --git a/src/ts/version.ts b/src/ts/version.ts
index 55826ef4..0fce1e9f 100644
--- a/src/ts/version.ts
+++ b/src/ts/version.ts
@@ -1,3 +1,5 @@
 
-const version: string = "5.77.0";
-export { version };
+const version    : string = "5.87.0",
+      build_time : number = 1670139024155;
+
+export { version, build_time };
diff --git a/typedoc-options.js b/typedoc-options.js
index c7b49036..55655e7d 100644
--- a/typedoc-options.js
+++ b/typedoc-options.js
@@ -27,7 +27,7 @@ module.exports = {
             { title: 'Node',        source: 'todo.md' },
             { title: 'Typescript',  source: 'todo.md' },
             { title: 'The browser', source: 'todo.md' },
-            { title: 'Deno',        source: 'todo.md' },
+//          { title: 'Deno',        source: 'todo.md' },
             { title: 'AWS Lambda',  source: 'todo.md' },
             { title: 'SQL',         source: 'todo.md' },
           ] },
diff --git a/version.d.ts b/version.d.ts
index d3b37b02..93f332a8 100644
--- a/version.d.ts
+++ b/version.d.ts
@@ -1,2 +1,2 @@
-declare const version: string;
-export { version };
+declare const version: string, build_time: number;
+export { version, build_time };