Merge pull request #155 from mermaid-js/dependabot/npm_and_yarn/url-parse-1.5.1

Bump url-parse from 1.4.7 to 1.5.1

.github/dependabot.yml

@@ -0,0 +1,8 @@
+version: 2
+updates:
+  - package-ecosystem: 'npm'
+    directory: '/'
+    target-branch: 'develop'
+    schedule:
+      interval: 'weekly'
+      day: 'friday'

.github/pull_request_template.md

@@ -1,13 +1,17 @@
 ## :bookmark_tabs: Summary
+
 Brief description about the content of your PR:
 
 Resolves #<your issue id here>
 
 ## :straight_ruler: Design Decisions
+
 Describe the way your implementation works or what design decisions you made if applicable:
 
 ### :clipboard: Tasks
+
 Make sure you
-- [ ] :book: have read the [contribution guidelines](https://github.com/mermaid-js/mermaid/blob/develop/CONTRIBUTING.md) 
+
-- [ ] :computer: have added unit/e2e tests (if appropriate) 
+- [ ] :book: have read the [contribution guidelines](https://github.com/mermaid-js/mermaid/blob/develop/CONTRIBUTING.md)
-- [ ] :bookmark: targeted `master` branch 
+- [ ] :computer: have added unit/e2e tests (if appropriate)
+- [ ] :bookmark: targeted `master` branch

.github/workflows/deploy.yml

@@ -0,0 +1,27 @@
+name: Deploy Live Editor
+on:
+  push:
+    branches:
+      - master
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/setup-node@v2
+        with:
+          node-version: '14'
+
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - name: Build & Deploy
+        run: |
+          npm i -g yarn
+          yarn install
+          yarn version --patch --no-git-tag-version
+          yarn release
+          git config user.name github-actions
+          git config user.email github-actions@github.com
+          git add .
+          git commit -m "Release $(yarn version --version)"
+          git push

.github/workflows/stale.yml

@@ -0,0 +1,17 @@
+name: Mark stale issues and pull requests
+
+on:
+  schedule:
+    - cron: '0 0 * * 4'
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/stale@v3
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          exempt-issue-labels: 'retained'
+          exempt-pr-labels: 'retained'
+          stale-issue-message: 'This issue is stale because it has been open 30 days with no activity. Remove stale label or comment or this will be closed in 7 days'
+          stale-pr-message: 'This pr is stale because it has been open 30 days with no activity. Remove stale label or comment or this will be closed in 7 days'

.gitignore

@@ -4,3 +4,4 @@ coverage/
 build/
 yarn-error.log
 .npmrc
+*node_modules*

.husky/.gitignore

@@ -0,0 +1 @@
+_

.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+npm run pre-commit

.prettierignore

@@ -1 +1 @@
-docs
+dist/

.prettierrc

@@ -1,3 +1,5 @@
 {
-    "singleQuote": true
+    "singleQuote": true,
+    "svelteSortOrder": "scripts-styles-markup",
+    "svelteBracketNewLine": false
 }

Dockerfile

@@ -8,7 +8,7 @@
 #                                        docker stop mermaid-live-editor
 
 
-FROM node:13.6.0-alpine as mermaid-live-editor-builder
+FROM node:14.16.0-alpine3.13 as mermaid-live-editor-builder
 COPY --chown=node:node . /home
 WORKDIR /home
 RUN yarn install

README.md

@@ -8,7 +8,6 @@ If you want to speed up the progress for mermaid-live-editor, join the slack cha
 
 Edit, preview and share mermaid charts/diagrams.
 
-
 ## Features
 
 - Edit and preview flowcharts, sequence diagrams, gantt diagrams in real time.
@@ -16,14 +15,15 @@ Edit, preview and share mermaid charts/diagrams.
 - Get a link to a viewer of the diagram so that you can share it with others.
 - Get a link to edit the diagram so that someone else can tweak it and send a new link back
 
-
 ## Live demo
 
 You can try out a live version [here](https://mermaid-js.github.io/mermaid-live-editor/).
 
 ## Setup
 
-This project is set up using [Yarn](https://classic.yarnpkg.com/en/docs/getting-started):
+[Volta](https://volta.sh) is used for managing node and yarn versions.
+
+This project is set up using [Yarn](https://classic.yarnpkg.com/en/docs/getting-started). :
 
 ```
 yarn install
@@ -43,7 +43,6 @@ registry=https://registry.npmjs.com/
 //npm.pkg.github.com/:_authToken="XXXXXXXXX"
 ```
 
-
 ## Development
 
 ```
@@ -53,7 +52,6 @@ open http://localhost:8080
 
 This app is created with Svelte + svelte-spa-router.
 
-
 ## Release
 
 ```

bin/beta-release

@@ -4,11 +4,18 @@
 
 # git clone git@github.com:mermaid-js/docs.git
 # git clone https://github.com/mermaid-js/docs.git
-
+set -e
+rm -rf docs
 yarn release
 pushd .
+if [ ! -d ../docs ]; then
+  echo "Clone https://github.com/mermaid-js/docs to parent folder before continuing." 
+  exit
+fi
+rm -rf ../docs/mermaid-live-editor-beta/* 
 cp -r docs/* ../docs/mermaid-live-editor-beta
 cd ../docs
-git commit * -m "Beta updated with latest changes"
+git add .
+git commit -m "Beta updated with latest changes"
 git push
 popd

docs/1065.1065.js

@@ -0,0 +1,217 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [1065],
+  {
+    71065: (e, n, s) => {
+      'use strict';
+      s.r(n), s.d(n, { conf: () => i, language: () => t });
+      var i = {
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '<', close: '>', notIn: ['string'] },
+          ],
+          surroundingPairs: [
+            { open: '(', close: ')' },
+            { open: '[', close: ']' },
+            { open: '`', close: '`' },
+          ],
+          folding: {
+            markers: {
+              start: new RegExp('^\\s*\x3c!--\\s*#?region\\b.*--\x3e'),
+              end: new RegExp('^\\s*\x3c!--\\s*#?endregion\\b.*--\x3e'),
+            },
+          },
+        },
+        t = {
+          defaultToken: '',
+          tokenPostfix: '.rst',
+          control: /[\\`*_\[\]{}()#+\-\.!]/,
+          escapes: /\\(?:@control)/,
+          empty: [
+            'area',
+            'base',
+            'basefont',
+            'br',
+            'col',
+            'frame',
+            'hr',
+            'img',
+            'input',
+            'isindex',
+            'link',
+            'meta',
+            'param',
+          ],
+          alphanumerics: /[A-Za-z0-9]/,
+          alphanumericsplus: /[A-Za-z0-9-_+:.]/,
+          simpleRefNameWithoutBq: /(?:@alphanumerics@alphanumericsplus*@alphanumerics)+|(?:@alphanumerics+)/,
+          simpleRefName: /(?:`@simpleRefNameWithoutBq`|@simpleRefNameWithoutBq)/,
+          phrase: /@simpleRefName(?:\s@simpleRefName)*/,
+          citationName: /[A-Za-z][A-Za-z0-9-_.]*/,
+          blockLiteralStart: /(?:[!"#$%&'()*+,-./:;<=>?@\[\]^_`{|}~]|[\s])/,
+          precedingChars: /(?:[ -:/'"<([{])/,
+          followingChars: /(?:[ -.,:;!?/'")\]}>]|$)/,
+          punctuation: /(=|-|~|`|#|"|\^|\+|\*|:|\.|'|_|\+)/,
+          tokenizer: {
+            root: [
+              [/^(@punctuation{3,}$){1,1}?/, 'keyword'],
+              [
+                /^\s*([\*\-+‣•]|[a-zA-Z0-9]+\.|\([a-zA-Z0-9]+\)|[a-zA-Z0-9]+\))\s/,
+                'keyword',
+              ],
+              [/([ ]::)\s*$/, 'keyword', '@blankLineOfLiteralBlocks'],
+              [/(::)\s*$/, 'keyword', '@blankLineOfLiteralBlocks'],
+              { include: '@tables' },
+              { include: '@explicitMarkupBlocks' },
+              { include: '@inlineMarkup' },
+            ],
+            explicitMarkupBlocks: [
+              { include: '@citations' },
+              { include: '@footnotes' },
+              [
+                /^(\.\.\s)(@simpleRefName)(::\s)(.*)$/,
+                [{ token: '', next: 'subsequentLines' }, 'keyword', '', ''],
+              ],
+              [
+                /^(\.\.)(\s+)(_)(@simpleRefName)(:)(\s+)(.*)/,
+                [
+                  { token: '', next: 'hyperlinks' },
+                  '',
+                  '',
+                  'string.link',
+                  '',
+                  '',
+                  'string.link',
+                ],
+              ],
+              [
+                /^((?:(?:\.\.)(?:\s+))?)(__)(:)(\s+)(.*)/,
+                [
+                  { token: '', next: 'subsequentLines' },
+                  '',
+                  '',
+                  '',
+                  'string.link',
+                ],
+              ],
+              [/^(__\s+)(.+)/, ['', 'string.link']],
+              [
+                /^(\.\.)( \|)([^| ]+[^|]*[^| ]*)(\| )(@simpleRefName)(:: .*)/,
+                [
+                  { token: '', next: 'subsequentLines' },
+                  '',
+                  'string.link',
+                  '',
+                  'keyword',
+                  '',
+                ],
+                '@rawBlocks',
+              ],
+              [/(\|)([^| ]+[^|]*[^| ]*)(\|_{0,2})/, ['', 'string.link', '']],
+              [
+                /^(\.\.)([ ].*)$/,
+                [{ token: '', next: '@comments' }, 'comment'],
+              ],
+            ],
+            inlineMarkup: [
+              { include: '@citationsReference' },
+              { include: '@footnotesReference' },
+              [/(@simpleRefName)(_{1,2})/, ['string.link', '']],
+              [
+                /(`)([^<`]+\s+)(<)(.*)(>)(`)(_)/,
+                ['', 'string.link', '', 'string.link', '', '', ''],
+              ],
+              [/\*\*([^\\*]|\*(?!\*))+\*\*/, 'strong'],
+              [/\*[^*]+\*/, 'emphasis'],
+              [/(``)((?:[^`]|\`(?!`))+)(``)/, ['', 'keyword', '']],
+              [/(__\s+)(.+)/, ['', 'keyword']],
+              [
+                /(:)((?:@simpleRefNameWithoutBq)?)(:`)([^`]+)(`)/,
+                ['', 'keyword', '', '', ''],
+              ],
+              [
+                /(`)([^`]+)(`:)((?:@simpleRefNameWithoutBq)?)(:)/,
+                ['', '', '', 'keyword', ''],
+              ],
+              [/(`)([^`]+)(`)/, ''],
+              [/(_`)(@phrase)(`)/, ['', 'string.link', '']],
+            ],
+            citations: [
+              [
+                /^(\.\.\s+\[)((?:@citationName))(\]\s+)(.*)/,
+                [
+                  { token: '', next: '@subsequentLines' },
+                  'string.link',
+                  '',
+                  '',
+                ],
+              ],
+            ],
+            citationsReference: [
+              [/(\[)(@citationName)(\]_)/, ['', 'string.link', '']],
+            ],
+            footnotes: [
+              [
+                /^(\.\.\s+\[)((?:[0-9]+))(\]\s+.*)/,
+                [{ token: '', next: '@subsequentLines' }, 'string.link', ''],
+              ],
+              [
+                /^(\.\.\s+\[)((?:#@simpleRefName?))(\]\s+)(.*)/,
+                [
+                  { token: '', next: '@subsequentLines' },
+                  'string.link',
+                  '',
+                  '',
+                ],
+              ],
+              [
+                /^(\.\.\s+\[)((?:\*))(\]\s+)(.*)/,
+                [
+                  { token: '', next: '@subsequentLines' },
+                  'string.link',
+                  '',
+                  '',
+                ],
+              ],
+            ],
+            footnotesReference: [
+              [/(\[)([0-9]+)(\])(_)/, ['', 'string.link', '', '']],
+              [/(\[)(#@simpleRefName?)(\])(_)/, ['', 'string.link', '', '']],
+              [/(\[)(\*)(\])(_)/, ['', 'string.link', '', '']],
+            ],
+            blankLineOfLiteralBlocks: [
+              [/^$/, '', '@subsequentLinesOfLiteralBlocks'],
+              [/^.*$/, '', '@pop'],
+            ],
+            subsequentLinesOfLiteralBlocks: [
+              [/(@blockLiteralStart+)(.*)/, ['keyword', '']],
+              [/^(?!blockLiteralStart)/, '', '@popall'],
+            ],
+            subsequentLines: [
+              [/^[\s]+.*/, ''],
+              [/^(?!\s)/, '', '@pop'],
+            ],
+            hyperlinks: [
+              [/^[\s]+.*/, 'string.link'],
+              [/^(?!\s)/, '', '@pop'],
+            ],
+            comments: [
+              [/^[\s]+.*/, 'comment'],
+              [/^(?!\s)/, '', '@pop'],
+            ],
+            tables: [
+              [/\+-[+-]+/, 'keyword'],
+              [/\+=[+=]+/, 'keyword'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/1134.1134.js

@@ -0,0 +1,391 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [1134, 6717],
+  {
+    41134: (e, t, n) => {
+      'use strict';
+      n.r(t), n.d(t, { conf: () => o, language: () => r });
+      var i = n(96717),
+        o = i.conf,
+        r = {
+          defaultToken: 'invalid',
+          tokenPostfix: '.js',
+          keywords: [
+            'break',
+            'case',
+            'catch',
+            'class',
+            'continue',
+            'const',
+            'constructor',
+            'debugger',
+            'default',
+            'delete',
+            'do',
+            'else',
+            'export',
+            'extends',
+            'false',
+            'finally',
+            'for',
+            'from',
+            'function',
+            'get',
+            'if',
+            'import',
+            'in',
+            'instanceof',
+            'let',
+            'new',
+            'null',
+            'return',
+            'set',
+            'super',
+            'switch',
+            'symbol',
+            'this',
+            'throw',
+            'true',
+            'try',
+            'typeof',
+            'undefined',
+            'var',
+            'void',
+            'while',
+            'with',
+            'yield',
+            'async',
+            'await',
+            'of',
+          ],
+          typeKeywords: [],
+          operators: i.language.operators,
+          symbols: i.language.symbols,
+          escapes: i.language.escapes,
+          digits: i.language.digits,
+          octaldigits: i.language.octaldigits,
+          binarydigits: i.language.binarydigits,
+          hexdigits: i.language.hexdigits,
+          regexpctl: i.language.regexpctl,
+          regexpesc: i.language.regexpesc,
+          tokenizer: i.language.tokenizer,
+        };
+    },
+    96717: (e, t, n) => {
+      'use strict';
+      n.r(t), n.d(t, { conf: () => o, language: () => r });
+      var i = n(89587),
+        o = {
+          wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+          comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          onEnterRules: [
+            {
+              beforeText: /^\s*\/\*\*(?!\/)([^\*]|\*(?!\/))*$/,
+              afterText: /^\s*\*\/$/,
+              action: {
+                indentAction: i.Mj.IndentAction.IndentOutdent,
+                appendText: ' * ',
+              },
+            },
+            {
+              beforeText: /^\s*\/\*\*(?!\/)([^\*]|\*(?!\/))*$/,
+              action: {
+                indentAction: i.Mj.IndentAction.None,
+                appendText: ' * ',
+              },
+            },
+            {
+              beforeText: /^(\t|(\ \ ))*\ \*(\ ([^\*]|\*(?!\/))*)?$/,
+              action: {
+                indentAction: i.Mj.IndentAction.None,
+                appendText: '* ',
+              },
+            },
+            {
+              beforeText: /^(\t|(\ \ ))*\ \*\/\s*$/,
+              action: { indentAction: i.Mj.IndentAction.None, removeText: 1 },
+            },
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"', notIn: ['string'] },
+            { open: "'", close: "'", notIn: ['string', 'comment'] },
+            { open: '`', close: '`', notIn: ['string', 'comment'] },
+            { open: '/**', close: ' */', notIn: ['string'] },
+          ],
+          folding: {
+            markers: {
+              start: new RegExp('^\\s*//\\s*#?region\\b'),
+              end: new RegExp('^\\s*//\\s*#?endregion\\b'),
+            },
+          },
+        },
+        r = {
+          defaultToken: 'invalid',
+          tokenPostfix: '.ts',
+          keywords: [
+            'abstract',
+            'any',
+            'as',
+            'asserts',
+            'bigint',
+            'boolean',
+            'break',
+            'case',
+            'catch',
+            'class',
+            'continue',
+            'const',
+            'constructor',
+            'debugger',
+            'declare',
+            'default',
+            'delete',
+            'do',
+            'else',
+            'enum',
+            'export',
+            'extends',
+            'false',
+            'finally',
+            'for',
+            'from',
+            'function',
+            'get',
+            'if',
+            'implements',
+            'import',
+            'in',
+            'infer',
+            'instanceof',
+            'interface',
+            'is',
+            'keyof',
+            'let',
+            'module',
+            'namespace',
+            'never',
+            'new',
+            'null',
+            'number',
+            'object',
+            'package',
+            'private',
+            'protected',
+            'public',
+            'readonly',
+            'require',
+            'global',
+            'return',
+            'set',
+            'static',
+            'string',
+            'super',
+            'switch',
+            'symbol',
+            'this',
+            'throw',
+            'true',
+            'try',
+            'type',
+            'typeof',
+            'undefined',
+            'unique',
+            'unknown',
+            'var',
+            'void',
+            'while',
+            'with',
+            'yield',
+            'async',
+            'await',
+            'of',
+          ],
+          operators: [
+            '<=',
+            '>=',
+            '==',
+            '!=',
+            '===',
+            '!==',
+            '=>',
+            '+',
+            '-',
+            '**',
+            '*',
+            '/',
+            '%',
+            '++',
+            '--',
+            '<<',
+            '</',
+            '>>',
+            '>>>',
+            '&',
+            '|',
+            '^',
+            '!',
+            '~',
+            '&&',
+            '||',
+            '??',
+            '?',
+            ':',
+            '=',
+            '+=',
+            '-=',
+            '*=',
+            '**=',
+            '/=',
+            '%=',
+            '<<=',
+            '>>=',
+            '>>>=',
+            '&=',
+            '|=',
+            '^=',
+            '@',
+          ],
+          symbols: /[=><!~?:&|+\-*\/\^%]+/,
+          escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+          digits: /\d+(_+\d+)*/,
+          octaldigits: /[0-7]+(_+[0-7]+)*/,
+          binarydigits: /[0-1]+(_+[0-1]+)*/,
+          hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+          regexpctl: /[(){}\[\]\$\^|\-*+?\.]/,
+          regexpesc: /\\(?:[bBdDfnrstvwWn0\\\/]|@regexpctl|c[A-Z]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4})/,
+          tokenizer: {
+            root: [[/[{}]/, 'delimiter.bracket'], { include: 'common' }],
+            common: [
+              [
+                /[a-z_$][\w$]*/,
+                { cases: { '@keywords': 'keyword', '@default': 'identifier' } },
+              ],
+              [/[A-Z][\w\$]*/, 'type.identifier'],
+              { include: '@whitespace' },
+              [
+                /\/(?=([^\\\/]|\\.)+\/([gimsuy]*)(\s*)(\.|;|,|\)|\]|\}|$))/,
+                { token: 'regexp', bracket: '@open', next: '@regexp' },
+              ],
+              [/[()\[\]]/, '@brackets'],
+              [/[<>](?!@symbols)/, '@brackets'],
+              [/!(?=([^=]|$))/, 'delimiter'],
+              [
+                /@symbols/,
+                { cases: { '@operators': 'delimiter', '@default': '' } },
+              ],
+              [/(@digits)[eE]([\-+]?(@digits))?/, 'number.float'],
+              [/(@digits)\.(@digits)([eE][\-+]?(@digits))?/, 'number.float'],
+              [/0[xX](@hexdigits)n?/, 'number.hex'],
+              [/0[oO]?(@octaldigits)n?/, 'number.octal'],
+              [/0[bB](@binarydigits)n?/, 'number.binary'],
+              [/(@digits)n?/, 'number'],
+              [/[;,.]/, 'delimiter'],
+              [/"([^"\\]|\\.)*$/, 'string.invalid'],
+              [/'([^'\\]|\\.)*$/, 'string.invalid'],
+              [/"/, 'string', '@string_double'],
+              [/'/, 'string', '@string_single'],
+              [/`/, 'string', '@string_backtick'],
+            ],
+            whitespace: [
+              [/[ \t\r\n]+/, ''],
+              [/\/\*\*(?!\/)/, 'comment.doc', '@jsdoc'],
+              [/\/\*/, 'comment', '@comment'],
+              [/\/\/.*$/, 'comment'],
+            ],
+            comment: [
+              [/[^\/*]+/, 'comment'],
+              [/\*\//, 'comment', '@pop'],
+              [/[\/*]/, 'comment'],
+            ],
+            jsdoc: [
+              [/[^\/*]+/, 'comment.doc'],
+              [/\*\//, 'comment.doc', '@pop'],
+              [/[\/*]/, 'comment.doc'],
+            ],
+            regexp: [
+              [
+                /(\{)(\d+(?:,\d*)?)(\})/,
+                [
+                  'regexp.escape.control',
+                  'regexp.escape.control',
+                  'regexp.escape.control',
+                ],
+              ],
+              [
+                /(\[)(\^?)(?=(?:[^\]\\\/]|\\.)+)/,
+                [
+                  'regexp.escape.control',
+                  { token: 'regexp.escape.control', next: '@regexrange' },
+                ],
+              ],
+              [
+                /(\()(\?:|\?=|\?!)/,
+                ['regexp.escape.control', 'regexp.escape.control'],
+              ],
+              [/[()]/, 'regexp.escape.control'],
+              [/@regexpctl/, 'regexp.escape.control'],
+              [/[^\\\/]/, 'regexp'],
+              [/@regexpesc/, 'regexp.escape'],
+              [/\\\./, 'regexp.invalid'],
+              [
+                /(\/)([gimsuy]*)/,
+                [
+                  { token: 'regexp', bracket: '@close', next: '@pop' },
+                  'keyword.other',
+                ],
+              ],
+            ],
+            regexrange: [
+              [/-/, 'regexp.escape.control'],
+              [/\^/, 'regexp.invalid'],
+              [/@regexpesc/, 'regexp.escape'],
+              [/[^\]]/, 'regexp'],
+              [
+                /\]/,
+                {
+                  token: 'regexp.escape.control',
+                  next: '@pop',
+                  bracket: '@close',
+                },
+              ],
+            ],
+            string_double: [
+              [/[^\\"]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/"/, 'string', '@pop'],
+            ],
+            string_single: [
+              [/[^\\']+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/'/, 'string', '@pop'],
+            ],
+            string_backtick: [
+              [
+                /\$\{/,
+                { token: 'delimiter.bracket', next: '@bracketCounting' },
+              ],
+              [/[^\\`$]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/`/, 'string', '@pop'],
+            ],
+            bracketCounting: [
+              [/\{/, 'delimiter.bracket', '@bracketCounting'],
+              [/\}/, 'delimiter.bracket', '@pop'],
+              { include: 'common' },
+            ],
+          },
+        };
+    },
+  },
+]);

docs/1147.1147.js

@@ -0,0 +1,229 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [1147],
+  {
+    21147: (e, r, t) => {
+      'use strict';
+      t.r(r), t.d(r, { conf: () => n, language: () => s });
+      var n = {
+          wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#%\^\&\*\(\)\=\$\-\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+          comments: { blockComment: ['###', '###'], lineComment: '#' },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          folding: {
+            markers: {
+              start: new RegExp('^\\s*#region\\b'),
+              end: new RegExp('^\\s*#endregion\\b'),
+            },
+          },
+        },
+        s = {
+          defaultToken: '',
+          ignoreCase: !0,
+          tokenPostfix: '.coffee',
+          brackets: [
+            { open: '{', close: '}', token: 'delimiter.curly' },
+            { open: '[', close: ']', token: 'delimiter.square' },
+            { open: '(', close: ')', token: 'delimiter.parenthesis' },
+          ],
+          regEx: /\/(?!\/\/)(?:[^\/\\]|\\.)*\/[igm]*/,
+          keywords: [
+            'and',
+            'or',
+            'is',
+            'isnt',
+            'not',
+            'on',
+            'yes',
+            '@',
+            'no',
+            'off',
+            'true',
+            'false',
+            'null',
+            'this',
+            'new',
+            'delete',
+            'typeof',
+            'in',
+            'instanceof',
+            'return',
+            'throw',
+            'break',
+            'continue',
+            'debugger',
+            'if',
+            'else',
+            'switch',
+            'for',
+            'while',
+            'do',
+            'try',
+            'catch',
+            'finally',
+            'class',
+            'extends',
+            'super',
+            'undefined',
+            'then',
+            'unless',
+            'until',
+            'loop',
+            'of',
+            'by',
+            'when',
+          ],
+          symbols: /[=><!~?&%|+\-*\/\^\.,\:]+/,
+          escapes: /\\(?:[abfnrtv\\"'$]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+          tokenizer: {
+            root: [
+              [/\@[a-zA-Z_]\w*/, 'variable.predefined'],
+              [
+                /[a-zA-Z_]\w*/,
+                {
+                  cases: {
+                    this: 'variable.predefined',
+                    '@keywords': { token: 'keyword.$0' },
+                    '@default': '',
+                  },
+                },
+              ],
+              [/[ \t\r\n]+/, ''],
+              [/###/, 'comment', '@comment'],
+              [/#.*$/, 'comment'],
+              ['///', { token: 'regexp', next: '@hereregexp' }],
+              [/^(\s*)(@regEx)/, ['', 'regexp']],
+              [/(\()(\s*)(@regEx)/, ['@brackets', '', 'regexp']],
+              [/(\,)(\s*)(@regEx)/, ['delimiter', '', 'regexp']],
+              [/(\=)(\s*)(@regEx)/, ['delimiter', '', 'regexp']],
+              [/(\:)(\s*)(@regEx)/, ['delimiter', '', 'regexp']],
+              [/(\[)(\s*)(@regEx)/, ['@brackets', '', 'regexp']],
+              [/(\!)(\s*)(@regEx)/, ['delimiter', '', 'regexp']],
+              [/(\&)(\s*)(@regEx)/, ['delimiter', '', 'regexp']],
+              [/(\|)(\s*)(@regEx)/, ['delimiter', '', 'regexp']],
+              [/(\?)(\s*)(@regEx)/, ['delimiter', '', 'regexp']],
+              [/(\{)(\s*)(@regEx)/, ['@brackets', '', 'regexp']],
+              [/(\;)(\s*)(@regEx)/, ['', '', 'regexp']],
+              [
+                /}/,
+                {
+                  cases: {
+                    '$S2==interpolatedstring': {
+                      token: 'string',
+                      next: '@pop',
+                    },
+                    '@default': '@brackets',
+                  },
+                },
+              ],
+              [/[{}()\[\]]/, '@brackets'],
+              [/@symbols/, 'delimiter'],
+              [/\d+[eE]([\-+]?\d+)?/, 'number.float'],
+              [/\d+\.\d+([eE][\-+]?\d+)?/, 'number.float'],
+              [/0[xX][0-9a-fA-F]+/, 'number.hex'],
+              [/0[0-7]+(?!\d)/, 'number.octal'],
+              [/\d+/, 'number'],
+              [/[,.]/, 'delimiter'],
+              [/"""/, 'string', '@herestring."""'],
+              [/'''/, 'string', "@herestring.'''"],
+              [
+                /"/,
+                {
+                  cases: {
+                    '@eos': 'string',
+                    '@default': { token: 'string', next: '@string."' },
+                  },
+                },
+              ],
+              [
+                /'/,
+                {
+                  cases: {
+                    '@eos': 'string',
+                    '@default': { token: 'string', next: "@string.'" },
+                  },
+                },
+              ],
+            ],
+            string: [
+              [/[^"'\#\\]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\./, 'string.escape.invalid'],
+              [/\./, 'string.escape.invalid'],
+              [
+                /#{/,
+                {
+                  cases: {
+                    '$S2=="': {
+                      token: 'string',
+                      next: 'root.interpolatedstring',
+                    },
+                    '@default': 'string',
+                  },
+                },
+              ],
+              [
+                /["']/,
+                {
+                  cases: {
+                    '$#==$S2': { token: 'string', next: '@pop' },
+                    '@default': 'string',
+                  },
+                },
+              ],
+              [/#/, 'string'],
+            ],
+            herestring: [
+              [
+                /("""|''')/,
+                {
+                  cases: {
+                    '$1==$S2': { token: 'string', next: '@pop' },
+                    '@default': 'string',
+                  },
+                },
+              ],
+              [/[^#\\'"]+/, 'string'],
+              [/['"]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\./, 'string.escape.invalid'],
+              [
+                /#{/,
+                { token: 'string.quote', next: 'root.interpolatedstring' },
+              ],
+              [/#/, 'string'],
+            ],
+            comment: [
+              [/[^#]+/, 'comment'],
+              [/###/, 'comment', '@pop'],
+              [/#/, 'comment'],
+            ],
+            hereregexp: [
+              [/[^\\\/#]+/, 'regexp'],
+              [/\\./, 'regexp'],
+              [/#.*$/, 'comment'],
+              ['///[igm]*', { token: 'regexp', next: '@pop' }],
+              [/\//, 'regexp'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/1259.1259.js

@@ -0,0 +1,299 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [1259],
+  {
+    91259: (E, S, e) => {
+      'use strict';
+      e.r(S), e.d(S, { conf: () => T, language: () => R });
+      var T = {
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+        },
+        R = {
+          defaultToken: '',
+          tokenPostfix: '.redis',
+          ignoreCase: !0,
+          brackets: [
+            { open: '[', close: ']', token: 'delimiter.square' },
+            { open: '(', close: ')', token: 'delimiter.parenthesis' },
+          ],
+          keywords: [
+            'APPEND',
+            'AUTH',
+            'BGREWRITEAOF',
+            'BGSAVE',
+            'BITCOUNT',
+            'BITFIELD',
+            'BITOP',
+            'BITPOS',
+            'BLPOP',
+            'BRPOP',
+            'BRPOPLPUSH',
+            'CLIENT',
+            'KILL',
+            'LIST',
+            'GETNAME',
+            'PAUSE',
+            'REPLY',
+            'SETNAME',
+            'CLUSTER',
+            'ADDSLOTS',
+            'COUNT-FAILURE-REPORTS',
+            'COUNTKEYSINSLOT',
+            'DELSLOTS',
+            'FAILOVER',
+            'FORGET',
+            'GETKEYSINSLOT',
+            'INFO',
+            'KEYSLOT',
+            'MEET',
+            'NODES',
+            'REPLICATE',
+            'RESET',
+            'SAVECONFIG',
+            'SET-CONFIG-EPOCH',
+            'SETSLOT',
+            'SLAVES',
+            'SLOTS',
+            'COMMAND',
+            'COUNT',
+            'GETKEYS',
+            'CONFIG',
+            'GET',
+            'REWRITE',
+            'SET',
+            'RESETSTAT',
+            'DBSIZE',
+            'DEBUG',
+            'OBJECT',
+            'SEGFAULT',
+            'DECR',
+            'DECRBY',
+            'DEL',
+            'DISCARD',
+            'DUMP',
+            'ECHO',
+            'EVAL',
+            'EVALSHA',
+            'EXEC',
+            'EXISTS',
+            'EXPIRE',
+            'EXPIREAT',
+            'FLUSHALL',
+            'FLUSHDB',
+            'GEOADD',
+            'GEOHASH',
+            'GEOPOS',
+            'GEODIST',
+            'GEORADIUS',
+            'GEORADIUSBYMEMBER',
+            'GETBIT',
+            'GETRANGE',
+            'GETSET',
+            'HDEL',
+            'HEXISTS',
+            'HGET',
+            'HGETALL',
+            'HINCRBY',
+            'HINCRBYFLOAT',
+            'HKEYS',
+            'HLEN',
+            'HMGET',
+            'HMSET',
+            'HSET',
+            'HSETNX',
+            'HSTRLEN',
+            'HVALS',
+            'INCR',
+            'INCRBY',
+            'INCRBYFLOAT',
+            'KEYS',
+            'LASTSAVE',
+            'LINDEX',
+            'LINSERT',
+            'LLEN',
+            'LPOP',
+            'LPUSH',
+            'LPUSHX',
+            'LRANGE',
+            'LREM',
+            'LSET',
+            'LTRIM',
+            'MGET',
+            'MIGRATE',
+            'MONITOR',
+            'MOVE',
+            'MSET',
+            'MSETNX',
+            'MULTI',
+            'PERSIST',
+            'PEXPIRE',
+            'PEXPIREAT',
+            'PFADD',
+            'PFCOUNT',
+            'PFMERGE',
+            'PING',
+            'PSETEX',
+            'PSUBSCRIBE',
+            'PUBSUB',
+            'PTTL',
+            'PUBLISH',
+            'PUNSUBSCRIBE',
+            'QUIT',
+            'RANDOMKEY',
+            'READONLY',
+            'READWRITE',
+            'RENAME',
+            'RENAMENX',
+            'RESTORE',
+            'ROLE',
+            'RPOP',
+            'RPOPLPUSH',
+            'RPUSH',
+            'RPUSHX',
+            'SADD',
+            'SAVE',
+            'SCARD',
+            'SCRIPT',
+            'FLUSH',
+            'LOAD',
+            'SDIFF',
+            'SDIFFSTORE',
+            'SELECT',
+            'SETBIT',
+            'SETEX',
+            'SETNX',
+            'SETRANGE',
+            'SHUTDOWN',
+            'SINTER',
+            'SINTERSTORE',
+            'SISMEMBER',
+            'SLAVEOF',
+            'SLOWLOG',
+            'SMEMBERS',
+            'SMOVE',
+            'SORT',
+            'SPOP',
+            'SRANDMEMBER',
+            'SREM',
+            'STRLEN',
+            'SUBSCRIBE',
+            'SUNION',
+            'SUNIONSTORE',
+            'SWAPDB',
+            'SYNC',
+            'TIME',
+            'TOUCH',
+            'TTL',
+            'TYPE',
+            'UNSUBSCRIBE',
+            'UNLINK',
+            'UNWATCH',
+            'WAIT',
+            'WATCH',
+            'ZADD',
+            'ZCARD',
+            'ZCOUNT',
+            'ZINCRBY',
+            'ZINTERSTORE',
+            'ZLEXCOUNT',
+            'ZRANGE',
+            'ZRANGEBYLEX',
+            'ZREVRANGEBYLEX',
+            'ZRANGEBYSCORE',
+            'ZRANK',
+            'ZREM',
+            'ZREMRANGEBYLEX',
+            'ZREMRANGEBYRANK',
+            'ZREMRANGEBYSCORE',
+            'ZREVRANGE',
+            'ZREVRANGEBYSCORE',
+            'ZREVRANK',
+            'ZSCORE',
+            'ZUNIONSTORE',
+            'SCAN',
+            'SSCAN',
+            'HSCAN',
+            'ZSCAN',
+          ],
+          operators: [],
+          builtinFunctions: [],
+          builtinVariables: [],
+          pseudoColumns: [],
+          tokenizer: {
+            root: [
+              { include: '@whitespace' },
+              { include: '@pseudoColumns' },
+              { include: '@numbers' },
+              { include: '@strings' },
+              { include: '@scopes' },
+              [/[;,.]/, 'delimiter'],
+              [/[()]/, '@brackets'],
+              [
+                /[\w@#$]+/,
+                {
+                  cases: {
+                    '@keywords': 'keyword',
+                    '@operators': 'operator',
+                    '@builtinVariables': 'predefined',
+                    '@builtinFunctions': 'predefined',
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+              [/[<>=!%&+\-*/|~^]/, 'operator'],
+            ],
+            whitespace: [[/\s+/, 'white']],
+            pseudoColumns: [
+              [
+                /[$][A-Za-z_][\w@#$]*/,
+                {
+                  cases: {
+                    '@pseudoColumns': 'predefined',
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+            ],
+            numbers: [
+              [/0[xX][0-9a-fA-F]*/, 'number'],
+              [/[$][+-]*\d*(\.\d*)?/, 'number'],
+              [/((\d+(\.\d*)?)|(\.\d+))([eE][\-+]?\d+)?/, 'number'],
+            ],
+            strings: [
+              [/'/, { token: 'string', next: '@string' }],
+              [/"/, { token: 'string.double', next: '@stringDouble' }],
+            ],
+            string: [
+              [/[^']+/, 'string'],
+              [/''/, 'string'],
+              [/'/, { token: 'string', next: '@pop' }],
+            ],
+            stringDouble: [
+              [/[^"]+/, 'string.double'],
+              [/""/, 'string.double'],
+              [/"/, { token: 'string.double', next: '@pop' }],
+            ],
+            scopes: [],
+          },
+        };
+    },
+  },
+]);

docs/1448.1448.js

@@ -0,0 +1,150 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [1448],
+  {
+    11448: (e, t, o) => {
+      'use strict';
+      o.r(t), o.d(t, { conf: () => n, language: () => s });
+      var n = {
+          comments: { lineComment: '//', blockComment: ['(*', '*)'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+            ['<', '>'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '<', close: '>' },
+            { open: "'", close: "'" },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '<', close: '>' },
+            { open: "'", close: "'" },
+          ],
+        },
+        s = {
+          defaultToken: '',
+          tokenPostfix: '.cameligo',
+          ignoreCase: !0,
+          brackets: [
+            { open: '{', close: '}', token: 'delimiter.curly' },
+            { open: '[', close: ']', token: 'delimiter.square' },
+            { open: '(', close: ')', token: 'delimiter.parenthesis' },
+            { open: '<', close: '>', token: 'delimiter.angle' },
+          ],
+          keywords: [
+            'abs',
+            'begin',
+            'Bytes',
+            'Crypto',
+            'Current',
+            'else',
+            'end',
+            'failwith',
+            'false',
+            'fun',
+            'if',
+            'in',
+            'let',
+            'let%entry',
+            'let%init',
+            'List',
+            'list',
+            'Map',
+            'map',
+            'match',
+            'match%nat',
+            'mod',
+            'not',
+            'operation',
+            'Operation',
+            'of',
+            'Set',
+            'set',
+            'sender',
+            'source',
+            'String',
+            'then',
+            'true',
+            'type',
+            'with',
+          ],
+          typeKeywords: ['int', 'unit', 'string', 'tz'],
+          operators: [
+            '=',
+            '>',
+            '<',
+            '<=',
+            '>=',
+            '<>',
+            ':',
+            ':=',
+            'and',
+            'mod',
+            'or',
+            '+',
+            '-',
+            '*',
+            '/',
+            '@',
+            '&',
+            '^',
+            '%',
+            '->',
+            '<-',
+          ],
+          symbols: /[=><:@\^&|+\-*\/\^%]+/,
+          tokenizer: {
+            root: [
+              [
+                /[a-zA-Z_][\w]*/,
+                {
+                  cases: {
+                    '@keywords': { token: 'keyword.$0' },
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+              { include: '@whitespace' },
+              [/[{}()\[\]]/, '@brackets'],
+              [/[<>](?!@symbols)/, '@brackets'],
+              [
+                /@symbols/,
+                { cases: { '@operators': 'delimiter', '@default': '' } },
+              ],
+              [/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
+              [/\$[0-9a-fA-F]{1,16}/, 'number.hex'],
+              [/\d+/, 'number'],
+              [/[;,.]/, 'delimiter'],
+              [/'([^'\\]|\\.)*$/, 'string.invalid'],
+              [/'/, 'string', '@string'],
+              [/'[^\\']'/, 'string'],
+              [/'/, 'string.invalid'],
+              [/\#\d+/, 'string'],
+            ],
+            comment: [
+              [/[^\(\*]+/, 'comment'],
+              [/\*\)/, 'comment', '@pop'],
+              [/\(\*/, 'comment'],
+            ],
+            string: [
+              [/[^\\']+/, 'string'],
+              [/\\./, 'string.escape.invalid'],
+              [/'/, { token: 'string.quote', bracket: '@close', next: '@pop' }],
+            ],
+            whitespace: [
+              [/[ \t\r\n]+/, 'white'],
+              [/\(\*/, 'comment', '@comment'],
+              [/\/\/.*$/, 'comment'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/1471.1471.js

@@ -0,0 +1,67 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [1471],
+  {
+    31471: (e, t, n) => {
+      'use strict';
+      n.r(t), n.d(t, { conf: () => s, language: () => i });
+      var s = { comments: { lineComment: '#' } },
+        i = {
+          defaultToken: 'keyword',
+          ignoreCase: !0,
+          tokenPostfix: '.azcli',
+          str: /[^#\s]/,
+          tokenizer: {
+            root: [
+              { include: '@comment' },
+              [
+                /\s-+@str*\s*/,
+                {
+                  cases: {
+                    '@eos': { token: 'key.identifier', next: '@popall' },
+                    '@default': { token: 'key.identifier', next: '@type' },
+                  },
+                },
+              ],
+              [
+                /^-+@str*\s*/,
+                {
+                  cases: {
+                    '@eos': { token: 'key.identifier', next: '@popall' },
+                    '@default': { token: 'key.identifier', next: '@type' },
+                  },
+                },
+              ],
+            ],
+            type: [
+              { include: '@comment' },
+              [
+                /-+@str*\s*/,
+                {
+                  cases: {
+                    '@eos': { token: 'key.identifier', next: '@popall' },
+                    '@default': 'key.identifier',
+                  },
+                },
+              ],
+              [
+                /@str+\s*/,
+                {
+                  cases: {
+                    '@eos': { token: 'string', next: '@popall' },
+                    '@default': 'string',
+                  },
+                },
+              ],
+            ],
+            comment: [
+              [
+                /#.*$/,
+                { cases: { '@eos': { token: 'comment', next: '@popall' } } },
+              ],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/180.180.js

@@ -0,0 +1,421 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [180],
+  {
+    90180: (e, t, o) => {
+      'use strict';
+      o.r(t), o.d(t, { conf: () => r, language: () => n });
+      var r = {
+          wordPattern: /(unary_[@~!#%^&*()\-=+\\|:<>\/?]+)|([a-zA-Z_$][\w$]*?_=)|(`[^`]+`)|([a-zA-Z_$][\w$]*)/g,
+          comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          folding: {
+            markers: {
+              start: new RegExp(
+                '^\\s*//\\s*(?:(?:#?region\\b)|(?:<editor-fold\\b))'
+              ),
+              end: new RegExp(
+                '^\\s*//\\s*(?:(?:#?endregion\\b)|(?:</editor-fold>))'
+              ),
+            },
+          },
+        },
+        n = {
+          tokenPostfix: '.scala',
+          keywords: [
+            'asInstanceOf',
+            'catch',
+            'class',
+            'classOf',
+            'def',
+            'do',
+            'else',
+            'extends',
+            'finally',
+            'for',
+            'foreach',
+            'forSome',
+            'if',
+            'import',
+            'isInstanceOf',
+            'macro',
+            'match',
+            'new',
+            'object',
+            'package',
+            'return',
+            'throw',
+            'trait',
+            'try',
+            'type',
+            'until',
+            'val',
+            'var',
+            'while',
+            'with',
+            'yield',
+            'given',
+            'enum',
+            'then',
+          ],
+          softKeywords: ['as', 'export', 'extension', 'end', 'derives', 'on'],
+          constants: ['true', 'false', 'null', 'this', 'super'],
+          modifiers: [
+            'abstract',
+            'final',
+            'implicit',
+            'lazy',
+            'override',
+            'private',
+            'protected',
+            'sealed',
+          ],
+          softModifiers: ['inline', 'opaque', 'open', 'transparent', 'using'],
+          name: /(?:[a-z_$][\w$]*|`[^`]+`)/,
+          type: /(?:[A-Z][\w$]*)/,
+          symbols: /[=><!~?:&|+\-*\/^\\%@#]+/,
+          digits: /\d+(_+\d+)*/,
+          hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+          escapes: /\\(?:[btnfr\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+          fstring_conv: /[bBhHsScCdoxXeEfgGaAt]|[Tn](?:[HIklMSLNpzZsQ]|[BbhAaCYyjmde]|[RTrDFC])/,
+          tokenizer: {
+            root: [
+              [
+                /\braw"""/,
+                {
+                  token: 'string.quote',
+                  bracket: '@open',
+                  next: '@rawstringt',
+                },
+              ],
+              [
+                /\braw"/,
+                { token: 'string.quote', bracket: '@open', next: '@rawstring' },
+              ],
+              [
+                /\bs"""/,
+                { token: 'string.quote', bracket: '@open', next: '@sstringt' },
+              ],
+              [
+                /\bs"/,
+                { token: 'string.quote', bracket: '@open', next: '@sstring' },
+              ],
+              [
+                /\bf""""/,
+                { token: 'string.quote', bracket: '@open', next: '@fstringt' },
+              ],
+              [
+                /\bf"/,
+                { token: 'string.quote', bracket: '@open', next: '@fstring' },
+              ],
+              [
+                /"""/,
+                { token: 'string.quote', bracket: '@open', next: '@stringt' },
+              ],
+              [
+                /"/,
+                { token: 'string.quote', bracket: '@open', next: '@string' },
+              ],
+              [
+                /(@digits)[eE]([\-+]?(@digits))?[fFdD]?/,
+                'number.float',
+                '@allowMethod',
+              ],
+              [
+                /(@digits)\.(@digits)([eE][\-+]?(@digits))?[fFdD]?/,
+                'number.float',
+                '@allowMethod',
+              ],
+              [/0[xX](@hexdigits)[Ll]?/, 'number.hex', '@allowMethod'],
+              [/(@digits)[fFdD]/, 'number.float', '@allowMethod'],
+              [/(@digits)[lL]?/, 'number', '@allowMethod'],
+              [/\b_\*/, 'key'],
+              [/\b(_)\b/, 'keyword', '@allowMethod'],
+              [/\bimport\b/, 'keyword', '@import'],
+              [
+                /\b(case)([ \t]+)(class)\b/,
+                ['keyword.modifier', 'white', 'keyword'],
+              ],
+              [/\bcase\b/, 'keyword', '@case'],
+              [/\bva[lr]\b/, 'keyword', '@vardef'],
+              [
+                /\b(def)([ \t]+)((?:unary_)?@symbols|@name(?:_=)|@name)/,
+                ['keyword', 'white', 'identifier'],
+              ],
+              [/@name(?=[ \t]*:(?!:))/, 'variable'],
+              [
+                /(\.)(@name|@symbols)/,
+                ['operator', { token: '@rematch', next: '@allowMethod' }],
+              ],
+              [
+                /([{(])(\s*)(@name(?=\s*=>))/,
+                ['@brackets', 'white', 'variable'],
+              ],
+              [
+                /@name/,
+                {
+                  cases: {
+                    '@keywords': 'keyword',
+                    '@softKeywords': 'keyword',
+                    '@modifiers': 'keyword.modifier',
+                    '@softModifiers': 'keyword.modifier',
+                    '@constants': { token: 'constant', next: '@allowMethod' },
+                    '@default': { token: 'identifier', next: '@allowMethod' },
+                  },
+                },
+              ],
+              [/@type/, 'type', '@allowMethod'],
+              { include: '@whitespace' },
+              [/@[a-zA-Z_$][\w$]*(?:\.[a-zA-Z_$][\w$]*)*/, 'annotation'],
+              [/[{(]/, '@brackets'],
+              [/[})]/, '@brackets', '@allowMethod'],
+              [/\[/, 'operator.square'],
+              [
+                /](?!\s*(?:va[rl]|def|type)\b)/,
+                'operator.square',
+                '@allowMethod',
+              ],
+              [/]/, 'operator.square'],
+              [/([=-]>|<-|>:|<:|:>|<%)(?=[\s\w()[\]{},\."'`])/, 'keyword'],
+              [/@symbols/, 'operator'],
+              [/[;,\.]/, 'delimiter'],
+              [/'[a-zA-Z$][\w$]*(?!')/, 'attribute.name'],
+              [/'[^\\']'/, 'string', '@allowMethod'],
+              [
+                /(')(@escapes)(')/,
+                [
+                  'string',
+                  'string.escape',
+                  { token: 'string', next: '@allowMethod' },
+                ],
+              ],
+              [/'/, 'string.invalid'],
+            ],
+            import: [
+              [/;/, 'delimiter', '@pop'],
+              [/^|$/, '', '@pop'],
+              [/[ \t]+/, 'white'],
+              [/[\n\r]+/, 'white', '@pop'],
+              [/\/\*/, 'comment', '@comment'],
+              [/@name|@type/, 'type'],
+              [/[(){}]/, '@brackets'],
+              [/[[\]]/, 'operator.square'],
+              [/[\.,]/, 'delimiter'],
+            ],
+            allowMethod: [
+              [/^|$/, '', '@pop'],
+              [/[ \t]+/, 'white'],
+              [/[\n\r]+/, 'white', '@pop'],
+              [/\/\*/, 'comment', '@comment'],
+              [/(?==>[\s\w([{])/, 'keyword', '@pop'],
+              [
+                /(@name|@symbols)(?=[ \t]*[[({"'`]|[ \t]+(?:[+-]?\.?\d|\w))/,
+                {
+                  cases: {
+                    '@keywords': { token: 'keyword', next: '@pop' },
+                    '->|<-|>:|<:|<%': { token: 'keyword', next: '@pop' },
+                    '@default': { token: '@rematch', next: '@pop' },
+                  },
+                },
+              ],
+              ['', '', '@pop'],
+            ],
+            comment: [
+              [/[^\/*]+/, 'comment'],
+              [/\/\*/, 'comment', '@push'],
+              [/\*\//, 'comment', '@pop'],
+              [/[\/*]/, 'comment'],
+            ],
+            case: [
+              [/\b_\*/, 'key'],
+              [/\b(_|true|false|null|this|super)\b/, 'keyword', '@allowMethod'],
+              [/\bif\b|=>/, 'keyword', '@pop'],
+              [/`[^`]+`/, 'identifier', '@allowMethod'],
+              [/@name/, 'variable', '@allowMethod'],
+              [/:::?|\||@(?![a-z_$])/, 'keyword'],
+              { include: '@root' },
+            ],
+            vardef: [
+              [/\b_\*/, 'key'],
+              [/\b(_|true|false|null|this|super)\b/, 'keyword'],
+              [/@name/, 'variable'],
+              [/:::?|\||@(?![a-z_$])/, 'keyword'],
+              [/=|:(?!:)/, 'operator', '@pop'],
+              [/$/, 'white', '@pop'],
+              { include: '@root' },
+            ],
+            string: [
+              [/[^\\"\n\r]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [
+                /"/,
+                {
+                  token: 'string.quote',
+                  bracket: '@close',
+                  switchTo: '@allowMethod',
+                },
+              ],
+            ],
+            stringt: [
+              [/[^\\"\n\r]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/"(?=""")/, 'string'],
+              [
+                /"""/,
+                {
+                  token: 'string.quote',
+                  bracket: '@close',
+                  switchTo: '@allowMethod',
+                },
+              ],
+              [/"/, 'string'],
+            ],
+            fstring: [
+              [/@escapes/, 'string.escape'],
+              [
+                /"/,
+                {
+                  token: 'string.quote',
+                  bracket: '@close',
+                  switchTo: '@allowMethod',
+                },
+              ],
+              [/\$\$/, 'string'],
+              [/(\$)([a-z_]\w*)/, ['operator', 'identifier']],
+              [/\$\{/, 'operator', '@interp'],
+              [/%%/, 'string'],
+              [
+                /(%)([\-#+ 0,(])(\d+|\.\d+|\d+\.\d+)(@fstring_conv)/,
+                ['metatag', 'keyword.modifier', 'number', 'metatag'],
+              ],
+              [
+                /(%)(\d+|\.\d+|\d+\.\d+)(@fstring_conv)/,
+                ['metatag', 'number', 'metatag'],
+              ],
+              [
+                /(%)([\-#+ 0,(])(@fstring_conv)/,
+                ['metatag', 'keyword.modifier', 'metatag'],
+              ],
+              [/(%)(@fstring_conv)/, ['metatag', 'metatag']],
+              [/./, 'string'],
+            ],
+            fstringt: [
+              [/@escapes/, 'string.escape'],
+              [/"(?=""")/, 'string'],
+              [
+                /"""/,
+                {
+                  token: 'string.quote',
+                  bracket: '@close',
+                  switchTo: '@allowMethod',
+                },
+              ],
+              [/\$\$/, 'string'],
+              [/(\$)([a-z_]\w*)/, ['operator', 'identifier']],
+              [/\$\{/, 'operator', '@interp'],
+              [/%%/, 'string'],
+              [
+                /(%)([\-#+ 0,(])(\d+|\.\d+|\d+\.\d+)(@fstring_conv)/,
+                ['metatag', 'keyword.modifier', 'number', 'metatag'],
+              ],
+              [
+                /(%)(\d+|\.\d+|\d+\.\d+)(@fstring_conv)/,
+                ['metatag', 'number', 'metatag'],
+              ],
+              [
+                /(%)([\-#+ 0,(])(@fstring_conv)/,
+                ['metatag', 'keyword.modifier', 'metatag'],
+              ],
+              [/(%)(@fstring_conv)/, ['metatag', 'metatag']],
+              [/./, 'string'],
+            ],
+            sstring: [
+              [/@escapes/, 'string.escape'],
+              [
+                /"/,
+                {
+                  token: 'string.quote',
+                  bracket: '@close',
+                  switchTo: '@allowMethod',
+                },
+              ],
+              [/\$\$/, 'string'],
+              [/(\$)([a-z_]\w*)/, ['operator', 'identifier']],
+              [/\$\{/, 'operator', '@interp'],
+              [/./, 'string'],
+            ],
+            sstringt: [
+              [/@escapes/, 'string.escape'],
+              [/"(?=""")/, 'string'],
+              [
+                /"""/,
+                {
+                  token: 'string.quote',
+                  bracket: '@close',
+                  switchTo: '@allowMethod',
+                },
+              ],
+              [/\$\$/, 'string'],
+              [/(\$)([a-z_]\w*)/, ['operator', 'identifier']],
+              [/\$\{/, 'operator', '@interp'],
+              [/./, 'string'],
+            ],
+            interp: [
+              [/{/, 'operator', '@push'],
+              [/}/, 'operator', '@pop'],
+              { include: '@root' },
+            ],
+            rawstring: [
+              [/[^"]/, 'string'],
+              [
+                /"/,
+                {
+                  token: 'string.quote',
+                  bracket: '@close',
+                  switchTo: '@allowMethod',
+                },
+              ],
+            ],
+            rawstringt: [
+              [/[^"]/, 'string'],
+              [/"(?=""")/, 'string'],
+              [
+                /"""/,
+                {
+                  token: 'string.quote',
+                  bracket: '@close',
+                  switchTo: '@allowMethod',
+                },
+              ],
+              [/"/, 'string'],
+            ],
+            whitespace: [
+              [/[ \t\r\n]+/, 'white'],
+              [/\/\*/, 'comment', '@comment'],
+              [/\/\/.*$/, 'comment'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/1886.1886.js

@@ -0,0 +1,563 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [1886],
+  {
+    81886: (e, n, i) => {
+      'use strict';
+      i.r(n), i.d(n, { conf: () => t, language: () => r });
+      var t = {
+          comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+            ['begin', 'end'],
+            ['case', 'endcase'],
+            ['casex', 'endcase'],
+            ['casez', 'endcase'],
+            ['checker', 'endchecker'],
+            ['class', 'endclass'],
+            ['clocking', 'endclocking'],
+            ['config', 'endconfig'],
+            ['function', 'endfunction'],
+            ['generate', 'endgenerate'],
+            ['group', 'endgroup'],
+            ['interface', 'endinterface'],
+            ['module', 'endmodule'],
+            ['package', 'endpackage'],
+            ['primitive', 'endprimitive'],
+            ['program', 'endprogram'],
+            ['property', 'endproperty'],
+            ['specify', 'endspecify'],
+            ['sequence', 'endsequence'],
+            ['table', 'endtable'],
+            ['task', 'endtask'],
+          ],
+          autoClosingPairs: [
+            { open: '[', close: ']' },
+            { open: '{', close: '}' },
+            { open: '(', close: ')' },
+            { open: "'", close: "'", notIn: ['string', 'comment'] },
+            { open: '"', close: '"', notIn: ['string'] },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          folding: {
+            offSide: !1,
+            markers: {
+              start: new RegExp(
+                '^(?:\\s*|.*(?!\\/[\\/\\*])[^\\w])(?:begin|case(x|z)?|class|clocking|config|covergroup|function|generate|interface|module|package|primitive|property|program|sequence|specify|table|task)\\b'
+              ),
+              end: new RegExp(
+                '^(?:\\s*|.*(?!\\/[\\/\\*])[^\\w])(?:end|endcase|endclass|endclocking|endconfig|endgroup|endfunction|endgenerate|endinterface|endmodule|endpackage|endprimitive|endproperty|endprogram|endsequence|endspecify|endtable|endtask)\\b'
+              ),
+            },
+          },
+        },
+        r = {
+          defaultToken: '',
+          tokenPostfix: '.sv',
+          brackets: [
+            { token: 'delimiter.curly', open: '{', close: '}' },
+            { token: 'delimiter.parenthesis', open: '(', close: ')' },
+            { token: 'delimiter.square', open: '[', close: ']' },
+            { token: 'delimiter.angle', open: '<', close: '>' },
+          ],
+          keywords: [
+            'accept_on',
+            'alias',
+            'always',
+            'always_comb',
+            'always_ff',
+            'always_latch',
+            'and',
+            'assert',
+            'assign',
+            'assume',
+            'automatic',
+            'before',
+            'begin',
+            'bind',
+            'bins',
+            'binsof',
+            'bit',
+            'break',
+            'buf',
+            'bufif0',
+            'bufif1',
+            'byte',
+            'case',
+            'casex',
+            'casez',
+            'cell',
+            'chandle',
+            'checker',
+            'class',
+            'clocking',
+            'cmos',
+            'config',
+            'const',
+            'constraint',
+            'context',
+            'continue',
+            'cover',
+            'covergroup',
+            'coverpoint',
+            'cross',
+            'deassign',
+            'default',
+            'defparam',
+            'design',
+            'disable',
+            'dist',
+            'do',
+            'edge',
+            'else',
+            'end',
+            'endcase',
+            'endchecker',
+            'endclass',
+            'endclocking',
+            'endconfig',
+            'endfunction',
+            'endgenerate',
+            'endgroup',
+            'endinterface',
+            'endmodule',
+            'endpackage',
+            'endprimitive',
+            'endprogram',
+            'endproperty',
+            'endspecify',
+            'endsequence',
+            'endtable',
+            'endtask',
+            'enum',
+            'event',
+            'eventually',
+            'expect',
+            'export',
+            'extends',
+            'extern',
+            'final',
+            'first_match',
+            'for',
+            'force',
+            'foreach',
+            'forever',
+            'fork',
+            'forkjoin',
+            'function',
+            'generate',
+            'genvar',
+            'global',
+            'highz0',
+            'highz1',
+            'if',
+            'iff',
+            'ifnone',
+            'ignore_bins',
+            'illegal_bins',
+            'implements',
+            'implies',
+            'import',
+            'incdir',
+            'include',
+            'initial',
+            'inout',
+            'input',
+            'inside',
+            'instance',
+            'int',
+            'integer',
+            'interconnect',
+            'interface',
+            'intersect',
+            'join',
+            'join_any',
+            'join_none',
+            'large',
+            'let',
+            'liblist',
+            'library',
+            'local',
+            'localparam',
+            'logic',
+            'longint',
+            'macromodule',
+            'matches',
+            'medium',
+            'modport',
+            'module',
+            'nand',
+            'negedge',
+            'nettype',
+            'new',
+            'nexttime',
+            'nmos',
+            'nor',
+            'noshowcancelled',
+            'not',
+            'notif0',
+            'notif1',
+            'null',
+            'or',
+            'output',
+            'package',
+            'packed',
+            'parameter',
+            'pmos',
+            'posedge',
+            'primitive',
+            'priority',
+            'program',
+            'property',
+            'protected',
+            'pull0',
+            'pull1',
+            'pulldown',
+            'pullup',
+            'pulsestyle_ondetect',
+            'pulsestyle_onevent',
+            'pure',
+            'rand',
+            'randc',
+            'randcase',
+            'randsequence',
+            'rcmos',
+            'real',
+            'realtime',
+            'ref',
+            'reg',
+            'reject_on',
+            'release',
+            'repeat',
+            'restrict',
+            'return',
+            'rnmos',
+            'rpmos',
+            'rtran',
+            'rtranif0',
+            'rtranif1',
+            's_always',
+            's_eventually',
+            's_nexttime',
+            's_until',
+            's_until_with',
+            'scalared',
+            'sequence',
+            'shortint',
+            'shortreal',
+            'showcancelled',
+            'signed',
+            'small',
+            'soft',
+            'solve',
+            'specify',
+            'specparam',
+            'static',
+            'string',
+            'strong',
+            'strong0',
+            'strong1',
+            'struct',
+            'super',
+            'supply0',
+            'supply1',
+            'sync_accept_on',
+            'sync_reject_on',
+            'table',
+            'tagged',
+            'task',
+            'this',
+            'throughout',
+            'time',
+            'timeprecision',
+            'timeunit',
+            'tran',
+            'tranif0',
+            'tranif1',
+            'tri',
+            'tri0',
+            'tri1',
+            'triand',
+            'trior',
+            'trireg',
+            'type',
+            'typedef',
+            'union',
+            'unique',
+            'unique0',
+            'unsigned',
+            'until',
+            'until_with',
+            'untyped',
+            'use',
+            'uwire',
+            'var',
+            'vectored',
+            'virtual',
+            'void',
+            'wait',
+            'wait_order',
+            'wand',
+            'weak',
+            'weak0',
+            'weak1',
+            'while',
+            'wildcard',
+            'wire',
+            'with',
+            'within',
+            'wor',
+            'xnor',
+            'xor',
+          ],
+          builtin_gates: [
+            'and',
+            'nand',
+            'nor',
+            'or',
+            'xor',
+            'xnor',
+            'buf',
+            'not',
+            'bufif0',
+            'bufif1',
+            'notif1',
+            'notif0',
+            'cmos',
+            'nmos',
+            'pmos',
+            'rcmos',
+            'rnmos',
+            'rpmos',
+            'tran',
+            'tranif1',
+            'tranif0',
+            'rtran',
+            'rtranif1',
+            'rtranif0',
+          ],
+          operators: [
+            '=',
+            '+=',
+            '-=',
+            '*=',
+            '/=',
+            '%=',
+            '&=',
+            '|=',
+            '^=',
+            '<<=',
+            '>>+',
+            '<<<=',
+            '>>>=',
+            '?',
+            ':',
+            '+',
+            '-',
+            '!',
+            '~',
+            '&',
+            '~&',
+            '|',
+            '~|',
+            '^',
+            '~^',
+            '^~',
+            '+',
+            '-',
+            '*',
+            '/',
+            '%',
+            '==',
+            '!=',
+            '===',
+            '!==',
+            '==?',
+            '!=?',
+            '&&',
+            '||',
+            '**',
+            '<',
+            '<=',
+            '>',
+            '>=',
+            '&',
+            '|',
+            '^',
+            '>>',
+            '<<',
+            '>>>',
+            '<<<',
+            '++',
+            '--',
+            '->',
+            '<->',
+            'inside',
+            'dist',
+            '::',
+            '+:',
+            '-:',
+            '*>',
+            '&&&',
+            '|->',
+            '|=>',
+            '#=#',
+          ],
+          symbols: /[=><!~?:&|+\-*\/\^%#]+/,
+          escapes: /%%|\\(?:[antvf\\"']|x[0-9A-Fa-f]{1,2}|[0-7]{1,3})/,
+          identifier: /(?:[a-zA-Z_][a-zA-Z0-9_$\.]*|\\\S+ )/,
+          systemcall: /[$][a-zA-Z0-9_]+/,
+          timeunits: /s|ms|us|ns|ps|fs/,
+          tokenizer: {
+            root: [
+              [
+                /^(\s*)(@identifier)/,
+                [
+                  '',
+                  {
+                    cases: {
+                      '@builtin_gates': {
+                        token: 'keyword.$2',
+                        next: '@module_instance',
+                      },
+                      '@keywords': { token: 'keyword.$2' },
+                      '@default': {
+                        token: 'identifier',
+                        next: '@module_instance',
+                      },
+                    },
+                  },
+                ],
+              ],
+              [
+                /^\s*`include/,
+                { token: 'keyword.directive.include', next: '@include' },
+              ],
+              [/^\s*`\s*\w+/, 'keyword'],
+              { include: '@identifier_or_keyword' },
+              { include: '@whitespace' },
+              [/\(\*.*\*\)/, 'annotation'],
+              [/@systemcall/, 'variable.predefined'],
+              [/[{}()\[\]]/, '@brackets'],
+              [/[<>](?!@symbols)/, '@brackets'],
+              [
+                /@symbols/,
+                { cases: { '@operators': 'delimiter', '@default': '' } },
+              ],
+              { include: '@numbers' },
+              [/[;,.]/, 'delimiter'],
+              { include: '@strings' },
+            ],
+            identifier_or_keyword: [
+              [
+                /@identifier/,
+                {
+                  cases: {
+                    '@keywords': { token: 'keyword.$0' },
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+            ],
+            numbers: [
+              [/\d+?[\d_]*(?:\.[\d_]+)?[eE][\-+]?\d+/, 'number.float'],
+              [/\d+?[\d_]*\.[\d_]+(?:\s*@timeunits)?/, 'number.float'],
+              [
+                /(?:\d+?[\d_]*\s*)?'[sS]?[dD]\s*[0-9xXzZ?]+?[0-9xXzZ?_]*/,
+                'number',
+              ],
+              [
+                /(?:\d+?[\d_]*\s*)?'[sS]?[bB]\s*[0-1xXzZ?]+?[0-1xXzZ?_]*/,
+                'number.binary',
+              ],
+              [
+                /(?:\d+?[\d_]*\s*)?'[sS]?[oO]\s*[0-7xXzZ?]+?[0-7xXzZ?_]*/,
+                'number.octal',
+              ],
+              [
+                /(?:\d+?[\d_]*\s*)?'[sS]?[hH]\s*[0-9a-fA-FxXzZ?]+?[0-9a-fA-FxXzZ?_]*/,
+                'number.hex',
+              ],
+              [/1step/, 'number'],
+              [/[\dxXzZ]+?[\dxXzZ_]*(?:\s*@timeunits)?/, 'number'],
+              [/'[01xXzZ]+/, 'number'],
+            ],
+            module_instance: [
+              { include: '@whitespace' },
+              [
+                /(#?)(\()/,
+                ['', { token: '@brackets', next: '@port_connection' }],
+              ],
+              [
+                /@identifier\s*[;={}\[\],]/,
+                { token: '@rematch', next: '@pop' },
+              ],
+              [/@symbols|[;={}\[\],]/, { token: '@rematch', next: '@pop' }],
+              [/@identifier/, 'type'],
+              [/;/, 'delimiter', '@pop'],
+            ],
+            port_connection: [
+              { include: '@identifier_or_keyword' },
+              { include: '@whitespace' },
+              [/@systemcall/, 'variable.predefined'],
+              { include: '@numbers' },
+              { include: '@strings' },
+              [/[,]/, 'delimiter'],
+              [/\(/, '@brackets', '@port_connection'],
+              [/\)/, '@brackets', '@pop'],
+            ],
+            whitespace: [
+              [/[ \t\r\n]+/, ''],
+              [/\/\*/, 'comment', '@comment'],
+              [/\/\/.*$/, 'comment'],
+            ],
+            comment: [
+              [/[^\/*]+/, 'comment'],
+              [/\*\//, 'comment', '@pop'],
+              [/[\/*]/, 'comment'],
+            ],
+            strings: [
+              [/"([^"\\]|\\.)*$/, 'string.invalid'],
+              [/"/, 'string', '@string'],
+            ],
+            string: [
+              [/[^\\"]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/"/, 'string', '@pop'],
+            ],
+            include: [
+              [
+                /(\s*)(")([\w*\/*]*)(.\w*)(")/,
+                [
+                  '',
+                  'string.include.identifier',
+                  'string.include.identifier',
+                  'string.include.identifier',
+                  { token: 'string.include.identifier', next: '@pop' },
+                ],
+              ],
+              [
+                /(\s*)(<)([\w*\/*]*)(.\w*)(>)/,
+                [
+                  '',
+                  'string.include.identifier',
+                  'string.include.identifier',
+                  'string.include.identifier',
+                  { token: 'string.include.identifier', next: '@pop' },
+                ],
+              ],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/1960.1960.js

@@ -0,0 +1,378 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [1960],
+  {
+    71960: (e, t, n) => {
+      'use strict';
+      n.r(t), n.d(t, { conf: () => i, language: () => r });
+      var i = {
+          comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '[', close: ']' },
+            { open: '{', close: '}' },
+            { open: '(', close: ')' },
+            { open: "'", close: "'", notIn: ['string', 'comment'] },
+            { open: '"', close: '"', notIn: ['string'] },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          folding: {
+            markers: {
+              start: new RegExp('^\\s*#pragma\\s+region\\b'),
+              end: new RegExp('^\\s*#pragma\\s+endregion\\b'),
+            },
+          },
+        },
+        r = {
+          defaultToken: '',
+          tokenPostfix: '.cpp',
+          brackets: [
+            { token: 'delimiter.curly', open: '{', close: '}' },
+            { token: 'delimiter.parenthesis', open: '(', close: ')' },
+            { token: 'delimiter.square', open: '[', close: ']' },
+            { token: 'delimiter.angle', open: '<', close: '>' },
+          ],
+          keywords: [
+            'abstract',
+            'amp',
+            'array',
+            'auto',
+            'bool',
+            'break',
+            'case',
+            'catch',
+            'char',
+            'class',
+            'const',
+            'constexpr',
+            'const_cast',
+            'continue',
+            'cpu',
+            'decltype',
+            'default',
+            'delegate',
+            'delete',
+            'do',
+            'double',
+            'dynamic_cast',
+            'each',
+            'else',
+            'enum',
+            'event',
+            'explicit',
+            'export',
+            'extern',
+            'false',
+            'final',
+            'finally',
+            'float',
+            'for',
+            'friend',
+            'gcnew',
+            'generic',
+            'goto',
+            'if',
+            'in',
+            'initonly',
+            'inline',
+            'int',
+            'interface',
+            'interior_ptr',
+            'internal',
+            'literal',
+            'long',
+            'mutable',
+            'namespace',
+            'new',
+            'noexcept',
+            'nullptr',
+            '__nullptr',
+            'operator',
+            'override',
+            'partial',
+            'pascal',
+            'pin_ptr',
+            'private',
+            'property',
+            'protected',
+            'public',
+            'ref',
+            'register',
+            'reinterpret_cast',
+            'restrict',
+            'return',
+            'safe_cast',
+            'sealed',
+            'short',
+            'signed',
+            'sizeof',
+            'static',
+            'static_assert',
+            'static_cast',
+            'struct',
+            'switch',
+            'template',
+            'this',
+            'thread_local',
+            'throw',
+            'tile_static',
+            'true',
+            'try',
+            'typedef',
+            'typeid',
+            'typename',
+            'union',
+            'unsigned',
+            'using',
+            'virtual',
+            'void',
+            'volatile',
+            'wchar_t',
+            'where',
+            'while',
+            '_asm',
+            '_based',
+            '_cdecl',
+            '_declspec',
+            '_fastcall',
+            '_if_exists',
+            '_if_not_exists',
+            '_inline',
+            '_multiple_inheritance',
+            '_pascal',
+            '_single_inheritance',
+            '_stdcall',
+            '_virtual_inheritance',
+            '_w64',
+            '__abstract',
+            '__alignof',
+            '__asm',
+            '__assume',
+            '__based',
+            '__box',
+            '__builtin_alignof',
+            '__cdecl',
+            '__clrcall',
+            '__declspec',
+            '__delegate',
+            '__event',
+            '__except',
+            '__fastcall',
+            '__finally',
+            '__forceinline',
+            '__gc',
+            '__hook',
+            '__identifier',
+            '__if_exists',
+            '__if_not_exists',
+            '__inline',
+            '__int128',
+            '__int16',
+            '__int32',
+            '__int64',
+            '__int8',
+            '__interface',
+            '__leave',
+            '__m128',
+            '__m128d',
+            '__m128i',
+            '__m256',
+            '__m256d',
+            '__m256i',
+            '__m64',
+            '__multiple_inheritance',
+            '__newslot',
+            '__nogc',
+            '__noop',
+            '__nounwind',
+            '__novtordisp',
+            '__pascal',
+            '__pin',
+            '__pragma',
+            '__property',
+            '__ptr32',
+            '__ptr64',
+            '__raise',
+            '__restrict',
+            '__resume',
+            '__sealed',
+            '__single_inheritance',
+            '__stdcall',
+            '__super',
+            '__thiscall',
+            '__try',
+            '__try_cast',
+            '__typeof',
+            '__unaligned',
+            '__unhook',
+            '__uuidof',
+            '__value',
+            '__virtual_inheritance',
+            '__w64',
+            '__wchar_t',
+          ],
+          operators: [
+            '=',
+            '>',
+            '<',
+            '!',
+            '~',
+            '?',
+            ':',
+            '==',
+            '<=',
+            '>=',
+            '!=',
+            '&&',
+            '||',
+            '++',
+            '--',
+            '+',
+            '-',
+            '*',
+            '/',
+            '&',
+            '|',
+            '^',
+            '%',
+            '<<',
+            '>>',
+            '>>>',
+            '+=',
+            '-=',
+            '*=',
+            '/=',
+            '&=',
+            '|=',
+            '^=',
+            '%=',
+            '<<=',
+            '>>=',
+            '>>>=',
+          ],
+          symbols: /[=><!~?:&|+\-*\/\^%]+/,
+          escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+          integersuffix: /(ll|LL|u|U|l|L)?(ll|LL|u|U|l|L)?/,
+          floatsuffix: /[fFlL]?/,
+          encoding: /u|u8|U|L/,
+          tokenizer: {
+            root: [
+              [
+                /@encoding?R\"(?:([^ ()\\\t]*))\(/,
+                { token: 'string.raw.begin', next: '@raw.$1' },
+              ],
+              [
+                /[a-zA-Z_]\w*/,
+                {
+                  cases: {
+                    '@keywords': { token: 'keyword.$0' },
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+              { include: '@whitespace' },
+              [/\[\[.*\]\]/, 'annotation'],
+              [
+                /^\s*#include/,
+                { token: 'keyword.directive.include', next: '@include' },
+              ],
+              [/^\s*#\s*\w+/, 'keyword'],
+              [/[{}()\[\]]/, '@brackets'],
+              [/[<>](?!@symbols)/, '@brackets'],
+              [
+                /@symbols/,
+                { cases: { '@operators': 'delimiter', '@default': '' } },
+              ],
+              [/\d*\d+[eE]([\-+]?\d+)?(@floatsuffix)/, 'number.float'],
+              [/\d*\.\d+([eE][\-+]?\d+)?(@floatsuffix)/, 'number.float'],
+              [/0[xX][0-9a-fA-F']*[0-9a-fA-F](@integersuffix)/, 'number.hex'],
+              [/0[0-7']*[0-7](@integersuffix)/, 'number.octal'],
+              [/0[bB][0-1']*[0-1](@integersuffix)/, 'number.binary'],
+              [/\d[\d']*\d(@integersuffix)/, 'number'],
+              [/\d(@integersuffix)/, 'number'],
+              [/[;,.]/, 'delimiter'],
+              [/"([^"\\]|\\.)*$/, 'string.invalid'],
+              [/"/, 'string', '@string'],
+              [/'[^\\']'/, 'string'],
+              [/(')(@escapes)(')/, ['string', 'string.escape', 'string']],
+              [/'/, 'string.invalid'],
+            ],
+            whitespace: [
+              [/[ \t\r\n]+/, ''],
+              [/\/\*\*(?!\/)/, 'comment.doc', '@doccomment'],
+              [/\/\*/, 'comment', '@comment'],
+              [/\/\/.*$/, 'comment'],
+            ],
+            comment: [
+              [/[^\/*]+/, 'comment'],
+              [/\*\//, 'comment', '@pop'],
+              [/[\/*]/, 'comment'],
+            ],
+            doccomment: [
+              [/[^\/*]+/, 'comment.doc'],
+              [/\*\//, 'comment.doc', '@pop'],
+              [/[\/*]/, 'comment.doc'],
+            ],
+            string: [
+              [/[^\\"]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/"/, 'string', '@pop'],
+            ],
+            raw: [
+              [
+                /(.*)(\))(?:([^ ()\\\t"]*))(\")/,
+                {
+                  cases: {
+                    '$3==$S2': [
+                      'string.raw',
+                      'string.raw.end',
+                      'string.raw.end',
+                      { token: 'string.raw.end', next: '@pop' },
+                    ],
+                    '@default': [
+                      'string.raw',
+                      'string.raw',
+                      'string.raw',
+                      'string.raw',
+                    ],
+                  },
+                },
+              ],
+              [/.*/, 'string.raw'],
+            ],
+            include: [
+              [
+                /(\s*)(<)([^<>]*)(>)/,
+                [
+                  '',
+                  'keyword.directive.include.begin',
+                  'string.include.identifier',
+                  { token: 'keyword.directive.include.end', next: '@pop' },
+                ],
+              ],
+              [
+                /(\s*)(")([^"]*)(")/,
+                [
+                  '',
+                  'keyword.directive.include.begin',
+                  'string.include.identifier',
+                  { token: 'keyword.directive.include.end', next: '@pop' },
+                ],
+              ],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/2060.2060.js

@@ -0,0 +1,112 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [2060],
+  {
+    32060: (e, o, n) => {
+      'use strict';
+      n.r(o), n.d(o, { conf: () => t, language: () => s });
+      var t = {
+          comments: { lineComment: ';', blockComment: ['#|', '|#'] },
+          brackets: [
+            ['(', ')'],
+            ['{', '}'],
+            ['[', ']'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+          ],
+        },
+        s = {
+          defaultToken: '',
+          ignoreCase: !0,
+          tokenPostfix: '.scheme',
+          brackets: [
+            { open: '(', close: ')', token: 'delimiter.parenthesis' },
+            { open: '{', close: '}', token: 'delimiter.curly' },
+            { open: '[', close: ']', token: 'delimiter.square' },
+          ],
+          keywords: [
+            'case',
+            'do',
+            'let',
+            'loop',
+            'if',
+            'else',
+            'when',
+            'cons',
+            'car',
+            'cdr',
+            'cond',
+            'lambda',
+            'lambda*',
+            'syntax-rules',
+            'format',
+            'set!',
+            'quote',
+            'eval',
+            'append',
+            'list',
+            'list?',
+            'member?',
+            'load',
+          ],
+          constants: ['#t', '#f'],
+          operators: ['eq?', 'eqv?', 'equal?', 'and', 'or', 'not', 'null?'],
+          tokenizer: {
+            root: [
+              [/#[xXoObB][0-9a-fA-F]+/, 'number.hex'],
+              [/[+-]?\d+(?:(?:\.\d*)?(?:[eE][+-]?\d+)?)?/, 'number.float'],
+              [
+                /(?:\b(?:(define|define-syntax|define-macro))\b)(\s+)((?:\w|\-|\!|\?)*)/,
+                ['keyword', 'white', 'variable'],
+              ],
+              { include: '@whitespace' },
+              { include: '@strings' },
+              [
+                /[a-zA-Z_#][a-zA-Z0-9_\-\?\!\*]*/,
+                {
+                  cases: {
+                    '@keywords': 'keyword',
+                    '@constants': 'constant',
+                    '@operators': 'operators',
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+            ],
+            comment: [
+              [/[^\|#]+/, 'comment'],
+              [/#\|/, 'comment', '@push'],
+              [/\|#/, 'comment', '@pop'],
+              [/[\|#]/, 'comment'],
+            ],
+            whitespace: [
+              [/[ \t\r\n]+/, 'white'],
+              [/#\|/, 'comment', '@comment'],
+              [/;.*$/, 'comment'],
+            ],
+            strings: [
+              [/"$/, 'string', '@popall'],
+              [/"(?=.)/, 'string', '@multiLineString'],
+            ],
+            multiLineString: [
+              [/[^\\"]+$/, 'string', '@popall'],
+              [/[^\\"]+/, 'string'],
+              [/\\./, 'string.escape'],
+              [/"/, 'string', '@popall'],
+              [/\\$/, 'string'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/2075.2075.js

@@ -0,0 +1,222 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [2075],
+  {
+    62075: (e, t, n) => {
+      'use strict';
+      n.r(t), n.d(t, { conf: () => i, language: () => r });
+      var i = {
+          wordPattern: /(#?-?\d*\.\d\w*%?)|((::|[@#.!:])?[\w-?]+%?)|::|[@#.!:]/g,
+          comments: { blockComment: ['/*', '*/'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}', notIn: ['string', 'comment'] },
+            { open: '[', close: ']', notIn: ['string', 'comment'] },
+            { open: '(', close: ')', notIn: ['string', 'comment'] },
+            { open: '"', close: '"', notIn: ['string', 'comment'] },
+            { open: "'", close: "'", notIn: ['string', 'comment'] },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          folding: {
+            markers: {
+              start: new RegExp('^\\s*\\/\\*\\s*#region\\b\\s*(.*?)\\s*\\*\\/'),
+              end: new RegExp('^\\s*\\/\\*\\s*#endregion\\b.*\\*\\/'),
+            },
+          },
+        },
+        r = {
+          defaultToken: '',
+          tokenPostfix: '.css',
+          ws: '[ \t\n\r\f]*',
+          identifier:
+            '-?-?([a-zA-Z]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))([\\w\\-]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))*',
+          brackets: [
+            { open: '{', close: '}', token: 'delimiter.bracket' },
+            { open: '[', close: ']', token: 'delimiter.bracket' },
+            { open: '(', close: ')', token: 'delimiter.parenthesis' },
+            { open: '<', close: '>', token: 'delimiter.angle' },
+          ],
+          tokenizer: {
+            root: [{ include: '@selector' }],
+            selector: [
+              { include: '@comments' },
+              { include: '@import' },
+              { include: '@strings' },
+              [
+                '[@](keyframes|-webkit-keyframes|-moz-keyframes|-o-keyframes)',
+                { token: 'keyword', next: '@keyframedeclaration' },
+              ],
+              [
+                '[@](page|content|font-face|-moz-document)',
+                { token: 'keyword' },
+              ],
+              [
+                '[@](charset|namespace)',
+                { token: 'keyword', next: '@declarationbody' },
+              ],
+              [
+                '(url-prefix)(\\()',
+                [
+                  'attribute.value',
+                  { token: 'delimiter.parenthesis', next: '@urldeclaration' },
+                ],
+              ],
+              [
+                '(url)(\\()',
+                [
+                  'attribute.value',
+                  { token: 'delimiter.parenthesis', next: '@urldeclaration' },
+                ],
+              ],
+              { include: '@selectorname' },
+              ['[\\*]', 'tag'],
+              ['[>\\+,]', 'delimiter'],
+              [
+                '\\[',
+                { token: 'delimiter.bracket', next: '@selectorattribute' },
+              ],
+              ['{', { token: 'delimiter.bracket', next: '@selectorbody' }],
+            ],
+            selectorbody: [
+              { include: '@comments' },
+              [
+                '[*_]?@identifier@ws:(?=(\\s|\\d|[^{;}]*[;}]))',
+                'attribute.name',
+                '@rulevalue',
+              ],
+              ['}', { token: 'delimiter.bracket', next: '@pop' }],
+            ],
+            selectorname: [['(\\.|#(?=[^{])|%|(@identifier)|:)+', 'tag']],
+            selectorattribute: [
+              { include: '@term' },
+              [']', { token: 'delimiter.bracket', next: '@pop' }],
+            ],
+            term: [
+              { include: '@comments' },
+              [
+                '(url-prefix)(\\()',
+                [
+                  'attribute.value',
+                  { token: 'delimiter.parenthesis', next: '@urldeclaration' },
+                ],
+              ],
+              [
+                '(url)(\\()',
+                [
+                  'attribute.value',
+                  { token: 'delimiter.parenthesis', next: '@urldeclaration' },
+                ],
+              ],
+              { include: '@functioninvocation' },
+              { include: '@numbers' },
+              { include: '@name' },
+              ['([<>=\\+\\-\\*\\/\\^\\|\\~,])', 'delimiter'],
+              [',', 'delimiter'],
+            ],
+            rulevalue: [
+              { include: '@comments' },
+              { include: '@strings' },
+              { include: '@term' },
+              ['!important', 'keyword'],
+              [';', 'delimiter', '@pop'],
+              ['(?=})', { token: '', next: '@pop' }],
+            ],
+            warndebug: [
+              [
+                '[@](warn|debug)',
+                { token: 'keyword', next: '@declarationbody' },
+              ],
+            ],
+            import: [
+              ['[@](import)', { token: 'keyword', next: '@declarationbody' }],
+            ],
+            urldeclaration: [
+              { include: '@strings' },
+              ['[^)\r\n]+', 'string'],
+              ['\\)', { token: 'delimiter.parenthesis', next: '@pop' }],
+            ],
+            parenthizedterm: [
+              { include: '@term' },
+              ['\\)', { token: 'delimiter.parenthesis', next: '@pop' }],
+            ],
+            declarationbody: [
+              { include: '@term' },
+              [';', 'delimiter', '@pop'],
+              ['(?=})', { token: '', next: '@pop' }],
+            ],
+            comments: [
+              ['\\/\\*', 'comment', '@comment'],
+              ['\\/\\/+.*', 'comment'],
+            ],
+            comment: [
+              ['\\*\\/', 'comment', '@pop'],
+              [/[^*/]+/, 'comment'],
+              [/./, 'comment'],
+            ],
+            name: [['@identifier', 'attribute.value']],
+            numbers: [
+              [
+                '-?(\\d*\\.)?\\d+([eE][\\-+]?\\d+)?',
+                { token: 'attribute.value.number', next: '@units' },
+              ],
+              ['#[0-9a-fA-F_]+(?!\\w)', 'attribute.value.hex'],
+            ],
+            units: [
+              [
+                '(em|ex|ch|rem|vmin|vmax|vw|vh|vm|cm|mm|in|px|pt|pc|deg|grad|rad|turn|s|ms|Hz|kHz|%)?',
+                'attribute.value.unit',
+                '@pop',
+              ],
+            ],
+            keyframedeclaration: [
+              ['@identifier', 'attribute.value'],
+              ['{', { token: 'delimiter.bracket', switchTo: '@keyframebody' }],
+            ],
+            keyframebody: [
+              { include: '@term' },
+              ['{', { token: 'delimiter.bracket', next: '@selectorbody' }],
+              ['}', { token: 'delimiter.bracket', next: '@pop' }],
+            ],
+            functioninvocation: [
+              [
+                '@identifier\\(',
+                { token: 'attribute.value', next: '@functionarguments' },
+              ],
+            ],
+            functionarguments: [
+              ['\\$@identifier@ws:', 'attribute.name'],
+              ['[,]', 'delimiter'],
+              { include: '@term' },
+              ['\\)', { token: 'attribute.value', next: '@pop' }],
+            ],
+            strings: [
+              ['~?"', { token: 'string', next: '@stringenddoublequote' }],
+              ["~?'", { token: 'string', next: '@stringendquote' }],
+            ],
+            stringenddoublequote: [
+              ['\\\\.', 'string'],
+              ['"', { token: 'string', next: '@pop' }],
+              [/[^\\"]+/, 'string'],
+              ['.', 'string'],
+            ],
+            stringendquote: [
+              ['\\\\.', 'string'],
+              ["'", { token: 'string', next: '@pop' }],
+              [/[^\\']+/, 'string'],
+              ['.', 'string'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/2140.2140.js

@@ -0,0 +1,222 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [2140],
+  {
+    22140: (e, o, r) => {
+      'use strict';
+      r.r(o), r.d(o, { conf: () => t, language: () => a });
+      var t = {
+          comments: { lineComment: '#' },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+          ],
+        },
+        a = {
+          defaultToken: '',
+          tokenPostfix: '.r',
+          roxygen: [
+            '@param',
+            '@return',
+            '@name',
+            '@rdname',
+            '@examples',
+            '@include',
+            '@docType',
+            '@S3method',
+            '@TODO',
+            '@aliases',
+            '@alias',
+            '@assignee',
+            '@author',
+            '@callGraphDepth',
+            '@callGraph',
+            '@callGraphPrimitives',
+            '@concept',
+            '@exportClass',
+            '@exportMethod',
+            '@exportPattern',
+            '@export',
+            '@formals',
+            '@format',
+            '@importClassesFrom',
+            '@importFrom',
+            '@importMethodsFrom',
+            '@import',
+            '@keywords',
+            '@method',
+            '@nord',
+            '@note',
+            '@references',
+            '@seealso',
+            '@setClass',
+            '@slot',
+            '@source',
+            '@title',
+            '@usage',
+          ],
+          constants: [
+            'NULL',
+            'FALSE',
+            'TRUE',
+            'NA',
+            'Inf',
+            'NaN ',
+            'NA_integer_',
+            'NA_real_',
+            'NA_complex_',
+            'NA_character_ ',
+            'T',
+            'F',
+            'LETTERS',
+            'letters',
+            'month.abb',
+            'month.name',
+            'pi',
+            'R.version.string',
+          ],
+          keywords: [
+            'break',
+            'next',
+            'return',
+            'if',
+            'else',
+            'for',
+            'in',
+            'repeat',
+            'while',
+            'array',
+            'category',
+            'character',
+            'complex',
+            'double',
+            'function',
+            'integer',
+            'list',
+            'logical',
+            'matrix',
+            'numeric',
+            'vector',
+            'data.frame',
+            'factor',
+            'library',
+            'require',
+            'attach',
+            'detach',
+            'source',
+          ],
+          special: [
+            '\\n',
+            '\\r',
+            '\\t',
+            '\\b',
+            '\\a',
+            '\\f',
+            '\\v',
+            "\\'",
+            '\\"',
+            '\\\\',
+          ],
+          brackets: [
+            { open: '{', close: '}', token: 'delimiter.curly' },
+            { open: '[', close: ']', token: 'delimiter.bracket' },
+            { open: '(', close: ')', token: 'delimiter.parenthesis' },
+          ],
+          tokenizer: {
+            root: [
+              { include: '@numbers' },
+              { include: '@strings' },
+              [/[{}\[\]()]/, '@brackets'],
+              { include: '@operators' },
+              [/#'/, 'comment.doc', '@roxygen'],
+              [/(^#.*$)/, 'comment'],
+              [/\s+/, 'white'],
+              [/[,:;]/, 'delimiter'],
+              [/@[a-zA-Z]\w*/, 'tag'],
+              [
+                /[a-zA-Z]\w*/,
+                {
+                  cases: {
+                    '@keywords': 'keyword',
+                    '@constants': 'constant',
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+            ],
+            roxygen: [
+              [
+                /@\w+/,
+                {
+                  cases: {
+                    '@roxygen': 'tag',
+                    '@eos': { token: 'comment.doc', next: '@pop' },
+                    '@default': 'comment.doc',
+                  },
+                },
+              ],
+              [
+                /\s+/,
+                {
+                  cases: {
+                    '@eos': { token: 'comment.doc', next: '@pop' },
+                    '@default': 'comment.doc',
+                  },
+                },
+              ],
+              [/.*/, { token: 'comment.doc', next: '@pop' }],
+            ],
+            numbers: [
+              [/0[xX][0-9a-fA-F]+/, 'number.hex'],
+              [/-?(\d*\.)?\d+([eE][+\-]?\d+)?/, 'number'],
+            ],
+            operators: [
+              [/<{1,2}-/, 'operator'],
+              [/->{1,2}/, 'operator'],
+              [/%[^%\s]+%/, 'operator'],
+              [/\*\*/, 'operator'],
+              [/%%/, 'operator'],
+              [/&&/, 'operator'],
+              [/\|\|/, 'operator'],
+              [/<</, 'operator'],
+              [/>>/, 'operator'],
+              [/[-+=&|!<>^~*/:$]/, 'operator'],
+            ],
+            strings: [
+              [/'/, 'string.escape', '@stringBody'],
+              [/"/, 'string.escape', '@dblStringBody'],
+            ],
+            stringBody: [
+              [
+                /\\./,
+                { cases: { '@special': 'string', '@default': 'error-token' } },
+              ],
+              [/'/, 'string.escape', '@popall'],
+              [/./, 'string'],
+            ],
+            dblStringBody: [
+              [
+                /\\./,
+                { cases: { '@special': 'string', '@default': 'error-token' } },
+              ],
+              [/"/, 'string.escape', '@popall'],
+              [/./, 'string'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/249.249.js

@@ -0,0 +1,201 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [249],
+  {
+    80249: (e, n, t) => {
+      'use strict';
+      t.r(n), t.d(n, { conf: () => o, language: () => s });
+      var o = {
+          comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '`', close: '`', notIn: ['string'] },
+            { open: '"', close: '"', notIn: ['string'] },
+            { open: "'", close: "'", notIn: ['string', 'comment'] },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '`', close: '`' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+        },
+        s = {
+          defaultToken: '',
+          tokenPostfix: '.go',
+          keywords: [
+            'break',
+            'case',
+            'chan',
+            'const',
+            'continue',
+            'default',
+            'defer',
+            'else',
+            'fallthrough',
+            'for',
+            'func',
+            'go',
+            'goto',
+            'if',
+            'import',
+            'interface',
+            'map',
+            'package',
+            'range',
+            'return',
+            'select',
+            'struct',
+            'switch',
+            'type',
+            'var',
+            'bool',
+            'true',
+            'false',
+            'uint8',
+            'uint16',
+            'uint32',
+            'uint64',
+            'int8',
+            'int16',
+            'int32',
+            'int64',
+            'float32',
+            'float64',
+            'complex64',
+            'complex128',
+            'byte',
+            'rune',
+            'uint',
+            'int',
+            'uintptr',
+            'string',
+            'nil',
+          ],
+          operators: [
+            '+',
+            '-',
+            '*',
+            '/',
+            '%',
+            '&',
+            '|',
+            '^',
+            '<<',
+            '>>',
+            '&^',
+            '+=',
+            '-=',
+            '*=',
+            '/=',
+            '%=',
+            '&=',
+            '|=',
+            '^=',
+            '<<=',
+            '>>=',
+            '&^=',
+            '&&',
+            '||',
+            '<-',
+            '++',
+            '--',
+            '==',
+            '<',
+            '>',
+            '=',
+            '!',
+            '!=',
+            '<=',
+            '>=',
+            ':=',
+            '...',
+            '(',
+            ')',
+            '',
+            ']',
+            '{',
+            '}',
+            ',',
+            ';',
+            '.',
+            ':',
+          ],
+          symbols: /[=><!~?:&|+\-*\/\^%]+/,
+          escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+          tokenizer: {
+            root: [
+              [
+                /[a-zA-Z_]\w*/,
+                {
+                  cases: {
+                    '@keywords': { token: 'keyword.$0' },
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+              { include: '@whitespace' },
+              [/\[\[.*\]\]/, 'annotation'],
+              [/^\s*#\w+/, 'keyword'],
+              [/[{}()\[\]]/, '@brackets'],
+              [/[<>](?!@symbols)/, '@brackets'],
+              [
+                /@symbols/,
+                { cases: { '@operators': 'delimiter', '@default': '' } },
+              ],
+              [/\d*\d+[eE]([\-+]?\d+)?/, 'number.float'],
+              [/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
+              [/0[xX][0-9a-fA-F']*[0-9a-fA-F]/, 'number.hex'],
+              [/0[0-7']*[0-7]/, 'number.octal'],
+              [/0[bB][0-1']*[0-1]/, 'number.binary'],
+              [/\d[\d']*/, 'number'],
+              [/\d/, 'number'],
+              [/[;,.]/, 'delimiter'],
+              [/"([^"\\]|\\.)*$/, 'string.invalid'],
+              [/"/, 'string', '@string'],
+              [/`/, 'string', '@rawstring'],
+              [/'[^\\']'/, 'string'],
+              [/(')(@escapes)(')/, ['string', 'string.escape', 'string']],
+              [/'/, 'string.invalid'],
+            ],
+            whitespace: [
+              [/[ \t\r\n]+/, ''],
+              [/\/\*\*(?!\/)/, 'comment.doc', '@doccomment'],
+              [/\/\*/, 'comment', '@comment'],
+              [/\/\/.*$/, 'comment'],
+            ],
+            comment: [
+              [/[^\/*]+/, 'comment'],
+              [/\*\//, 'comment', '@pop'],
+              [/[\/*]/, 'comment'],
+            ],
+            doccomment: [
+              [/[^\/*]+/, 'comment.doc'],
+              [/\/\*/, 'comment.doc.invalid'],
+              [/\*\//, 'comment.doc', '@pop'],
+              [/[\/*]/, 'comment.doc'],
+            ],
+            string: [
+              [/[^\\"]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/"/, 'string', '@pop'],
+            ],
+            rawstring: [
+              [/[^\`]/, 'string'],
+              [/`/, 'string', '@pop'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/2571.2571.js

@@ -0,0 +1,289 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [2571],
+  {
+    2571: (e, t, n) => {
+      'use strict';
+      n.r(t), n.d(t, { conf: () => o, language: () => d });
+      var i = n(89587),
+        r = [
+          'area',
+          'base',
+          'br',
+          'col',
+          'embed',
+          'hr',
+          'img',
+          'input',
+          'keygen',
+          'link',
+          'menuitem',
+          'meta',
+          'param',
+          'source',
+          'track',
+          'wbr',
+        ],
+        o = {
+          wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\$\^\&\*\(\)\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\s]+)/g,
+          comments: { blockComment: ['\x3c!--', '--\x3e'] },
+          brackets: [
+            ['\x3c!--', '--\x3e'],
+            ['<', '>'],
+            ['{', '}'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          surroundingPairs: [
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '<', close: '>' },
+          ],
+          onEnterRules: [
+            {
+              beforeText: new RegExp(
+                '<(?!(?:' +
+                  r.join('|') +
+                  '))([_:\\w][_:\\w-.\\d]*)([^/>]*(?!/)>)[^<]*$',
+                'i'
+              ),
+              afterText: /^<\/([_:\w][_:\w-.\d]*)\s*>$/i,
+              action: { indentAction: i.Mj.IndentAction.IndentOutdent },
+            },
+            {
+              beforeText: new RegExp(
+                '<(?!(?:' +
+                  r.join('|') +
+                  '))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$',
+                'i'
+              ),
+              action: { indentAction: i.Mj.IndentAction.Indent },
+            },
+          ],
+          folding: {
+            markers: {
+              start: new RegExp('^\\s*\x3c!--\\s*#region\\b.*--\x3e'),
+              end: new RegExp('^\\s*\x3c!--\\s*#endregion\\b.*--\x3e'),
+            },
+          },
+        },
+        d = {
+          defaultToken: '',
+          tokenPostfix: '.html',
+          ignoreCase: !0,
+          tokenizer: {
+            root: [
+              [/<!DOCTYPE/, 'metatag', '@doctype'],
+              [/<!--/, 'comment', '@comment'],
+              [
+                /(<)((?:[\w\-]+:)?[\w\-]+)(\s*)(\/>)/,
+                ['delimiter', 'tag', '', 'delimiter'],
+              ],
+              [/(<)(script)/, ['delimiter', { token: 'tag', next: '@script' }]],
+              [/(<)(style)/, ['delimiter', { token: 'tag', next: '@style' }]],
+              [
+                /(<)((?:[\w\-]+:)?[\w\-]+)/,
+                ['delimiter', { token: 'tag', next: '@otherTag' }],
+              ],
+              [
+                /(<\/)((?:[\w\-]+:)?[\w\-]+)/,
+                ['delimiter', { token: 'tag', next: '@otherTag' }],
+              ],
+              [/</, 'delimiter'],
+              [/[^<]+/],
+            ],
+            doctype: [
+              [/[^>]+/, 'metatag.content'],
+              [/>/, 'metatag', '@pop'],
+            ],
+            comment: [
+              [/-->/, 'comment', '@pop'],
+              [/[^-]+/, 'comment.content'],
+              [/./, 'comment.content'],
+            ],
+            otherTag: [
+              [/\/?>/, 'delimiter', '@pop'],
+              [/"([^"]*)"/, 'attribute.value'],
+              [/'([^']*)'/, 'attribute.value'],
+              [/[\w\-]+/, 'attribute.name'],
+              [/=/, 'delimiter'],
+              [/[ \t\r\n]+/],
+            ],
+            script: [
+              [/type/, 'attribute.name', '@scriptAfterType'],
+              [/"([^"]*)"/, 'attribute.value'],
+              [/'([^']*)'/, 'attribute.value'],
+              [/[\w\-]+/, 'attribute.name'],
+              [/=/, 'delimiter'],
+              [
+                />/,
+                {
+                  token: 'delimiter',
+                  next: '@scriptEmbedded',
+                  nextEmbedded: 'text/javascript',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [
+                /(<\/)(script\s*)(>)/,
+                ['delimiter', 'tag', { token: 'delimiter', next: '@pop' }],
+              ],
+            ],
+            scriptAfterType: [
+              [/=/, 'delimiter', '@scriptAfterTypeEquals'],
+              [
+                />/,
+                {
+                  token: 'delimiter',
+                  next: '@scriptEmbedded',
+                  nextEmbedded: 'text/javascript',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            scriptAfterTypeEquals: [
+              [
+                /"([^"]*)"/,
+                {
+                  token: 'attribute.value',
+                  switchTo: '@scriptWithCustomType.$1',
+                },
+              ],
+              [
+                /'([^']*)'/,
+                {
+                  token: 'attribute.value',
+                  switchTo: '@scriptWithCustomType.$1',
+                },
+              ],
+              [
+                />/,
+                {
+                  token: 'delimiter',
+                  next: '@scriptEmbedded',
+                  nextEmbedded: 'text/javascript',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            scriptWithCustomType: [
+              [
+                />/,
+                {
+                  token: 'delimiter',
+                  next: '@scriptEmbedded.$S2',
+                  nextEmbedded: '$S2',
+                },
+              ],
+              [/"([^"]*)"/, 'attribute.value'],
+              [/'([^']*)'/, 'attribute.value'],
+              [/[\w\-]+/, 'attribute.name'],
+              [/=/, 'delimiter'],
+              [/[ \t\r\n]+/],
+              [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            scriptEmbedded: [
+              [
+                /<\/script/,
+                { token: '@rematch', next: '@pop', nextEmbedded: '@pop' },
+              ],
+              [/[^<]+/, ''],
+            ],
+            style: [
+              [/type/, 'attribute.name', '@styleAfterType'],
+              [/"([^"]*)"/, 'attribute.value'],
+              [/'([^']*)'/, 'attribute.value'],
+              [/[\w\-]+/, 'attribute.name'],
+              [/=/, 'delimiter'],
+              [
+                />/,
+                {
+                  token: 'delimiter',
+                  next: '@styleEmbedded',
+                  nextEmbedded: 'text/css',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [
+                /(<\/)(style\s*)(>)/,
+                ['delimiter', 'tag', { token: 'delimiter', next: '@pop' }],
+              ],
+            ],
+            styleAfterType: [
+              [/=/, 'delimiter', '@styleAfterTypeEquals'],
+              [
+                />/,
+                {
+                  token: 'delimiter',
+                  next: '@styleEmbedded',
+                  nextEmbedded: 'text/css',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            styleAfterTypeEquals: [
+              [
+                /"([^"]*)"/,
+                {
+                  token: 'attribute.value',
+                  switchTo: '@styleWithCustomType.$1',
+                },
+              ],
+              [
+                /'([^']*)'/,
+                {
+                  token: 'attribute.value',
+                  switchTo: '@styleWithCustomType.$1',
+                },
+              ],
+              [
+                />/,
+                {
+                  token: 'delimiter',
+                  next: '@styleEmbedded',
+                  nextEmbedded: 'text/css',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            styleWithCustomType: [
+              [
+                />/,
+                {
+                  token: 'delimiter',
+                  next: '@styleEmbedded.$S2',
+                  nextEmbedded: '$S2',
+                },
+              ],
+              [/"([^"]*)"/, 'attribute.value'],
+              [/'([^']*)'/, 'attribute.value'],
+              [/[\w\-]+/, 'attribute.name'],
+              [/=/, 'delimiter'],
+              [/[ \t\r\n]+/],
+              [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            styleEmbedded: [
+              [
+                /<\/style/,
+                { token: '@rematch', next: '@pop', nextEmbedded: '@pop' },
+              ],
+              [/[^<]+/, ''],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/2798.2798.js

@@ -0,0 +1,67 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [2798],
+  {
+    52798: (e, n, s) => {
+      'use strict';
+      s.r(n), s.d(n, { conf: () => i, language: () => o });
+      var i = {
+          comments: { lineComment: '#' },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+        },
+        o = {
+          defaultToken: '',
+          tokenPostfix: '.ini',
+          escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+          tokenizer: {
+            root: [
+              [/^\[[^\]]*\]/, 'metatag'],
+              [/(^\w+)(\s*)(\=)/, ['key', '', 'delimiter']],
+              { include: '@whitespace' },
+              [/\d+/, 'number'],
+              [/"([^"\\]|\\.)*$/, 'string.invalid'],
+              [/'([^'\\]|\\.)*$/, 'string.invalid'],
+              [/"/, 'string', '@string."'],
+              [/'/, 'string', "@string.'"],
+            ],
+            whitespace: [
+              [/[ \t\r\n]+/, ''],
+              [/^\s*[#;].*$/, 'comment'],
+            ],
+            string: [
+              [/[^\\"']+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [
+                /["']/,
+                {
+                  cases: {
+                    '$#==$S2': { token: 'string', next: '@pop' },
+                    '@default': 'string',
+                  },
+                },
+              ],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/2892.2892.js

@@ -0,0 +1,405 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [2892],
+  {
+    22892: (e, t, n) => {
+      'use strict';
+      n.r(t), n.d(t, { conf: () => o, language: () => a });
+      var o = {
+          comments: { lineComment: '//' },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '"', close: '"', notIn: ['string', 'comment'] },
+            { open: "'", close: "'", notIn: ['string', 'comment'] },
+            { open: '{', close: '}', notIn: ['string', 'comment'] },
+            { open: '[', close: ']', notIn: ['string', 'comment'] },
+            { open: '(', close: ')', notIn: ['string', 'comment'] },
+          ],
+          folding: { offSide: !0 },
+        },
+        a = {
+          defaultToken: '',
+          tokenPostfix: '.pug',
+          ignoreCase: !0,
+          brackets: [
+            { token: 'delimiter.curly', open: '{', close: '}' },
+            { token: 'delimiter.array', open: '[', close: ']' },
+            { token: 'delimiter.parenthesis', open: '(', close: ')' },
+          ],
+          keywords: [
+            'append',
+            'block',
+            'case',
+            'default',
+            'doctype',
+            'each',
+            'else',
+            'extends',
+            'for',
+            'if',
+            'in',
+            'include',
+            'mixin',
+            'typeof',
+            'unless',
+            'var',
+            'when',
+          ],
+          tags: [
+            'a',
+            'abbr',
+            'acronym',
+            'address',
+            'area',
+            'article',
+            'aside',
+            'audio',
+            'b',
+            'base',
+            'basefont',
+            'bdi',
+            'bdo',
+            'blockquote',
+            'body',
+            'br',
+            'button',
+            'canvas',
+            'caption',
+            'center',
+            'cite',
+            'code',
+            'col',
+            'colgroup',
+            'command',
+            'datalist',
+            'dd',
+            'del',
+            'details',
+            'dfn',
+            'div',
+            'dl',
+            'dt',
+            'em',
+            'embed',
+            'fieldset',
+            'figcaption',
+            'figure',
+            'font',
+            'footer',
+            'form',
+            'frame',
+            'frameset',
+            'h1',
+            'h2',
+            'h3',
+            'h4',
+            'h5',
+            'h6',
+            'head',
+            'header',
+            'hgroup',
+            'hr',
+            'html',
+            'i',
+            'iframe',
+            'img',
+            'input',
+            'ins',
+            'keygen',
+            'kbd',
+            'label',
+            'li',
+            'link',
+            'map',
+            'mark',
+            'menu',
+            'meta',
+            'meter',
+            'nav',
+            'noframes',
+            'noscript',
+            'object',
+            'ol',
+            'optgroup',
+            'option',
+            'output',
+            'p',
+            'param',
+            'pre',
+            'progress',
+            'q',
+            'rp',
+            'rt',
+            'ruby',
+            's',
+            'samp',
+            'script',
+            'section',
+            'select',
+            'small',
+            'source',
+            'span',
+            'strike',
+            'strong',
+            'style',
+            'sub',
+            'summary',
+            'sup',
+            'table',
+            'tbody',
+            'td',
+            'textarea',
+            'tfoot',
+            'th',
+            'thead',
+            'time',
+            'title',
+            'tr',
+            'tracks',
+            'tt',
+            'u',
+            'ul',
+            'video',
+            'wbr',
+          ],
+          symbols: /[\+\-\*\%\&\|\!\=\/\.\,\:]+/,
+          escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+          tokenizer: {
+            root: [
+              [
+                /^(\s*)([a-zA-Z_-][\w-]*)/,
+                {
+                  cases: {
+                    '$2@tags': {
+                      cases: {
+                        '@eos': ['', 'tag'],
+                        '@default': ['', { token: 'tag', next: '@tag.$1' }],
+                      },
+                    },
+                    '$2@keywords': ['', { token: 'keyword.$2' }],
+                    '@default': ['', ''],
+                  },
+                },
+              ],
+              [
+                /^(\s*)(#[a-zA-Z_-][\w-]*)/,
+                {
+                  cases: {
+                    '@eos': ['', 'tag.id'],
+                    '@default': ['', { token: 'tag.id', next: '@tag.$1' }],
+                  },
+                },
+              ],
+              [
+                /^(\s*)(\.[a-zA-Z_-][\w-]*)/,
+                {
+                  cases: {
+                    '@eos': ['', 'tag.class'],
+                    '@default': ['', { token: 'tag.class', next: '@tag.$1' }],
+                  },
+                },
+              ],
+              [/^(\s*)(\|.*)$/, ''],
+              { include: '@whitespace' },
+              [
+                /[a-zA-Z_$][\w$]*/,
+                {
+                  cases: {
+                    '@keywords': { token: 'keyword.$0' },
+                    '@default': '',
+                  },
+                },
+              ],
+              [/[{}()\[\]]/, '@brackets'],
+              [/@symbols/, 'delimiter'],
+              [/\d+\.\d+([eE][\-+]?\d+)?/, 'number.float'],
+              [/\d+/, 'number'],
+              [/"/, 'string', '@string."'],
+              [/'/, 'string', "@string.'"],
+            ],
+            tag: [
+              [
+                /(\.)(\s*$)/,
+                [{ token: 'delimiter', next: '@blockText.$S2.' }, ''],
+              ],
+              [/\s+/, { token: '', next: '@simpleText' }],
+              [
+                /#[a-zA-Z_-][\w-]*/,
+                {
+                  cases: {
+                    '@eos': { token: 'tag.id', next: '@pop' },
+                    '@default': 'tag.id',
+                  },
+                },
+              ],
+              [
+                /\.[a-zA-Z_-][\w-]*/,
+                {
+                  cases: {
+                    '@eos': { token: 'tag.class', next: '@pop' },
+                    '@default': 'tag.class',
+                  },
+                },
+              ],
+              [
+                /\(/,
+                { token: 'delimiter.parenthesis', next: '@attributeList' },
+              ],
+            ],
+            simpleText: [
+              [/[^#]+$/, { token: '', next: '@popall' }],
+              [/[^#]+/, { token: '' }],
+              [
+                /(#{)([^}]*)(})/,
+                {
+                  cases: {
+                    '@eos': [
+                      'interpolation.delimiter',
+                      'interpolation',
+                      { token: 'interpolation.delimiter', next: '@popall' },
+                    ],
+                    '@default': [
+                      'interpolation.delimiter',
+                      'interpolation',
+                      'interpolation.delimiter',
+                    ],
+                  },
+                },
+              ],
+              [/#$/, { token: '', next: '@popall' }],
+              [/#/, ''],
+            ],
+            attributeList: [
+              [/\s+/, ''],
+              [
+                /(\w+)(\s*=\s*)("|')/,
+                [
+                  'attribute.name',
+                  'delimiter',
+                  { token: 'attribute.value', next: '@value.$3' },
+                ],
+              ],
+              [/\w+/, 'attribute.name'],
+              [
+                /,/,
+                {
+                  cases: {
+                    '@eos': { token: 'attribute.delimiter', next: '@popall' },
+                    '@default': 'attribute.delimiter',
+                  },
+                },
+              ],
+              [/\)$/, { token: 'delimiter.parenthesis', next: '@popall' }],
+              [/\)/, { token: 'delimiter.parenthesis', next: '@pop' }],
+            ],
+            whitespace: [
+              [
+                /^(\s*)(\/\/.*)$/,
+                { token: 'comment', next: '@blockText.$1.comment' },
+              ],
+              [/[ \t\r\n]+/, ''],
+              [/<!--/, { token: 'comment', next: '@comment' }],
+            ],
+            blockText: [
+              [
+                /^\s+.*$/,
+                {
+                  cases: {
+                    '($S2\\s+.*$)': { token: '$S3' },
+                    '@default': { token: '@rematch', next: '@popall' },
+                  },
+                },
+              ],
+              [/./, { token: '@rematch', next: '@popall' }],
+            ],
+            comment: [
+              [/[^<\-]+/, 'comment.content'],
+              [/-->/, { token: 'comment', next: '@pop' }],
+              [/<!--/, 'comment.content.invalid'],
+              [/[<\-]/, 'comment.content'],
+            ],
+            string: [
+              [
+                /[^\\"'#]+/,
+                {
+                  cases: {
+                    '@eos': { token: 'string', next: '@popall' },
+                    '@default': 'string',
+                  },
+                },
+              ],
+              [
+                /@escapes/,
+                {
+                  cases: {
+                    '@eos': { token: 'string.escape', next: '@popall' },
+                    '@default': 'string.escape',
+                  },
+                },
+              ],
+              [
+                /\\./,
+                {
+                  cases: {
+                    '@eos': { token: 'string.escape.invalid', next: '@popall' },
+                    '@default': 'string.escape.invalid',
+                  },
+                },
+              ],
+              [
+                /(#{)([^}]*)(})/,
+                [
+                  'interpolation.delimiter',
+                  'interpolation',
+                  'interpolation.delimiter',
+                ],
+              ],
+              [/#/, 'string'],
+              [
+                /["']/,
+                {
+                  cases: {
+                    '$#==$S2': { token: 'string', next: '@pop' },
+                    '@default': { token: 'string' },
+                  },
+                },
+              ],
+            ],
+            value: [
+              [
+                /[^\\"']+/,
+                {
+                  cases: {
+                    '@eos': { token: 'attribute.value', next: '@popall' },
+                    '@default': 'attribute.value',
+                  },
+                },
+              ],
+              [
+                /\\./,
+                {
+                  cases: {
+                    '@eos': { token: 'attribute.value', next: '@popall' },
+                    '@default': 'attribute.value',
+                  },
+                },
+              ],
+              [
+                /["']/,
+                {
+                  cases: {
+                    '$#==$S2': { token: 'attribute.value', next: '@pop' },
+                    '@default': { token: 'attribute.value' },
+                  },
+                },
+              ],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/2911.2911.js

@@ -0,0 +1,245 @@
+/*! For license information please see 2911.2911.js.LICENSE.txt */
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [2911],
+  {
+    42911: (e, t, o) => {
+      'use strict';
+      o.r(t), o.d(t, { conf: () => n, language: () => i });
+      var n = {
+          comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+            { open: '`', close: '`' },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+            { open: '`', close: '`' },
+          ],
+        },
+        i = {
+          defaultToken: '',
+          tokenPostfix: '.swift',
+          identifier: /[a-zA-Z_][\w$]*/,
+          attributes: [
+            '@autoclosure',
+            '@noescape',
+            '@noreturn',
+            '@NSApplicationMain',
+            '@NSCopying',
+            '@NSManaged',
+            '@objc',
+            '@UIApplicationMain',
+            '@noreturn',
+            '@availability',
+            '@IBAction',
+            '@IBDesignable',
+            '@IBInspectable',
+            '@IBOutlet',
+          ],
+          accessmodifiers: ['public', 'private', 'internal'],
+          keywords: [
+            '__COLUMN__',
+            '__FILE__',
+            '__FUNCTION__',
+            '__LINE__',
+            'as',
+            'as!',
+            'as?',
+            'associativity',
+            'break',
+            'case',
+            'catch',
+            'class',
+            'continue',
+            'convenience',
+            'default',
+            'deinit',
+            'didSet',
+            'do',
+            'dynamic',
+            'dynamicType',
+            'else',
+            'enum',
+            'extension',
+            'fallthrough',
+            'final',
+            'for',
+            'func',
+            'get',
+            'guard',
+            'if',
+            'import',
+            'in',
+            'infix',
+            'init',
+            'inout',
+            'internal',
+            'is',
+            'lazy',
+            'left',
+            'let',
+            'mutating',
+            'nil',
+            'none',
+            'nonmutating',
+            'operator',
+            'optional',
+            'override',
+            'postfix',
+            'precedence',
+            'prefix',
+            'private',
+            'protocol',
+            'Protocol',
+            'public',
+            'repeat',
+            'required',
+            'return',
+            'right',
+            'self',
+            'Self',
+            'set',
+            'static',
+            'struct',
+            'subscript',
+            'super',
+            'switch',
+            'throw',
+            'throws',
+            'try',
+            'try!',
+            'Type',
+            'typealias',
+            'unowned',
+            'var',
+            'weak',
+            'where',
+            'while',
+            'willSet',
+            'FALSE',
+            'TRUE',
+          ],
+          symbols: /[=(){}\[\].,:;@#\_&\-<>`?!+*\\\/]/,
+          operatorstart: /[\/=\-+!*%<>&|^~?\u00A1-\u00A7\u00A9\u00AB\u00AC\u00AE\u00B0-\u00B1\u00B6\u00BB\u00BF\u00D7\u00F7\u2016-\u2017\u2020-\u2027\u2030-\u203E\u2041-\u2053\u2055-\u205E\u2190-\u23FF\u2500-\u2775\u2794-\u2BFF\u2E00-\u2E7F\u3001-\u3003\u3008-\u3030]/,
+          operatorend: /[\u0300-\u036F\u1DC0-\u1DFF\u20D0-\u20FF\uFE00-\uFE0F\uFE20-\uFE2F\uE0100-\uE01EF]/,
+          operators: /(@operatorstart)((@operatorstart)|(@operatorend))*/,
+          escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+          tokenizer: {
+            root: [
+              { include: '@whitespace' },
+              { include: '@comment' },
+              { include: '@attribute' },
+              { include: '@literal' },
+              { include: '@keyword' },
+              { include: '@invokedmethod' },
+              { include: '@symbol' },
+            ],
+            whitespace: [
+              [/\s+/, 'white'],
+              [/"""/, 'string.quote', '@endDblDocString'],
+            ],
+            endDblDocString: [
+              [/[^"]+/, 'string'],
+              [/\\"/, 'string'],
+              [/"""/, 'string.quote', '@popall'],
+              [/"/, 'string'],
+            ],
+            symbol: [
+              [/[{}()\[\]]/, '@brackets'],
+              [/[<>](?!@symbols)/, '@brackets'],
+              [/[.]/, 'delimiter'],
+              [/@operators/, 'operator'],
+              [/@symbols/, 'operator'],
+            ],
+            comment: [
+              [/\/\/\/.*$/, 'comment.doc'],
+              [/\/\*\*/, 'comment.doc', '@commentdocbody'],
+              [/\/\/.*$/, 'comment'],
+              [/\/\*/, 'comment', '@commentbody'],
+            ],
+            commentdocbody: [
+              [/\/\*/, 'comment', '@commentbody'],
+              [/\*\//, 'comment.doc', '@pop'],
+              [/\:[a-zA-Z]+\:/, 'comment.doc.param'],
+              [/./, 'comment.doc'],
+            ],
+            commentbody: [
+              [/\/\*/, 'comment', '@commentbody'],
+              [/\*\//, 'comment', '@pop'],
+              [/./, 'comment'],
+            ],
+            attribute: [
+              [
+                /\@@identifier/,
+                { cases: { '@attributes': 'keyword.control', '@default': '' } },
+              ],
+            ],
+            literal: [
+              [/"/, { token: 'string.quote', next: '@stringlit' }],
+              [/0[b]([01]_?)+/, 'number.binary'],
+              [/0[o]([0-7]_?)+/, 'number.octal'],
+              [/0[x]([0-9a-fA-F]_?)+([pP][\-+](\d_?)+)?/, 'number.hex'],
+              [/(\d_?)*\.(\d_?)+([eE][\-+]?(\d_?)+)?/, 'number.float'],
+              [/(\d_?)+/, 'number'],
+            ],
+            stringlit: [
+              [/\\\(/, { token: 'operator', next: '@interpolatedexpression' }],
+              [/@escapes/, 'string'],
+              [/\\./, 'string.escape.invalid'],
+              [/"/, { token: 'string.quote', next: '@pop' }],
+              [/./, 'string'],
+            ],
+            interpolatedexpression: [
+              [/\(/, { token: 'operator', next: '@interpolatedexpression' }],
+              [/\)/, { token: 'operator', next: '@pop' }],
+              { include: '@literal' },
+              { include: '@keyword' },
+              { include: '@symbol' },
+            ],
+            keyword: [
+              [/`/, { token: 'operator', next: '@escapedkeyword' }],
+              [
+                /@identifier/,
+                {
+                  cases: {
+                    '@keywords': 'keyword',
+                    '[A-Z][a-zA-Z0-9$]*': 'type.identifier',
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+            ],
+            escapedkeyword: [
+              [/`/, { token: 'operator', next: '@pop' }],
+              [/./, 'identifier'],
+            ],
+            invokedmethod: [
+              [
+                /([.])(@identifier)/,
+                {
+                  cases: {
+                    $2: ['delimeter', 'type.identifier'],
+                    '@default': '',
+                  },
+                },
+              ],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/2911.2911.js.LICENSE.txt

@@ -0,0 +1,3 @@
+/*!---------------------------------------------------------------------------------------------
+ *  Copyright (C) David Owens II, owensd.io. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/

docs/2954.2954.js

@@ -0,0 +1,229 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [2954],
+  {
+    42954: (e, t, s) => {
+      'use strict';
+      s.r(t), s.d(t, { conf: () => n, language: () => o });
+      var n = {
+          comments: { blockComment: ['\x3c!--', '--\x3e'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '<', close: '>', notIn: ['string'] },
+          ],
+          surroundingPairs: [
+            { open: '(', close: ')' },
+            { open: '[', close: ']' },
+            { open: '`', close: '`' },
+          ],
+          folding: {
+            markers: {
+              start: new RegExp('^\\s*\x3c!--\\s*#?region\\b.*--\x3e'),
+              end: new RegExp('^\\s*\x3c!--\\s*#?endregion\\b.*--\x3e'),
+            },
+          },
+        },
+        o = {
+          defaultToken: '',
+          tokenPostfix: '.md',
+          control: /[\\`*_\[\]{}()#+\-\.!]/,
+          noncontrol: /[^\\`*_\[\]{}()#+\-\.!]/,
+          escapes: /\\(?:@control)/,
+          jsescapes: /\\(?:[btnfr\\"']|[0-7][0-7]?|[0-3][0-7]{2})/,
+          empty: [
+            'area',
+            'base',
+            'basefont',
+            'br',
+            'col',
+            'frame',
+            'hr',
+            'img',
+            'input',
+            'isindex',
+            'link',
+            'meta',
+            'param',
+          ],
+          tokenizer: {
+            root: [
+              [/^\s*\|/, '@rematch', '@table_header'],
+              [
+                /^(\s{0,3})(#+)((?:[^\\#]|@escapes)+)((?:#+)?)/,
+                ['white', 'keyword', 'keyword', 'keyword'],
+              ],
+              [/^\s*(=+|\-+)\s*$/, 'keyword'],
+              [/^\s*((\*[ ]?)+)\s*$/, 'meta.separator'],
+              [/^\s*>+/, 'comment'],
+              [/^\s*([\*\-+:]|\d+\.)\s/, 'keyword'],
+              [/^(\t|[ ]{4})[^ ].*$/, 'string'],
+              [
+                /^\s*~~~\s*((?:\w|[\/\-#])+)?\s*$/,
+                { token: 'string', next: '@codeblock' },
+              ],
+              [
+                /^\s*```\s*((?:\w|[\/\-#])+).*$/,
+                { token: 'string', next: '@codeblockgh', nextEmbedded: '$1' },
+              ],
+              [/^\s*```\s*$/, { token: 'string', next: '@codeblock' }],
+              { include: '@linecontent' },
+            ],
+            table_header: [
+              { include: '@table_common' },
+              [/[^\|]+/, 'keyword.table.header'],
+            ],
+            table_body: [
+              { include: '@table_common' },
+              { include: '@linecontent' },
+            ],
+            table_common: [
+              [/\s*[\-:]+\s*/, { token: 'keyword', switchTo: 'table_body' }],
+              [/^\s*\|/, 'keyword.table.left'],
+              [/^\s*[^\|]/, '@rematch', '@pop'],
+              [/^\s*$/, '@rematch', '@pop'],
+              [
+                /\|/,
+                {
+                  cases: {
+                    '@eos': 'keyword.table.right',
+                    '@default': 'keyword.table.middle',
+                  },
+                },
+              ],
+            ],
+            codeblock: [
+              [/^\s*~~~\s*$/, { token: 'string', next: '@pop' }],
+              [/^\s*```\s*$/, { token: 'string', next: '@pop' }],
+              [/.*$/, 'variable.source'],
+            ],
+            codeblockgh: [
+              [
+                /```\s*$/,
+                {
+                  token: 'variable.source',
+                  next: '@pop',
+                  nextEmbedded: '@pop',
+                },
+              ],
+              [/[^`]+/, 'variable.source'],
+            ],
+            linecontent: [
+              [/&\w+;/, 'string.escape'],
+              [/@escapes/, 'escape'],
+              [/\b__([^\\_]|@escapes|_(?!_))+__\b/, 'strong'],
+              [/\*\*([^\\*]|@escapes|\*(?!\*))+\*\*/, 'strong'],
+              [/\b_[^_]+_\b/, 'emphasis'],
+              [/\*([^\\*]|@escapes)+\*/, 'emphasis'],
+              [/`([^\\`]|@escapes)+`/, 'variable'],
+              [/\{+[^}]+\}+/, 'string.target'],
+              [
+                /(!?\[)((?:[^\]\\]|@escapes)*)(\]\([^\)]+\))/,
+                ['string.link', '', 'string.link'],
+              ],
+              [/(!?\[)((?:[^\]\\]|@escapes)*)(\])/, 'string.link'],
+              { include: 'html' },
+            ],
+            html: [
+              [/<(\w+)\/>/, 'tag'],
+              [
+                /<(\w+)/,
+                {
+                  cases: {
+                    '@empty': { token: 'tag', next: '@tag.$1' },
+                    '@default': { token: 'tag', next: '@tag.$1' },
+                  },
+                },
+              ],
+              [/<\/(\w+)\s*>/, { token: 'tag' }],
+              [/<!--/, 'comment', '@comment'],
+            ],
+            comment: [
+              [/[^<\-]+/, 'comment.content'],
+              [/-->/, 'comment', '@pop'],
+              [/<!--/, 'comment.content.invalid'],
+              [/[<\-]/, 'comment.content'],
+            ],
+            tag: [
+              [/[ \t\r\n]+/, 'white'],
+              [
+                /(type)(\s*=\s*)(")([^"]+)(")/,
+                [
+                  'attribute.name.html',
+                  'delimiter.html',
+                  'string.html',
+                  { token: 'string.html', switchTo: '@tag.$S2.$4' },
+                  'string.html',
+                ],
+              ],
+              [
+                /(type)(\s*=\s*)(')([^']+)(')/,
+                [
+                  'attribute.name.html',
+                  'delimiter.html',
+                  'string.html',
+                  { token: 'string.html', switchTo: '@tag.$S2.$4' },
+                  'string.html',
+                ],
+              ],
+              [
+                /(\w+)(\s*=\s*)("[^"]*"|'[^']*')/,
+                ['attribute.name.html', 'delimiter.html', 'string.html'],
+              ],
+              [/\w+/, 'attribute.name.html'],
+              [/\/>/, 'tag', '@pop'],
+              [
+                />/,
+                {
+                  cases: {
+                    '$S2==style': {
+                      token: 'tag',
+                      switchTo: 'embeddedStyle',
+                      nextEmbedded: 'text/css',
+                    },
+                    '$S2==script': {
+                      cases: {
+                        $S3: {
+                          token: 'tag',
+                          switchTo: 'embeddedScript',
+                          nextEmbedded: '$S3',
+                        },
+                        '@default': {
+                          token: 'tag',
+                          switchTo: 'embeddedScript',
+                          nextEmbedded: 'text/javascript',
+                        },
+                      },
+                    },
+                    '@default': { token: 'tag', next: '@pop' },
+                  },
+                },
+              ],
+            ],
+            embeddedStyle: [
+              [/[^<]+/, ''],
+              [
+                /<\/style\s*>/,
+                { token: '@rematch', next: '@pop', nextEmbedded: '@pop' },
+              ],
+              [/</, ''],
+            ],
+            embeddedScript: [
+              [/[^<]+/, ''],
+              [
+                /<\/script\s*>/,
+                { token: '@rematch', next: '@pop', nextEmbedded: '@pop' },
+              ],
+              [/</, ''],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/3036.3036.js

@@ -0,0 +1,753 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [3036],
+  {
+    33036: (e, t, n) => {
+      'use strict';
+      n.r(t), n.d(t, { conf: () => r, language: () => s });
+      var r = {
+          comments: { lineComment: ';;' },
+          brackets: [
+            ['[', ']'],
+            ['(', ')'],
+            ['{', '}'],
+          ],
+          autoClosingPairs: [
+            { open: '[', close: ']' },
+            { open: '"', close: '"' },
+            { open: '(', close: ')' },
+            { open: '{', close: '}' },
+          ],
+          surroundingPairs: [
+            { open: '[', close: ']' },
+            { open: '"', close: '"' },
+            { open: '(', close: ')' },
+            { open: '{', close: '}' },
+          ],
+        },
+        s = {
+          defaultToken: '',
+          ignoreCase: !0,
+          tokenPostfix: '.clj',
+          brackets: [
+            { open: '[', close: ']', token: 'delimiter.square' },
+            { open: '(', close: ')', token: 'delimiter.parenthesis' },
+            { open: '{', close: '}', token: 'delimiter.curly' },
+          ],
+          constants: ['true', 'false', 'nil'],
+          numbers: /^(?:[+\-]?\d+(?:(?:N|(?:[eE][+\-]?\d+))|(?:\.?\d*(?:M|(?:[eE][+\-]?\d+))?)|\/\d+|[xX][0-9a-fA-F]+|r[0-9a-zA-Z]+)?(?=[\\\[\]\s"#'(),;@^`{}~]|$))/,
+          characters: /^(?:\\(?:backspace|formfeed|newline|return|space|tab|o[0-7]{3}|u[0-9A-Fa-f]{4}|x[0-9A-Fa-f]{4}|.)?(?=[\\\[\]\s"(),;@^`{}~]|$))/,
+          escapes: /^\\(?:["'\\bfnrt]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+          qualifiedSymbols: /^(?:(?:[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*(?:\.[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*)*\/)?(?:\/|[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*)*(?=[\\\[\]\s"(),;@^`{}~]|$))/,
+          specialForms: [
+            '.',
+            'catch',
+            'def',
+            'do',
+            'if',
+            'monitor-enter',
+            'monitor-exit',
+            'new',
+            'quote',
+            'recur',
+            'set!',
+            'throw',
+            'try',
+            'var',
+          ],
+          coreSymbols: [
+            '*',
+            "*'",
+            '*1',
+            '*2',
+            '*3',
+            '*agent*',
+            '*allow-unresolved-vars*',
+            '*assert*',
+            '*clojure-version*',
+            '*command-line-args*',
+            '*compile-files*',
+            '*compile-path*',
+            '*compiler-options*',
+            '*data-readers*',
+            '*default-data-reader-fn*',
+            '*e',
+            '*err*',
+            '*file*',
+            '*flush-on-newline*',
+            '*fn-loader*',
+            '*in*',
+            '*math-context*',
+            '*ns*',
+            '*out*',
+            '*print-dup*',
+            '*print-length*',
+            '*print-level*',
+            '*print-meta*',
+            '*print-namespace-maps*',
+            '*print-readably*',
+            '*read-eval*',
+            '*reader-resolver*',
+            '*source-path*',
+            '*suppress-read*',
+            '*unchecked-math*',
+            '*use-context-classloader*',
+            '*verbose-defrecords*',
+            '*warn-on-reflection*',
+            '+',
+            "+'",
+            '-',
+            "-'",
+            '->',
+            '->>',
+            '->ArrayChunk',
+            '->Eduction',
+            '->Vec',
+            '->VecNode',
+            '->VecSeq',
+            '-cache-protocol-fn',
+            '-reset-methods',
+            '..',
+            '/',
+            '<',
+            '<=',
+            '=',
+            '==',
+            '>',
+            '>=',
+            'EMPTY-NODE',
+            'Inst',
+            'StackTraceElement->vec',
+            'Throwable->map',
+            'accessor',
+            'aclone',
+            'add-classpath',
+            'add-watch',
+            'agent',
+            'agent-error',
+            'agent-errors',
+            'aget',
+            'alength',
+            'alias',
+            'all-ns',
+            'alter',
+            'alter-meta!',
+            'alter-var-root',
+            'amap',
+            'ancestors',
+            'and',
+            'any?',
+            'apply',
+            'areduce',
+            'array-map',
+            'as->',
+            'aset',
+            'aset-boolean',
+            'aset-byte',
+            'aset-char',
+            'aset-double',
+            'aset-float',
+            'aset-int',
+            'aset-long',
+            'aset-short',
+            'assert',
+            'assoc',
+            'assoc!',
+            'assoc-in',
+            'associative?',
+            'atom',
+            'await',
+            'await-for',
+            'await1',
+            'bases',
+            'bean',
+            'bigdec',
+            'bigint',
+            'biginteger',
+            'binding',
+            'bit-and',
+            'bit-and-not',
+            'bit-clear',
+            'bit-flip',
+            'bit-not',
+            'bit-or',
+            'bit-set',
+            'bit-shift-left',
+            'bit-shift-right',
+            'bit-test',
+            'bit-xor',
+            'boolean',
+            'boolean-array',
+            'boolean?',
+            'booleans',
+            'bound-fn',
+            'bound-fn*',
+            'bound?',
+            'bounded-count',
+            'butlast',
+            'byte',
+            'byte-array',
+            'bytes',
+            'bytes?',
+            'case',
+            'cast',
+            'cat',
+            'char',
+            'char-array',
+            'char-escape-string',
+            'char-name-string',
+            'char?',
+            'chars',
+            'chunk',
+            'chunk-append',
+            'chunk-buffer',
+            'chunk-cons',
+            'chunk-first',
+            'chunk-next',
+            'chunk-rest',
+            'chunked-seq?',
+            'class',
+            'class?',
+            'clear-agent-errors',
+            'clojure-version',
+            'coll?',
+            'comment',
+            'commute',
+            'comp',
+            'comparator',
+            'compare',
+            'compare-and-set!',
+            'compile',
+            'complement',
+            'completing',
+            'concat',
+            'cond',
+            'cond->',
+            'cond->>',
+            'condp',
+            'conj',
+            'conj!',
+            'cons',
+            'constantly',
+            'construct-proxy',
+            'contains?',
+            'count',
+            'counted?',
+            'create-ns',
+            'create-struct',
+            'cycle',
+            'dec',
+            "dec'",
+            'decimal?',
+            'declare',
+            'dedupe',
+            'default-data-readers',
+            'definline',
+            'definterface',
+            'defmacro',
+            'defmethod',
+            'defmulti',
+            'defn',
+            'defn-',
+            'defonce',
+            'defprotocol',
+            'defrecord',
+            'defstruct',
+            'deftype',
+            'delay',
+            'delay?',
+            'deliver',
+            'denominator',
+            'deref',
+            'derive',
+            'descendants',
+            'destructure',
+            'disj',
+            'disj!',
+            'dissoc',
+            'dissoc!',
+            'distinct',
+            'distinct?',
+            'doall',
+            'dorun',
+            'doseq',
+            'dosync',
+            'dotimes',
+            'doto',
+            'double',
+            'double-array',
+            'double?',
+            'doubles',
+            'drop',
+            'drop-last',
+            'drop-while',
+            'eduction',
+            'empty',
+            'empty?',
+            'ensure',
+            'ensure-reduced',
+            'enumeration-seq',
+            'error-handler',
+            'error-mode',
+            'eval',
+            'even?',
+            'every-pred',
+            'every?',
+            'ex-data',
+            'ex-info',
+            'extend',
+            'extend-protocol',
+            'extend-type',
+            'extenders',
+            'extends?',
+            'false?',
+            'ffirst',
+            'file-seq',
+            'filter',
+            'filterv',
+            'find',
+            'find-keyword',
+            'find-ns',
+            'find-protocol-impl',
+            'find-protocol-method',
+            'find-var',
+            'first',
+            'flatten',
+            'float',
+            'float-array',
+            'float?',
+            'floats',
+            'flush',
+            'fn',
+            'fn?',
+            'fnext',
+            'fnil',
+            'for',
+            'force',
+            'format',
+            'frequencies',
+            'future',
+            'future-call',
+            'future-cancel',
+            'future-cancelled?',
+            'future-done?',
+            'future?',
+            'gen-class',
+            'gen-interface',
+            'gensym',
+            'get',
+            'get-in',
+            'get-method',
+            'get-proxy-class',
+            'get-thread-bindings',
+            'get-validator',
+            'group-by',
+            'halt-when',
+            'hash',
+            'hash-combine',
+            'hash-map',
+            'hash-ordered-coll',
+            'hash-set',
+            'hash-unordered-coll',
+            'ident?',
+            'identical?',
+            'identity',
+            'if-let',
+            'if-not',
+            'if-some',
+            'ifn?',
+            'import',
+            'in-ns',
+            'inc',
+            "inc'",
+            'indexed?',
+            'init-proxy',
+            'inst-ms',
+            'inst-ms*',
+            'inst?',
+            'instance?',
+            'int',
+            'int-array',
+            'int?',
+            'integer?',
+            'interleave',
+            'intern',
+            'interpose',
+            'into',
+            'into-array',
+            'ints',
+            'io!',
+            'isa?',
+            'iterate',
+            'iterator-seq',
+            'juxt',
+            'keep',
+            'keep-indexed',
+            'key',
+            'keys',
+            'keyword',
+            'keyword?',
+            'last',
+            'lazy-cat',
+            'lazy-seq',
+            'let',
+            'letfn',
+            'line-seq',
+            'list',
+            'list*',
+            'list?',
+            'load',
+            'load-file',
+            'load-reader',
+            'load-string',
+            'loaded-libs',
+            'locking',
+            'long',
+            'long-array',
+            'longs',
+            'loop',
+            'macroexpand',
+            'macroexpand-1',
+            'make-array',
+            'make-hierarchy',
+            'map',
+            'map-entry?',
+            'map-indexed',
+            'map?',
+            'mapcat',
+            'mapv',
+            'max',
+            'max-key',
+            'memfn',
+            'memoize',
+            'merge',
+            'merge-with',
+            'meta',
+            'method-sig',
+            'methods',
+            'min',
+            'min-key',
+            'mix-collection-hash',
+            'mod',
+            'munge',
+            'name',
+            'namespace',
+            'namespace-munge',
+            'nat-int?',
+            'neg-int?',
+            'neg?',
+            'newline',
+            'next',
+            'nfirst',
+            'nil?',
+            'nnext',
+            'not',
+            'not-any?',
+            'not-empty',
+            'not-every?',
+            'not=',
+            'ns',
+            'ns-aliases',
+            'ns-imports',
+            'ns-interns',
+            'ns-map',
+            'ns-name',
+            'ns-publics',
+            'ns-refers',
+            'ns-resolve',
+            'ns-unalias',
+            'ns-unmap',
+            'nth',
+            'nthnext',
+            'nthrest',
+            'num',
+            'number?',
+            'numerator',
+            'object-array',
+            'odd?',
+            'or',
+            'parents',
+            'partial',
+            'partition',
+            'partition-all',
+            'partition-by',
+            'pcalls',
+            'peek',
+            'persistent!',
+            'pmap',
+            'pop',
+            'pop!',
+            'pop-thread-bindings',
+            'pos-int?',
+            'pos?',
+            'pr',
+            'pr-str',
+            'prefer-method',
+            'prefers',
+            'primitives-classnames',
+            'print',
+            'print-ctor',
+            'print-dup',
+            'print-method',
+            'print-simple',
+            'print-str',
+            'printf',
+            'println',
+            'println-str',
+            'prn',
+            'prn-str',
+            'promise',
+            'proxy',
+            'proxy-call-with-super',
+            'proxy-mappings',
+            'proxy-name',
+            'proxy-super',
+            'push-thread-bindings',
+            'pvalues',
+            'qualified-ident?',
+            'qualified-keyword?',
+            'qualified-symbol?',
+            'quot',
+            'rand',
+            'rand-int',
+            'rand-nth',
+            'random-sample',
+            'range',
+            'ratio?',
+            'rational?',
+            'rationalize',
+            're-find',
+            're-groups',
+            're-matcher',
+            're-matches',
+            're-pattern',
+            're-seq',
+            'read',
+            'read-line',
+            'read-string',
+            'reader-conditional',
+            'reader-conditional?',
+            'realized?',
+            'record?',
+            'reduce',
+            'reduce-kv',
+            'reduced',
+            'reduced?',
+            'reductions',
+            'ref',
+            'ref-history-count',
+            'ref-max-history',
+            'ref-min-history',
+            'ref-set',
+            'refer',
+            'refer-clojure',
+            'reify',
+            'release-pending-sends',
+            'rem',
+            'remove',
+            'remove-all-methods',
+            'remove-method',
+            'remove-ns',
+            'remove-watch',
+            'repeat',
+            'repeatedly',
+            'replace',
+            'replicate',
+            'require',
+            'reset!',
+            'reset-meta!',
+            'reset-vals!',
+            'resolve',
+            'rest',
+            'restart-agent',
+            'resultset-seq',
+            'reverse',
+            'reversible?',
+            'rseq',
+            'rsubseq',
+            'run!',
+            'satisfies?',
+            'second',
+            'select-keys',
+            'send',
+            'send-off',
+            'send-via',
+            'seq',
+            'seq?',
+            'seqable?',
+            'seque',
+            'sequence',
+            'sequential?',
+            'set',
+            'set-agent-send-executor!',
+            'set-agent-send-off-executor!',
+            'set-error-handler!',
+            'set-error-mode!',
+            'set-validator!',
+            'set?',
+            'short',
+            'short-array',
+            'shorts',
+            'shuffle',
+            'shutdown-agents',
+            'simple-ident?',
+            'simple-keyword?',
+            'simple-symbol?',
+            'slurp',
+            'some',
+            'some->',
+            'some->>',
+            'some-fn',
+            'some?',
+            'sort',
+            'sort-by',
+            'sorted-map',
+            'sorted-map-by',
+            'sorted-set',
+            'sorted-set-by',
+            'sorted?',
+            'special-symbol?',
+            'spit',
+            'split-at',
+            'split-with',
+            'str',
+            'string?',
+            'struct',
+            'struct-map',
+            'subs',
+            'subseq',
+            'subvec',
+            'supers',
+            'swap!',
+            'swap-vals!',
+            'symbol',
+            'symbol?',
+            'sync',
+            'tagged-literal',
+            'tagged-literal?',
+            'take',
+            'take-last',
+            'take-nth',
+            'take-while',
+            'test',
+            'the-ns',
+            'thread-bound?',
+            'time',
+            'to-array',
+            'to-array-2d',
+            'trampoline',
+            'transduce',
+            'transient',
+            'tree-seq',
+            'true?',
+            'type',
+            'unchecked-add',
+            'unchecked-add-int',
+            'unchecked-byte',
+            'unchecked-char',
+            'unchecked-dec',
+            'unchecked-dec-int',
+            'unchecked-divide-int',
+            'unchecked-double',
+            'unchecked-float',
+            'unchecked-inc',
+            'unchecked-inc-int',
+            'unchecked-int',
+            'unchecked-long',
+            'unchecked-multiply',
+            'unchecked-multiply-int',
+            'unchecked-negate',
+            'unchecked-negate-int',
+            'unchecked-remainder-int',
+            'unchecked-short',
+            'unchecked-subtract',
+            'unchecked-subtract-int',
+            'underive',
+            'unquote',
+            'unquote-splicing',
+            'unreduced',
+            'unsigned-bit-shift-right',
+            'update',
+            'update-in',
+            'update-proxy',
+            'uri?',
+            'use',
+            'uuid?',
+            'val',
+            'vals',
+            'var-get',
+            'var-set',
+            'var?',
+            'vary-meta',
+            'vec',
+            'vector',
+            'vector-of',
+            'vector?',
+            'volatile!',
+            'volatile?',
+            'vreset!',
+            'vswap!',
+            'when',
+            'when-first',
+            'when-let',
+            'when-not',
+            'when-some',
+            'while',
+            'with-bindings',
+            'with-bindings*',
+            'with-in-str',
+            'with-loading-context',
+            'with-local-vars',
+            'with-meta',
+            'with-open',
+            'with-out-str',
+            'with-precision',
+            'with-redefs',
+            'with-redefs-fn',
+            'xml-seq',
+            'zero?',
+            'zipmap',
+          ],
+          tokenizer: {
+            root: [
+              { include: '@whitespace' },
+              [/@numbers/, 'number'],
+              [/@characters/, 'string'],
+              { include: '@string' },
+              [/[()\[\]{}]/, '@brackets'],
+              [/\/#"(?:\.|(?:")|[^"\n])*"\/g/, 'regexp'],
+              [/[#'@^`~]/, 'meta'],
+              [
+                /@qualifiedSymbols/,
+                {
+                  cases: {
+                    '^:.+$': 'constant',
+                    '@specialForms': 'keyword',
+                    '@coreSymbols': 'keyword',
+                    '@constants': 'constant',
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+            ],
+            whitespace: [
+              [/[\s,]+/, 'white'],
+              [/;.*$/, 'comment'],
+              [/\(comment\b/, 'comment', '@comment'],
+            ],
+            comment: [
+              [/\(/, 'comment', '@push'],
+              [/\)/, 'comment', '@pop'],
+              [/[^()]/, 'comment'],
+            ],
+            string: [[/"/, 'string', '@multiLineString']],
+            multiLineString: [
+              [/"/, 'string', '@popall'],
+              [/@escapes/, 'string.escape'],
+              [/./, 'string'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/3585.3585.js

@@ -0,0 +1,164 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [3585],
+  {
+    23585: (e, n, t) => {
+      'use strict';
+      t.r(n), t.d(n, { conf: () => r, language: () => o });
+      var r = {
+          comments: { lineComment: '#' },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          folding: { offSide: !0 },
+        },
+        o = {
+          tokenPostfix: '.yaml',
+          brackets: [
+            { token: 'delimiter.bracket', open: '{', close: '}' },
+            { token: 'delimiter.square', open: '[', close: ']' },
+          ],
+          keywords: [
+            'true',
+            'True',
+            'TRUE',
+            'false',
+            'False',
+            'FALSE',
+            'null',
+            'Null',
+            'Null',
+            '~',
+          ],
+          numberInteger: /(?:0|[+-]?[0-9]+)/,
+          numberFloat: /(?:0|[+-]?[0-9]+)(?:\.[0-9]+)?(?:e[-+][1-9][0-9]*)?/,
+          numberOctal: /0o[0-7]+/,
+          numberHex: /0x[0-9a-fA-F]+/,
+          numberInfinity: /[+-]?\.(?:inf|Inf|INF)/,
+          numberNaN: /\.(?:nan|Nan|NAN)/,
+          numberDate: /\d{4}-\d\d-\d\d([Tt ]\d\d:\d\d:\d\d(\.\d+)?(( ?[+-]\d\d?(:\d\d)?)|Z)?)?/,
+          escapes: /\\(?:[btnfr\\"']|[0-7][0-7]?|[0-3][0-7]{2})/,
+          tokenizer: {
+            root: [
+              { include: '@whitespace' },
+              { include: '@comment' },
+              [/%[^ ]+.*$/, 'meta.directive'],
+              [/---/, 'operators.directivesEnd'],
+              [/\.{3}/, 'operators.documentEnd'],
+              [/[-?:](?= )/, 'operators'],
+              { include: '@anchor' },
+              { include: '@tagHandle' },
+              { include: '@flowCollections' },
+              { include: '@blockStyle' },
+              [/@numberInteger(?![ \t]*\S+)/, 'number'],
+              [/@numberFloat(?![ \t]*\S+)/, 'number.float'],
+              [/@numberOctal(?![ \t]*\S+)/, 'number.octal'],
+              [/@numberHex(?![ \t]*\S+)/, 'number.hex'],
+              [/@numberInfinity(?![ \t]*\S+)/, 'number.infinity'],
+              [/@numberNaN(?![ \t]*\S+)/, 'number.nan'],
+              [/@numberDate(?![ \t]*\S+)/, 'number.date'],
+              [
+                /(".*?"|'.*?'|.*?)([ \t]*)(:)( |$)/,
+                ['type', 'white', 'operators', 'white'],
+              ],
+              { include: '@flowScalars' },
+              [
+                /.+$/,
+                { cases: { '@keywords': 'keyword', '@default': 'string' } },
+              ],
+            ],
+            object: [
+              { include: '@whitespace' },
+              { include: '@comment' },
+              [/\}/, '@brackets', '@pop'],
+              [/,/, 'delimiter.comma'],
+              [/:(?= )/, 'operators'],
+              [/(?:".*?"|'.*?'|[^,\{\[]+?)(?=: )/, 'type'],
+              { include: '@flowCollections' },
+              { include: '@flowScalars' },
+              { include: '@tagHandle' },
+              { include: '@anchor' },
+              { include: '@flowNumber' },
+              [
+                /[^\},]+/,
+                { cases: { '@keywords': 'keyword', '@default': 'string' } },
+              ],
+            ],
+            array: [
+              { include: '@whitespace' },
+              { include: '@comment' },
+              [/\]/, '@brackets', '@pop'],
+              [/,/, 'delimiter.comma'],
+              { include: '@flowCollections' },
+              { include: '@flowScalars' },
+              { include: '@tagHandle' },
+              { include: '@anchor' },
+              { include: '@flowNumber' },
+              [
+                /[^\],]+/,
+                { cases: { '@keywords': 'keyword', '@default': 'string' } },
+              ],
+            ],
+            multiString: [[/^( +).+$/, 'string', '@multiStringContinued.$1']],
+            multiStringContinued: [
+              [
+                /^( *).+$/,
+                {
+                  cases: {
+                    '$1==$S2': 'string',
+                    '@default': { token: '@rematch', next: '@popall' },
+                  },
+                },
+              ],
+            ],
+            whitespace: [[/[ \t\r\n]+/, 'white']],
+            comment: [[/#.*$/, 'comment']],
+            flowCollections: [
+              [/\[/, '@brackets', '@array'],
+              [/\{/, '@brackets', '@object'],
+            ],
+            flowScalars: [
+              [/"([^"\\]|\\.)*$/, 'string.invalid'],
+              [/'([^'\\]|\\.)*$/, 'string.invalid'],
+              [/'[^']*'/, 'string'],
+              [/"/, 'string', '@doubleQuotedString'],
+            ],
+            doubleQuotedString: [
+              [/[^\\"]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/"/, 'string', '@pop'],
+            ],
+            blockStyle: [[/[>|][0-9]*[+-]?$/, 'operators', '@multiString']],
+            flowNumber: [
+              [/@numberInteger(?=[ \t]*[,\]\}])/, 'number'],
+              [/@numberFloat(?=[ \t]*[,\]\}])/, 'number.float'],
+              [/@numberOctal(?=[ \t]*[,\]\}])/, 'number.octal'],
+              [/@numberHex(?=[ \t]*[,\]\}])/, 'number.hex'],
+              [/@numberInfinity(?=[ \t]*[,\]\}])/, 'number.infinity'],
+              [/@numberNaN(?=[ \t]*[,\]\}])/, 'number.nan'],
+              [/@numberDate(?=[ \t]*[,\]\}])/, 'number.date'],
+            ],
+            tagHandle: [[/\![^ ]*/, 'tag']],
+            anchor: [[/[&*][^ ]+/, 'namespace']],
+          },
+        };
+    },
+  },
+]);

docs/3632.3632.js

@@ -0,0 +1,170 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [3632],
+  {
+    48534: (e, t, s) => {
+      'use strict';
+      s.r(t), s.d(t, { conf: () => r, language: () => o });
+      var r = {
+          comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"', notIn: ['string'] },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+          ],
+        },
+        o = {
+          defaultToken: '',
+          tokenPostfix: '.hcl',
+          keywords: [
+            'var',
+            'local',
+            'path',
+            'for_each',
+            'any',
+            'string',
+            'number',
+            'bool',
+            'true',
+            'false',
+            'null',
+            'if ',
+            'else ',
+            'endif ',
+            'for ',
+            'in',
+            'endfor',
+          ],
+          operators: [
+            '=',
+            '>=',
+            '<=',
+            '==',
+            '!=',
+            '+',
+            '-',
+            '*',
+            '/',
+            '%',
+            '&&',
+            '||',
+            '!',
+            '<',
+            '>',
+            '?',
+            '...',
+            ':',
+          ],
+          symbols: /[=><!~?:&|+\-*\/\^%]+/,
+          escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+          terraformFunctions: /(abs|ceil|floor|log|max|min|pow|signum|chomp|format|formatlist|indent|join|lower|regex|regexall|replace|split|strrev|substr|title|trimspace|upper|chunklist|coalesce|coalescelist|compact|concat|contains|distinct|element|flatten|index|keys|length|list|lookup|map|matchkeys|merge|range|reverse|setintersection|setproduct|setunion|slice|sort|transpose|values|zipmap|base64decode|base64encode|base64gzip|csvdecode|jsondecode|jsonencode|urlencode|yamldecode|yamlencode|abspath|dirname|pathexpand|basename|file|fileexists|fileset|filebase64|templatefile|formatdate|timeadd|timestamp|base64sha256|base64sha512|bcrypt|filebase64sha256|filebase64sha512|filemd5|filemd1|filesha256|filesha512|md5|rsadecrypt|sha1|sha256|sha512|uuid|uuidv5|cidrhost|cidrnetmask|cidrsubnet|tobool|tolist|tomap|tonumber|toset|tostring)/,
+          terraformMainBlocks: /(module|data|terraform|resource|provider|variable|output|locals)/,
+          tokenizer: {
+            root: [
+              [
+                /^@terraformMainBlocks([ \t]*)([\w-]+|"[\w-]+"|)([ \t]*)([\w-]+|"[\w-]+"|)([ \t]*)(\{)/,
+                ['type', '', 'string', '', 'string', '', '@brackets'],
+              ],
+              [
+                /(\w+[ \t]+)([ \t]*)([\w-]+|"[\w-]+"|)([ \t]*)([\w-]+|"[\w-]+"|)([ \t]*)(\{)/,
+                ['identifier', '', 'string', '', 'string', '', '@brackets'],
+              ],
+              [
+                /(\w+[ \t]+)([ \t]*)([\w-]+|"[\w-]+"|)([ \t]*)([\w-]+|"[\w-]+"|)(=)(\{)/,
+                ['identifier', '', 'string', '', 'operator', '', '@brackets'],
+              ],
+              { include: '@terraform' },
+            ],
+            terraform: [
+              [/@terraformFunctions(\()/, ['type', '@brackets']],
+              [
+                /[a-zA-Z_]\w*-*/,
+                {
+                  cases: {
+                    '@keywords': { token: 'keyword.$0' },
+                    '@default': 'variable',
+                  },
+                },
+              ],
+              { include: '@whitespace' },
+              { include: '@heredoc' },
+              [/[{}()\[\]]/, '@brackets'],
+              [/[<>](?!@symbols)/, '@brackets'],
+              [
+                /@symbols/,
+                { cases: { '@operators': 'operator', '@default': '' } },
+              ],
+              [/\d*\d+[eE]([\-+]?\d+)?/, 'number.float'],
+              [/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
+              [/\d[\d']*/, 'number'],
+              [/\d/, 'number'],
+              [/[;,.]/, 'delimiter'],
+              [/"/, 'string', '@string'],
+              [/'/, 'invalid'],
+            ],
+            heredoc: [
+              [
+                /<<[-]*\s*["]?([\w\-]+)["]?/,
+                { token: 'string.heredoc.delimiter', next: '@heredocBody.$1' },
+              ],
+            ],
+            heredocBody: [
+              [
+                /^([\w\-]+)$/,
+                {
+                  cases: {
+                    '$1==$S2': [
+                      { token: 'string.heredoc.delimiter', next: '@popall' },
+                    ],
+                    '@default': 'string.heredoc',
+                  },
+                },
+              ],
+              [/./, 'string.heredoc'],
+            ],
+            whitespace: [
+              [/[ \t\r\n]+/, ''],
+              [/\/\*/, 'comment', '@comment'],
+              [/\/\/.*$/, 'comment'],
+              [/#.*$/, 'comment'],
+            ],
+            comment: [
+              [/[^\/*]+/, 'comment'],
+              [/\*\//, 'comment', '@pop'],
+              [/[\/*]/, 'comment'],
+            ],
+            string: [
+              [/\$\{/, { token: 'delimiter', next: '@stringExpression' }],
+              [/[^\\"\$]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/"/, 'string', '@popall'],
+            ],
+            stringInsideExpression: [
+              [/[^\\"]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/"/, 'string', '@pop'],
+            ],
+            stringExpression: [
+              [/\}/, { token: 'delimiter', next: '@pop' }],
+              [/"/, 'string', '@stringInsideExpression'],
+              { include: '@terraform' },
+            ],
+          },
+        };
+    },
+  },
+]);

docs/3919.3919.js

@@ -0,0 +1,183 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [3919],
+  {
+    63919: (e, t, n) => {
+      'use strict';
+      n.r(t), n.d(t, { conf: () => o, language: () => s });
+      var o = {
+          comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+            ['<', '>'],
+          ],
+          autoClosingPairs: [
+            { open: '"', close: '"', notIn: ['string', 'comment'] },
+            { open: '{', close: '}', notIn: ['string', 'comment'] },
+            { open: '[', close: ']', notIn: ['string', 'comment'] },
+            { open: '(', close: ')', notIn: ['string', 'comment'] },
+          ],
+        },
+        s = {
+          defaultToken: '',
+          tokenPostfix: '.aes',
+          brackets: [
+            { token: 'delimiter.curly', open: '{', close: '}' },
+            { token: 'delimiter.parenthesis', open: '(', close: ')' },
+            { token: 'delimiter.square', open: '[', close: ']' },
+            { token: 'delimiter.angle', open: '<', close: '>' },
+          ],
+          keywords: [
+            'contract',
+            'library',
+            'entrypoint',
+            'function',
+            'stateful',
+            'state',
+            'hash',
+            'signature',
+            'tuple',
+            'list',
+            'address',
+            'string',
+            'bool',
+            'int',
+            'record',
+            'datatype',
+            'type',
+            'option',
+            'oracle',
+            'oracle_query',
+            'Call',
+            'Bits',
+            'Bytes',
+            'Oracle',
+            'String',
+            'Crypto',
+            'Address',
+            'Auth',
+            'Chain',
+            'None',
+            'Some',
+            'bits',
+            'bytes',
+            'event',
+            'let',
+            'map',
+            'private',
+            'public',
+            'true',
+            'false',
+            'var',
+            'if',
+            'else',
+            'throw',
+          ],
+          operators: [
+            '=',
+            '>',
+            '<',
+            '!',
+            '~',
+            '?',
+            '::',
+            ':',
+            '==',
+            '<=',
+            '>=',
+            '!=',
+            '&&',
+            '||',
+            '++',
+            '--',
+            '+',
+            '-',
+            '*',
+            '/',
+            '&',
+            '|',
+            '^',
+            '%',
+            '<<',
+            '>>',
+            '>>>',
+            '+=',
+            '-=',
+            '*=',
+            '/=',
+            '&=',
+            '|=',
+            '^=',
+            '%=',
+            '<<=',
+            '>>=',
+            '>>>=',
+          ],
+          symbols: /[=><!~?:&|+\-*\/\^%]+/,
+          escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+          integersuffix: /(ll|LL|u|U|l|L)?(ll|LL|u|U|l|L)?/,
+          floatsuffix: /[fFlL]?/,
+          tokenizer: {
+            root: [
+              [
+                /[a-zA-Z_]\w*/,
+                {
+                  cases: {
+                    '@keywords': { token: 'keyword.$0' },
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+              { include: '@whitespace' },
+              [/\[\[.*\]\]/, 'annotation'],
+              [/^\s*#\w+/, 'keyword'],
+              [/int\d*/, 'keyword'],
+              [/[{}()\[\]]/, '@brackets'],
+              [/[<>](?!@symbols)/, '@brackets'],
+              [
+                /@symbols/,
+                { cases: { '@operators': 'delimiter', '@default': '' } },
+              ],
+              [/\d*\d+[eE]([\-+]?\d+)?(@floatsuffix)/, 'number.float'],
+              [/\d*\.\d+([eE][\-+]?\d+)?(@floatsuffix)/, 'number.float'],
+              [/0[xX][0-9a-fA-F']*[0-9a-fA-F](@integersuffix)/, 'number.hex'],
+              [/0[0-7']*[0-7](@integersuffix)/, 'number.octal'],
+              [/0[bB][0-1']*[0-1](@integersuffix)/, 'number.binary'],
+              [/\d[\d']*\d(@integersuffix)/, 'number'],
+              [/\d(@integersuffix)/, 'number'],
+              [/[;,.]/, 'delimiter'],
+              [/"([^"\\]|\\.)*$/, 'string.invalid'],
+              [/"/, 'string', '@string'],
+              [/'[^\\']'/, 'string'],
+              [/(')(@escapes)(')/, ['string', 'string.escape', 'string']],
+              [/'/, 'string.invalid'],
+            ],
+            whitespace: [
+              [/[ \t\r\n]+/, ''],
+              [/\/\*\*(?!\/)/, 'comment.doc', '@doccomment'],
+              [/\/\*/, 'comment', '@comment'],
+              [/\/\/.*$/, 'comment'],
+            ],
+            comment: [
+              [/[^\/*]+/, 'comment'],
+              [/\*\//, 'comment', '@pop'],
+              [/[\/*]/, 'comment'],
+            ],
+            doccomment: [
+              [/[^\/*]+/, 'comment.doc'],
+              [/\*\//, 'comment.doc', '@pop'],
+              [/[\/*]/, 'comment.doc'],
+            ],
+            string: [
+              [/[^\\"]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/"/, 'string', '@pop'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/4129.4129.js

@@ -0,0 +1,97 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [4129],
+  {
+    84129: (e, s, o) => {
+      'use strict';
+      o.r(s), o.d(s, { conf: () => t, language: () => n });
+      var t = {
+          comments: { lineComment: 'REM' },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+          ],
+          surroundingPairs: [
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+          ],
+          folding: {
+            markers: {
+              start: new RegExp('^\\s*(::\\s*|REM\\s+)#region'),
+              end: new RegExp('^\\s*(::\\s*|REM\\s+)#endregion'),
+            },
+          },
+        },
+        n = {
+          defaultToken: '',
+          ignoreCase: !0,
+          tokenPostfix: '.bat',
+          brackets: [
+            { token: 'delimiter.bracket', open: '{', close: '}' },
+            { token: 'delimiter.parenthesis', open: '(', close: ')' },
+            { token: 'delimiter.square', open: '[', close: ']' },
+          ],
+          keywords: /call|defined|echo|errorlevel|exist|for|goto|if|pause|set|shift|start|title|not|pushd|popd/,
+          symbols: /[=><!~?&|+\-*\/\^;\.,]+/,
+          escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+          tokenizer: {
+            root: [
+              [/^(\s*)(rem(?:\s.*|))$/, ['', 'comment']],
+              [
+                /(\@?)(@keywords)(?!\w)/,
+                [{ token: 'keyword' }, { token: 'keyword.$2' }],
+              ],
+              [/[ \t\r\n]+/, ''],
+              [/setlocal(?!\w)/, 'keyword.tag-setlocal'],
+              [/endlocal(?!\w)/, 'keyword.tag-setlocal'],
+              [/[a-zA-Z_]\w*/, ''],
+              [/:\w*/, 'metatag'],
+              [/%[^%]+%/, 'variable'],
+              [/%%[\w]+(?!\w)/, 'variable'],
+              [/[{}()\[\]]/, '@brackets'],
+              [/@symbols/, 'delimiter'],
+              [/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
+              [/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/, 'number.hex'],
+              [/\d+/, 'number'],
+              [/[;,.]/, 'delimiter'],
+              [/"/, 'string', '@string."'],
+              [/'/, 'string', "@string.'"],
+            ],
+            string: [
+              [
+                /[^\\"'%]+/,
+                {
+                  cases: {
+                    '@eos': { token: 'string', next: '@popall' },
+                    '@default': 'string',
+                  },
+                },
+              ],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/%[\w ]+%/, 'variable'],
+              [/%%[\w]+(?!\w)/, 'variable'],
+              [
+                /["']/,
+                {
+                  cases: {
+                    '$#==$S2': { token: 'string', next: '@pop' },
+                    '@default': 'string',
+                  },
+                },
+              ],
+              [/$/, 'string', '@popall'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/4368.4368.js

@@ -0,0 +1,245 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [4368],
+  {
+    84368: (e, i, t) => {
+      'use strict';
+      t.r(i), t.d(i, { conf: () => n, language: () => s });
+      var n = {
+          wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+          comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+            { open: '<', close: '>' },
+          ],
+          folding: {
+            markers: {
+              start: new RegExp(
+                '^\\s*//\\s*(?:(?:#?region\\b)|(?:<editor-fold\\b))'
+              ),
+              end: new RegExp(
+                '^\\s*//\\s*(?:(?:#?endregion\\b)|(?:</editor-fold>))'
+              ),
+            },
+          },
+        },
+        s = {
+          defaultToken: '',
+          tokenPostfix: '.kt',
+          keywords: [
+            'as',
+            'as?',
+            'break',
+            'class',
+            'continue',
+            'do',
+            'else',
+            'false',
+            'for',
+            'fun',
+            'if',
+            'in',
+            '!in',
+            'interface',
+            'is',
+            '!is',
+            'null',
+            'object',
+            'package',
+            'return',
+            'super',
+            'this',
+            'throw',
+            'true',
+            'try',
+            'typealias',
+            'val',
+            'var',
+            'when',
+            'while',
+            'by',
+            'catch',
+            'constructor',
+            'delegate',
+            'dynamic',
+            'field',
+            'file',
+            'finally',
+            'get',
+            'import',
+            'init',
+            'param',
+            'property',
+            'receiver',
+            'set',
+            'setparam',
+            'where',
+            'actual',
+            'abstract',
+            'annotation',
+            'companion',
+            'const',
+            'crossinline',
+            'data',
+            'enum',
+            'expect',
+            'external',
+            'final',
+            'infix',
+            'inline',
+            'inner',
+            'internal',
+            'lateinit',
+            'noinline',
+            'open',
+            'operator',
+            'out',
+            'override',
+            'private',
+            'protected',
+            'public',
+            'reified',
+            'sealed',
+            'suspend',
+            'tailrec',
+            'vararg',
+            'field',
+            'it',
+          ],
+          operators: [
+            '+',
+            '-',
+            '*',
+            '/',
+            '%',
+            '=',
+            '+=',
+            '-=',
+            '*=',
+            '/=',
+            '%=',
+            '++',
+            '--',
+            '&&',
+            '||',
+            '!',
+            '==',
+            '!=',
+            '===',
+            '!==',
+            '>',
+            '<',
+            '<=',
+            '>=',
+            '[',
+            ']',
+            '!!',
+            '?.',
+            '?:',
+            '::',
+            '..',
+            ':',
+            '?',
+            '->',
+            '@',
+            ';',
+            '$',
+            '_',
+          ],
+          symbols: /[=><!~?:&|+\-*\/\^%]+/,
+          escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+          digits: /\d+(_+\d+)*/,
+          octaldigits: /[0-7]+(_+[0-7]+)*/,
+          binarydigits: /[0-1]+(_+[0-1]+)*/,
+          hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+          tokenizer: {
+            root: [
+              [/[A-Z][\w\$]*/, 'type.identifier'],
+              [
+                /[a-zA-Z_$][\w$]*/,
+                {
+                  cases: {
+                    '@keywords': { token: 'keyword.$0' },
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+              { include: '@whitespace' },
+              [/[{}()\[\]]/, '@brackets'],
+              [/[<>](?!@symbols)/, '@brackets'],
+              [
+                /@symbols/,
+                { cases: { '@operators': 'delimiter', '@default': '' } },
+              ],
+              [/@\s*[a-zA-Z_\$][\w\$]*/, 'annotation'],
+              [/(@digits)[eE]([\-+]?(@digits))?[fFdD]?/, 'number.float'],
+              [
+                /(@digits)\.(@digits)([eE][\-+]?(@digits))?[fFdD]?/,
+                'number.float',
+              ],
+              [/0[xX](@hexdigits)[Ll]?/, 'number.hex'],
+              [/0(@octaldigits)[Ll]?/, 'number.octal'],
+              [/0[bB](@binarydigits)[Ll]?/, 'number.binary'],
+              [/(@digits)[fFdD]/, 'number.float'],
+              [/(@digits)[lL]?/, 'number'],
+              [/[;,.]/, 'delimiter'],
+              [/"([^"\\]|\\.)*$/, 'string.invalid'],
+              [/"""/, 'string', '@multistring'],
+              [/"/, 'string', '@string'],
+              [/'[^\\']'/, 'string'],
+              [/(')(@escapes)(')/, ['string', 'string.escape', 'string']],
+              [/'/, 'string.invalid'],
+            ],
+            whitespace: [
+              [/[ \t\r\n]+/, ''],
+              [/\/\*\*(?!\/)/, 'comment.doc', '@javadoc'],
+              [/\/\*/, 'comment', '@comment'],
+              [/\/\/.*$/, 'comment'],
+            ],
+            comment: [
+              [/[^\/*]+/, 'comment'],
+              [/\/\*/, 'comment', '@comment'],
+              [/\*\//, 'comment', '@pop'],
+              [/[\/*]/, 'comment'],
+            ],
+            javadoc: [
+              [/[^\/*]+/, 'comment.doc'],
+              [/\/\*/, 'comment.doc', '@push'],
+              [/\/\*/, 'comment.doc.invalid'],
+              [/\*\//, 'comment.doc', '@pop'],
+              [/[\/*]/, 'comment.doc'],
+            ],
+            string: [
+              [/[^\\"]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/"/, 'string', '@pop'],
+            ],
+            multistring: [
+              [/[^\\"]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/"""/, 'string', '@pop'],
+              [/./, 'string'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/4386.4386.js

@@ -0,0 +1,321 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [4386],
+  {
+    54386: (e, t, s) => {
+      'use strict';
+      s.r(t), s.d(t, { conf: () => o, language: () => i });
+      var o = {
+          wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+          comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+            { open: '<', close: '>' },
+          ],
+          folding: {
+            markers: {
+              start: new RegExp(
+                '^\\s*//\\s*(?:(?:#?region\\b)|(?:<editor-fold\\b))'
+              ),
+              end: new RegExp(
+                '^\\s*//\\s*(?:(?:#?endregion\\b)|(?:</editor-fold>))'
+              ),
+            },
+          },
+        },
+        n = [];
+      [
+        'abstract',
+        'activate',
+        'and',
+        'any',
+        'array',
+        'as',
+        'asc',
+        'assert',
+        'autonomous',
+        'begin',
+        'bigdecimal',
+        'blob',
+        'boolean',
+        'break',
+        'bulk',
+        'by',
+        'case',
+        'cast',
+        'catch',
+        'char',
+        'class',
+        'collect',
+        'commit',
+        'const',
+        'continue',
+        'convertcurrency',
+        'decimal',
+        'default',
+        'delete',
+        'desc',
+        'do',
+        'double',
+        'else',
+        'end',
+        'enum',
+        'exception',
+        'exit',
+        'export',
+        'extends',
+        'false',
+        'final',
+        'finally',
+        'float',
+        'for',
+        'from',
+        'future',
+        'get',
+        'global',
+        'goto',
+        'group',
+        'having',
+        'hint',
+        'if',
+        'implements',
+        'import',
+        'in',
+        'inner',
+        'insert',
+        'instanceof',
+        'int',
+        'interface',
+        'into',
+        'join',
+        'last_90_days',
+        'last_month',
+        'last_n_days',
+        'last_week',
+        'like',
+        'limit',
+        'list',
+        'long',
+        'loop',
+        'map',
+        'merge',
+        'native',
+        'new',
+        'next_90_days',
+        'next_month',
+        'next_n_days',
+        'next_week',
+        'not',
+        'null',
+        'nulls',
+        'number',
+        'object',
+        'of',
+        'on',
+        'or',
+        'outer',
+        'override',
+        'package',
+        'parallel',
+        'pragma',
+        'private',
+        'protected',
+        'public',
+        'retrieve',
+        'return',
+        'returning',
+        'rollback',
+        'savepoint',
+        'search',
+        'select',
+        'set',
+        'short',
+        'sort',
+        'stat',
+        'static',
+        'strictfp',
+        'super',
+        'switch',
+        'synchronized',
+        'system',
+        'testmethod',
+        'then',
+        'this',
+        'this_month',
+        'this_week',
+        'throw',
+        'throws',
+        'today',
+        'tolabel',
+        'tomorrow',
+        'transaction',
+        'transient',
+        'trigger',
+        'true',
+        'try',
+        'type',
+        'undelete',
+        'update',
+        'upsert',
+        'using',
+        'virtual',
+        'void',
+        'volatile',
+        'webservice',
+        'when',
+        'where',
+        'while',
+        'yesterday',
+      ].forEach(function (e) {
+        n.push(e),
+          n.push(e.toUpperCase()),
+          n.push(
+            (function (e) {
+              return e.charAt(0).toUpperCase() + e.substr(1);
+            })(e)
+          );
+      });
+      var i = {
+        defaultToken: '',
+        tokenPostfix: '.apex',
+        keywords: n,
+        operators: [
+          '=',
+          '>',
+          '<',
+          '!',
+          '~',
+          '?',
+          ':',
+          '==',
+          '<=',
+          '>=',
+          '!=',
+          '&&',
+          '||',
+          '++',
+          '--',
+          '+',
+          '-',
+          '*',
+          '/',
+          '&',
+          '|',
+          '^',
+          '%',
+          '<<',
+          '>>',
+          '>>>',
+          '+=',
+          '-=',
+          '*=',
+          '/=',
+          '&=',
+          '|=',
+          '^=',
+          '%=',
+          '<<=',
+          '>>=',
+          '>>>=',
+        ],
+        symbols: /[=><!~?:&|+\-*\/\^%]+/,
+        escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+        digits: /\d+(_+\d+)*/,
+        octaldigits: /[0-7]+(_+[0-7]+)*/,
+        binarydigits: /[0-1]+(_+[0-1]+)*/,
+        hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+        tokenizer: {
+          root: [
+            [
+              /[a-z_$][\w$]*/,
+              {
+                cases: {
+                  '@keywords': { token: 'keyword.$0' },
+                  '@default': 'identifier',
+                },
+              },
+            ],
+            [
+              /[A-Z][\w\$]*/,
+              {
+                cases: {
+                  '@keywords': { token: 'keyword.$0' },
+                  '@default': 'type.identifier',
+                },
+              },
+            ],
+            { include: '@whitespace' },
+            [/[{}()\[\]]/, '@brackets'],
+            [/[<>](?!@symbols)/, '@brackets'],
+            [
+              /@symbols/,
+              { cases: { '@operators': 'delimiter', '@default': '' } },
+            ],
+            [/@\s*[a-zA-Z_\$][\w\$]*/, 'annotation'],
+            [/(@digits)[eE]([\-+]?(@digits))?[fFdD]?/, 'number.float'],
+            [
+              /(@digits)\.(@digits)([eE][\-+]?(@digits))?[fFdD]?/,
+              'number.float',
+            ],
+            [/(@digits)[fFdD]/, 'number.float'],
+            [/(@digits)[lL]?/, 'number'],
+            [/[;,.]/, 'delimiter'],
+            [/"([^"\\]|\\.)*$/, 'string.invalid'],
+            [/'([^'\\]|\\.)*$/, 'string.invalid'],
+            [/"/, 'string', '@string."'],
+            [/'/, 'string', "@string.'"],
+            [/'[^\\']'/, 'string'],
+            [/(')(@escapes)(')/, ['string', 'string.escape', 'string']],
+            [/'/, 'string.invalid'],
+          ],
+          whitespace: [
+            [/[ \t\r\n]+/, ''],
+            [/\/\*\*(?!\/)/, 'comment.doc', '@apexdoc'],
+            [/\/\*/, 'comment', '@comment'],
+            [/\/\/.*$/, 'comment'],
+          ],
+          comment: [
+            [/[^\/*]+/, 'comment'],
+            [/\*\//, 'comment', '@pop'],
+            [/[\/*]/, 'comment'],
+          ],
+          apexdoc: [
+            [/[^\/*]+/, 'comment.doc'],
+            [/\*\//, 'comment.doc', '@pop'],
+            [/[\/*]/, 'comment.doc'],
+          ],
+          string: [
+            [/[^\\"']+/, 'string'],
+            [/@escapes/, 'string.escape'],
+            [/\\./, 'string.escape.invalid'],
+            [
+              /["']/,
+              {
+                cases: {
+                  '$#==$S2': { token: 'string', next: '@pop' },
+                  '@default': 'string',
+                },
+              },
+            ],
+          ],
+        },
+      };
+    },
+  },
+]);

docs/4407.4407.js

@@ -0,0 +1,912 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [4407],
+  {
+    94407: (e, t, a) => {
+      'use strict';
+      a.r(t), a.d(t, { conf: () => n, language: () => i });
+      var n = {
+          comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+          brackets: [
+            ['[', ']'],
+            ['(', ')'],
+            ['{', '}'],
+          ],
+          autoClosingPairs: [
+            {
+              open: '"',
+              close: '"',
+              notIn: ['string', 'comment', 'identifier'],
+            },
+            {
+              open: '[',
+              close: ']',
+              notIn: ['string', 'comment', 'identifier'],
+            },
+            {
+              open: '(',
+              close: ')',
+              notIn: ['string', 'comment', 'identifier'],
+            },
+            {
+              open: '{',
+              close: '}',
+              notIn: ['string', 'comment', 'identifier'],
+            },
+          ],
+        },
+        i = {
+          defaultToken: '',
+          tokenPostfix: '.pq',
+          ignoreCase: !1,
+          brackets: [
+            { open: '[', close: ']', token: 'delimiter.square' },
+            { open: '{', close: '}', token: 'delimiter.brackets' },
+            { open: '(', close: ')', token: 'delimiter.parenthesis' },
+          ],
+          operatorKeywords: ['and', 'not', 'or'],
+          keywords: [
+            'as',
+            'each',
+            'else',
+            'error',
+            'false',
+            'if',
+            'in',
+            'is',
+            'let',
+            'meta',
+            'otherwise',
+            'section',
+            'shared',
+            'then',
+            'true',
+            'try',
+            'type',
+          ],
+          constructors: [
+            '#binary',
+            '#date',
+            '#datetime',
+            '#datetimezone',
+            '#duration',
+            '#table',
+            '#time',
+          ],
+          constants: ['#infinity', '#nan', '#sections', '#shared'],
+          typeKeywords: [
+            'action',
+            'any',
+            'anynonnull',
+            'none',
+            'null',
+            'logical',
+            'number',
+            'time',
+            'date',
+            'datetime',
+            'datetimezone',
+            'duration',
+            'text',
+            'binary',
+            'list',
+            'record',
+            'table',
+            'function',
+          ],
+          builtinFunctions: [
+            'Access.Database',
+            'Action.Return',
+            'Action.Sequence',
+            'Action.Try',
+            'ActiveDirectory.Domains',
+            'AdoDotNet.DataSource',
+            'AdoDotNet.Query',
+            'AdobeAnalytics.Cubes',
+            'AnalysisServices.Database',
+            'AnalysisServices.Databases',
+            'AzureStorage.BlobContents',
+            'AzureStorage.Blobs',
+            'AzureStorage.Tables',
+            'Binary.Buffer',
+            'Binary.Combine',
+            'Binary.Compress',
+            'Binary.Decompress',
+            'Binary.End',
+            'Binary.From',
+            'Binary.FromList',
+            'Binary.FromText',
+            'Binary.InferContentType',
+            'Binary.Length',
+            'Binary.ToList',
+            'Binary.ToText',
+            'BinaryFormat.7BitEncodedSignedInteger',
+            'BinaryFormat.7BitEncodedUnsignedInteger',
+            'BinaryFormat.Binary',
+            'BinaryFormat.Byte',
+            'BinaryFormat.ByteOrder',
+            'BinaryFormat.Choice',
+            'BinaryFormat.Decimal',
+            'BinaryFormat.Double',
+            'BinaryFormat.Group',
+            'BinaryFormat.Length',
+            'BinaryFormat.List',
+            'BinaryFormat.Null',
+            'BinaryFormat.Record',
+            'BinaryFormat.SignedInteger16',
+            'BinaryFormat.SignedInteger32',
+            'BinaryFormat.SignedInteger64',
+            'BinaryFormat.Single',
+            'BinaryFormat.Text',
+            'BinaryFormat.Transform',
+            'BinaryFormat.UnsignedInteger16',
+            'BinaryFormat.UnsignedInteger32',
+            'BinaryFormat.UnsignedInteger64',
+            'Byte.From',
+            'Character.FromNumber',
+            'Character.ToNumber',
+            'Combiner.CombineTextByDelimiter',
+            'Combiner.CombineTextByEachDelimiter',
+            'Combiner.CombineTextByLengths',
+            'Combiner.CombineTextByPositions',
+            'Combiner.CombineTextByRanges',
+            'Comparer.Equals',
+            'Comparer.FromCulture',
+            'Comparer.Ordinal',
+            'Comparer.OrdinalIgnoreCase',
+            'Csv.Document',
+            'Cube.AddAndExpandDimensionColumn',
+            'Cube.AddMeasureColumn',
+            'Cube.ApplyParameter',
+            'Cube.AttributeMemberId',
+            'Cube.AttributeMemberProperty',
+            'Cube.CollapseAndRemoveColumns',
+            'Cube.Dimensions',
+            'Cube.DisplayFolders',
+            'Cube.Measures',
+            'Cube.Parameters',
+            'Cube.Properties',
+            'Cube.PropertyKey',
+            'Cube.ReplaceDimensions',
+            'Cube.Transform',
+            'Currency.From',
+            'DB2.Database',
+            'Date.AddDays',
+            'Date.AddMonths',
+            'Date.AddQuarters',
+            'Date.AddWeeks',
+            'Date.AddYears',
+            'Date.Day',
+            'Date.DayOfWeek',
+            'Date.DayOfWeekName',
+            'Date.DayOfYear',
+            'Date.DaysInMonth',
+            'Date.EndOfDay',
+            'Date.EndOfMonth',
+            'Date.EndOfQuarter',
+            'Date.EndOfWeek',
+            'Date.EndOfYear',
+            'Date.From',
+            'Date.FromText',
+            'Date.IsInCurrentDay',
+            'Date.IsInCurrentMonth',
+            'Date.IsInCurrentQuarter',
+            'Date.IsInCurrentWeek',
+            'Date.IsInCurrentYear',
+            'Date.IsInNextDay',
+            'Date.IsInNextMonth',
+            'Date.IsInNextNDays',
+            'Date.IsInNextNMonths',
+            'Date.IsInNextNQuarters',
+            'Date.IsInNextNWeeks',
+            'Date.IsInNextNYears',
+            'Date.IsInNextQuarter',
+            'Date.IsInNextWeek',
+            'Date.IsInNextYear',
+            'Date.IsInPreviousDay',
+            'Date.IsInPreviousMonth',
+            'Date.IsInPreviousNDays',
+            'Date.IsInPreviousNMonths',
+            'Date.IsInPreviousNQuarters',
+            'Date.IsInPreviousNWeeks',
+            'Date.IsInPreviousNYears',
+            'Date.IsInPreviousQuarter',
+            'Date.IsInPreviousWeek',
+            'Date.IsInPreviousYear',
+            'Date.IsInYearToDate',
+            'Date.IsLeapYear',
+            'Date.Month',
+            'Date.MonthName',
+            'Date.QuarterOfYear',
+            'Date.StartOfDay',
+            'Date.StartOfMonth',
+            'Date.StartOfQuarter',
+            'Date.StartOfWeek',
+            'Date.StartOfYear',
+            'Date.ToRecord',
+            'Date.ToText',
+            'Date.WeekOfMonth',
+            'Date.WeekOfYear',
+            'Date.Year',
+            'DateTime.AddZone',
+            'DateTime.Date',
+            'DateTime.FixedLocalNow',
+            'DateTime.From',
+            'DateTime.FromFileTime',
+            'DateTime.FromText',
+            'DateTime.IsInCurrentHour',
+            'DateTime.IsInCurrentMinute',
+            'DateTime.IsInCurrentSecond',
+            'DateTime.IsInNextHour',
+            'DateTime.IsInNextMinute',
+            'DateTime.IsInNextNHours',
+            'DateTime.IsInNextNMinutes',
+            'DateTime.IsInNextNSeconds',
+            'DateTime.IsInNextSecond',
+            'DateTime.IsInPreviousHour',
+            'DateTime.IsInPreviousMinute',
+            'DateTime.IsInPreviousNHours',
+            'DateTime.IsInPreviousNMinutes',
+            'DateTime.IsInPreviousNSeconds',
+            'DateTime.IsInPreviousSecond',
+            'DateTime.LocalNow',
+            'DateTime.Time',
+            'DateTime.ToRecord',
+            'DateTime.ToText',
+            'DateTimeZone.FixedLocalNow',
+            'DateTimeZone.FixedUtcNow',
+            'DateTimeZone.From',
+            'DateTimeZone.FromFileTime',
+            'DateTimeZone.FromText',
+            'DateTimeZone.LocalNow',
+            'DateTimeZone.RemoveZone',
+            'DateTimeZone.SwitchZone',
+            'DateTimeZone.ToLocal',
+            'DateTimeZone.ToRecord',
+            'DateTimeZone.ToText',
+            'DateTimeZone.ToUtc',
+            'DateTimeZone.UtcNow',
+            'DateTimeZone.ZoneHours',
+            'DateTimeZone.ZoneMinutes',
+            'Decimal.From',
+            'Diagnostics.ActivityId',
+            'Diagnostics.Trace',
+            'DirectQueryCapabilities.From',
+            'Double.From',
+            'Duration.Days',
+            'Duration.From',
+            'Duration.FromText',
+            'Duration.Hours',
+            'Duration.Minutes',
+            'Duration.Seconds',
+            'Duration.ToRecord',
+            'Duration.ToText',
+            'Duration.TotalDays',
+            'Duration.TotalHours',
+            'Duration.TotalMinutes',
+            'Duration.TotalSeconds',
+            'Embedded.Value',
+            'Error.Record',
+            'Excel.CurrentWorkbook',
+            'Excel.Workbook',
+            'Exchange.Contents',
+            'Expression.Constant',
+            'Expression.Evaluate',
+            'Expression.Identifier',
+            'Facebook.Graph',
+            'File.Contents',
+            'Folder.Contents',
+            'Folder.Files',
+            'Function.From',
+            'Function.Invoke',
+            'Function.InvokeAfter',
+            'Function.IsDataSource',
+            'GoogleAnalytics.Accounts',
+            'Guid.From',
+            'HdInsight.Containers',
+            'HdInsight.Contents',
+            'HdInsight.Files',
+            'Hdfs.Contents',
+            'Hdfs.Files',
+            'Informix.Database',
+            'Int16.From',
+            'Int32.From',
+            'Int64.From',
+            'Int8.From',
+            'ItemExpression.From',
+            'Json.Document',
+            'Json.FromValue',
+            'Lines.FromBinary',
+            'Lines.FromText',
+            'Lines.ToBinary',
+            'Lines.ToText',
+            'List.Accumulate',
+            'List.AllTrue',
+            'List.Alternate',
+            'List.AnyTrue',
+            'List.Average',
+            'List.Buffer',
+            'List.Combine',
+            'List.Contains',
+            'List.ContainsAll',
+            'List.ContainsAny',
+            'List.Count',
+            'List.Covariance',
+            'List.DateTimeZones',
+            'List.DateTimes',
+            'List.Dates',
+            'List.Difference',
+            'List.Distinct',
+            'List.Durations',
+            'List.FindText',
+            'List.First',
+            'List.FirstN',
+            'List.Generate',
+            'List.InsertRange',
+            'List.Intersect',
+            'List.IsDistinct',
+            'List.IsEmpty',
+            'List.Last',
+            'List.LastN',
+            'List.MatchesAll',
+            'List.MatchesAny',
+            'List.Max',
+            'List.MaxN',
+            'List.Median',
+            'List.Min',
+            'List.MinN',
+            'List.Mode',
+            'List.Modes',
+            'List.NonNullCount',
+            'List.Numbers',
+            'List.PositionOf',
+            'List.PositionOfAny',
+            'List.Positions',
+            'List.Product',
+            'List.Random',
+            'List.Range',
+            'List.RemoveFirstN',
+            'List.RemoveItems',
+            'List.RemoveLastN',
+            'List.RemoveMatchingItems',
+            'List.RemoveNulls',
+            'List.RemoveRange',
+            'List.Repeat',
+            'List.ReplaceMatchingItems',
+            'List.ReplaceRange',
+            'List.ReplaceValue',
+            'List.Reverse',
+            'List.Select',
+            'List.Single',
+            'List.SingleOrDefault',
+            'List.Skip',
+            'List.Sort',
+            'List.StandardDeviation',
+            'List.Sum',
+            'List.Times',
+            'List.Transform',
+            'List.TransformMany',
+            'List.Union',
+            'List.Zip',
+            'Logical.From',
+            'Logical.FromText',
+            'Logical.ToText',
+            'MQ.Queue',
+            'MySQL.Database',
+            'Number.Abs',
+            'Number.Acos',
+            'Number.Asin',
+            'Number.Atan',
+            'Number.Atan2',
+            'Number.BitwiseAnd',
+            'Number.BitwiseNot',
+            'Number.BitwiseOr',
+            'Number.BitwiseShiftLeft',
+            'Number.BitwiseShiftRight',
+            'Number.BitwiseXor',
+            'Number.Combinations',
+            'Number.Cos',
+            'Number.Cosh',
+            'Number.Exp',
+            'Number.Factorial',
+            'Number.From',
+            'Number.FromText',
+            'Number.IntegerDivide',
+            'Number.IsEven',
+            'Number.IsNaN',
+            'Number.IsOdd',
+            'Number.Ln',
+            'Number.Log',
+            'Number.Log10',
+            'Number.Mod',
+            'Number.Permutations',
+            'Number.Power',
+            'Number.Random',
+            'Number.RandomBetween',
+            'Number.Round',
+            'Number.RoundAwayFromZero',
+            'Number.RoundDown',
+            'Number.RoundTowardZero',
+            'Number.RoundUp',
+            'Number.Sign',
+            'Number.Sin',
+            'Number.Sinh',
+            'Number.Sqrt',
+            'Number.Tan',
+            'Number.Tanh',
+            'Number.ToText',
+            'OData.Feed',
+            'Odbc.DataSource',
+            'Odbc.Query',
+            'OleDb.DataSource',
+            'OleDb.Query',
+            'Oracle.Database',
+            'Percentage.From',
+            'PostgreSQL.Database',
+            'RData.FromBinary',
+            'Record.AddField',
+            'Record.Combine',
+            'Record.Field',
+            'Record.FieldCount',
+            'Record.FieldNames',
+            'Record.FieldOrDefault',
+            'Record.FieldValues',
+            'Record.FromList',
+            'Record.FromTable',
+            'Record.HasFields',
+            'Record.RemoveFields',
+            'Record.RenameFields',
+            'Record.ReorderFields',
+            'Record.SelectFields',
+            'Record.ToList',
+            'Record.ToTable',
+            'Record.TransformFields',
+            'Replacer.ReplaceText',
+            'Replacer.ReplaceValue',
+            'RowExpression.Column',
+            'RowExpression.From',
+            'Salesforce.Data',
+            'Salesforce.Reports',
+            'SapBusinessWarehouse.Cubes',
+            'SapHana.Database',
+            'SharePoint.Contents',
+            'SharePoint.Files',
+            'SharePoint.Tables',
+            'Single.From',
+            'Soda.Feed',
+            'Splitter.SplitByNothing',
+            'Splitter.SplitTextByAnyDelimiter',
+            'Splitter.SplitTextByDelimiter',
+            'Splitter.SplitTextByEachDelimiter',
+            'Splitter.SplitTextByLengths',
+            'Splitter.SplitTextByPositions',
+            'Splitter.SplitTextByRanges',
+            'Splitter.SplitTextByRepeatedLengths',
+            'Splitter.SplitTextByWhitespace',
+            'Sql.Database',
+            'Sql.Databases',
+            'SqlExpression.SchemaFrom',
+            'SqlExpression.ToExpression',
+            'Sybase.Database',
+            'Table.AddColumn',
+            'Table.AddIndexColumn',
+            'Table.AddJoinColumn',
+            'Table.AddKey',
+            'Table.AggregateTableColumn',
+            'Table.AlternateRows',
+            'Table.Buffer',
+            'Table.Column',
+            'Table.ColumnCount',
+            'Table.ColumnNames',
+            'Table.ColumnsOfType',
+            'Table.Combine',
+            'Table.CombineColumns',
+            'Table.Contains',
+            'Table.ContainsAll',
+            'Table.ContainsAny',
+            'Table.DemoteHeaders',
+            'Table.Distinct',
+            'Table.DuplicateColumn',
+            'Table.ExpandListColumn',
+            'Table.ExpandRecordColumn',
+            'Table.ExpandTableColumn',
+            'Table.FillDown',
+            'Table.FillUp',
+            'Table.FilterWithDataTable',
+            'Table.FindText',
+            'Table.First',
+            'Table.FirstN',
+            'Table.FirstValue',
+            'Table.FromColumns',
+            'Table.FromList',
+            'Table.FromPartitions',
+            'Table.FromRecords',
+            'Table.FromRows',
+            'Table.FromValue',
+            'Table.Group',
+            'Table.HasColumns',
+            'Table.InsertRows',
+            'Table.IsDistinct',
+            'Table.IsEmpty',
+            'Table.Join',
+            'Table.Keys',
+            'Table.Last',
+            'Table.LastN',
+            'Table.MatchesAllRows',
+            'Table.MatchesAnyRows',
+            'Table.Max',
+            'Table.MaxN',
+            'Table.Min',
+            'Table.MinN',
+            'Table.NestedJoin',
+            'Table.Partition',
+            'Table.PartitionValues',
+            'Table.Pivot',
+            'Table.PositionOf',
+            'Table.PositionOfAny',
+            'Table.PrefixColumns',
+            'Table.Profile',
+            'Table.PromoteHeaders',
+            'Table.Range',
+            'Table.RemoveColumns',
+            'Table.RemoveFirstN',
+            'Table.RemoveLastN',
+            'Table.RemoveMatchingRows',
+            'Table.RemoveRows',
+            'Table.RemoveRowsWithErrors',
+            'Table.RenameColumns',
+            'Table.ReorderColumns',
+            'Table.Repeat',
+            'Table.ReplaceErrorValues',
+            'Table.ReplaceKeys',
+            'Table.ReplaceMatchingRows',
+            'Table.ReplaceRelationshipIdentity',
+            'Table.ReplaceRows',
+            'Table.ReplaceValue',
+            'Table.ReverseRows',
+            'Table.RowCount',
+            'Table.Schema',
+            'Table.SelectColumns',
+            'Table.SelectRows',
+            'Table.SelectRowsWithErrors',
+            'Table.SingleRow',
+            'Table.Skip',
+            'Table.Sort',
+            'Table.SplitColumn',
+            'Table.ToColumns',
+            'Table.ToList',
+            'Table.ToRecords',
+            'Table.ToRows',
+            'Table.TransformColumnNames',
+            'Table.TransformColumnTypes',
+            'Table.TransformColumns',
+            'Table.TransformRows',
+            'Table.Transpose',
+            'Table.Unpivot',
+            'Table.UnpivotOtherColumns',
+            'Table.View',
+            'Table.ViewFunction',
+            'TableAction.DeleteRows',
+            'TableAction.InsertRows',
+            'TableAction.UpdateRows',
+            'Tables.GetRelationships',
+            'Teradata.Database',
+            'Text.AfterDelimiter',
+            'Text.At',
+            'Text.BeforeDelimiter',
+            'Text.BetweenDelimiters',
+            'Text.Clean',
+            'Text.Combine',
+            'Text.Contains',
+            'Text.End',
+            'Text.EndsWith',
+            'Text.Format',
+            'Text.From',
+            'Text.FromBinary',
+            'Text.Insert',
+            'Text.Length',
+            'Text.Lower',
+            'Text.Middle',
+            'Text.NewGuid',
+            'Text.PadEnd',
+            'Text.PadStart',
+            'Text.PositionOf',
+            'Text.PositionOfAny',
+            'Text.Proper',
+            'Text.Range',
+            'Text.Remove',
+            'Text.RemoveRange',
+            'Text.Repeat',
+            'Text.Replace',
+            'Text.ReplaceRange',
+            'Text.Select',
+            'Text.Split',
+            'Text.SplitAny',
+            'Text.Start',
+            'Text.StartsWith',
+            'Text.ToBinary',
+            'Text.ToList',
+            'Text.Trim',
+            'Text.TrimEnd',
+            'Text.TrimStart',
+            'Text.Upper',
+            'Time.EndOfHour',
+            'Time.From',
+            'Time.FromText',
+            'Time.Hour',
+            'Time.Minute',
+            'Time.Second',
+            'Time.StartOfHour',
+            'Time.ToRecord',
+            'Time.ToText',
+            'Type.AddTableKey',
+            'Type.ClosedRecord',
+            'Type.Facets',
+            'Type.ForFunction',
+            'Type.ForRecord',
+            'Type.FunctionParameters',
+            'Type.FunctionRequiredParameters',
+            'Type.FunctionReturn',
+            'Type.Is',
+            'Type.IsNullable',
+            'Type.IsOpenRecord',
+            'Type.ListItem',
+            'Type.NonNullable',
+            'Type.OpenRecord',
+            'Type.RecordFields',
+            'Type.ReplaceFacets',
+            'Type.ReplaceTableKeys',
+            'Type.TableColumn',
+            'Type.TableKeys',
+            'Type.TableRow',
+            'Type.TableSchema',
+            'Type.Union',
+            'Uri.BuildQueryString',
+            'Uri.Combine',
+            'Uri.EscapeDataString',
+            'Uri.Parts',
+            'Value.Add',
+            'Value.As',
+            'Value.Compare',
+            'Value.Divide',
+            'Value.Equals',
+            'Value.Firewall',
+            'Value.FromText',
+            'Value.Is',
+            'Value.Metadata',
+            'Value.Multiply',
+            'Value.NativeQuery',
+            'Value.NullableEquals',
+            'Value.RemoveMetadata',
+            'Value.ReplaceMetadata',
+            'Value.ReplaceType',
+            'Value.Subtract',
+            'Value.Type',
+            'ValueAction.NativeStatement',
+            'ValueAction.Replace',
+            'Variable.Value',
+            'Web.Contents',
+            'Web.Page',
+            'WebAction.Request',
+            'Xml.Document',
+            'Xml.Tables',
+          ],
+          builtinConstants: [
+            'BinaryEncoding.Base64',
+            'BinaryEncoding.Hex',
+            'BinaryOccurrence.Optional',
+            'BinaryOccurrence.Repeating',
+            'BinaryOccurrence.Required',
+            'ByteOrder.BigEndian',
+            'ByteOrder.LittleEndian',
+            'Compression.Deflate',
+            'Compression.GZip',
+            'CsvStyle.QuoteAfterDelimiter',
+            'CsvStyle.QuoteAlways',
+            'Culture.Current',
+            'Day.Friday',
+            'Day.Monday',
+            'Day.Saturday',
+            'Day.Sunday',
+            'Day.Thursday',
+            'Day.Tuesday',
+            'Day.Wednesday',
+            'ExtraValues.Error',
+            'ExtraValues.Ignore',
+            'ExtraValues.List',
+            'GroupKind.Global',
+            'GroupKind.Local',
+            'JoinAlgorithm.Dynamic',
+            'JoinAlgorithm.LeftHash',
+            'JoinAlgorithm.LeftIndex',
+            'JoinAlgorithm.PairwiseHash',
+            'JoinAlgorithm.RightHash',
+            'JoinAlgorithm.RightIndex',
+            'JoinAlgorithm.SortMerge',
+            'JoinKind.FullOuter',
+            'JoinKind.Inner',
+            'JoinKind.LeftAnti',
+            'JoinKind.LeftOuter',
+            'JoinKind.RightAnti',
+            'JoinKind.RightOuter',
+            'JoinSide.Left',
+            'JoinSide.Right',
+            'MissingField.Error',
+            'MissingField.Ignore',
+            'MissingField.UseNull',
+            'Number.E',
+            'Number.Epsilon',
+            'Number.NaN',
+            'Number.NegativeInfinity',
+            'Number.PI',
+            'Number.PositiveInfinity',
+            'Occurrence.All',
+            'Occurrence.First',
+            'Occurrence.Last',
+            'Occurrence.Optional',
+            'Occurrence.Repeating',
+            'Occurrence.Required',
+            'Order.Ascending',
+            'Order.Descending',
+            'Precision.Decimal',
+            'Precision.Double',
+            'QuoteStyle.Csv',
+            'QuoteStyle.None',
+            'RelativePosition.FromEnd',
+            'RelativePosition.FromStart',
+            'RoundingMode.AwayFromZero',
+            'RoundingMode.Down',
+            'RoundingMode.ToEven',
+            'RoundingMode.TowardZero',
+            'RoundingMode.Up',
+            'SapHanaDistribution.All',
+            'SapHanaDistribution.Connection',
+            'SapHanaDistribution.Off',
+            'SapHanaDistribution.Statement',
+            'SapHanaRangeOperator.Equals',
+            'SapHanaRangeOperator.GreaterThan',
+            'SapHanaRangeOperator.GreaterThanOrEquals',
+            'SapHanaRangeOperator.LessThan',
+            'SapHanaRangeOperator.LessThanOrEquals',
+            'SapHanaRangeOperator.NotEquals',
+            'TextEncoding.Ascii',
+            'TextEncoding.BigEndianUnicode',
+            'TextEncoding.Unicode',
+            'TextEncoding.Utf16',
+            'TextEncoding.Utf8',
+            'TextEncoding.Windows',
+            'TraceLevel.Critical',
+            'TraceLevel.Error',
+            'TraceLevel.Information',
+            'TraceLevel.Verbose',
+            'TraceLevel.Warning',
+            'WebMethod.Delete',
+            'WebMethod.Get',
+            'WebMethod.Head',
+            'WebMethod.Patch',
+            'WebMethod.Post',
+            'WebMethod.Put',
+          ],
+          builtinTypes: [
+            'Action.Type',
+            'Any.Type',
+            'Binary.Type',
+            'BinaryEncoding.Type',
+            'BinaryOccurrence.Type',
+            'Byte.Type',
+            'ByteOrder.Type',
+            'Character.Type',
+            'Compression.Type',
+            'CsvStyle.Type',
+            'Currency.Type',
+            'Date.Type',
+            'DateTime.Type',
+            'DateTimeZone.Type',
+            'Day.Type',
+            'Decimal.Type',
+            'Double.Type',
+            'Duration.Type',
+            'ExtraValues.Type',
+            'Function.Type',
+            'GroupKind.Type',
+            'Guid.Type',
+            'Int16.Type',
+            'Int32.Type',
+            'Int64.Type',
+            'Int8.Type',
+            'JoinAlgorithm.Type',
+            'JoinKind.Type',
+            'JoinSide.Type',
+            'List.Type',
+            'Logical.Type',
+            'MissingField.Type',
+            'None.Type',
+            'Null.Type',
+            'Number.Type',
+            'Occurrence.Type',
+            'Order.Type',
+            'Password.Type',
+            'Percentage.Type',
+            'Precision.Type',
+            'QuoteStyle.Type',
+            'Record.Type',
+            'RelativePosition.Type',
+            'RoundingMode.Type',
+            'SapHanaDistribution.Type',
+            'SapHanaRangeOperator.Type',
+            'Single.Type',
+            'Table.Type',
+            'Text.Type',
+            'TextEncoding.Type',
+            'Time.Type',
+            'TraceLevel.Type',
+            'Type.Type',
+            'Uri.Type',
+            'WebMethod.Type',
+          ],
+          tokenizer: {
+            root: [
+              [/#"[\w \.]+"/, 'identifier.quote'],
+              [/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
+              [/0[xX][0-9a-fA-F]+/, 'number.hex'],
+              [/\d+([eE][\-+]?\d+)?/, 'number'],
+              [
+                /(#?[a-z]+)\b/,
+                {
+                  cases: {
+                    '@typeKeywords': 'type',
+                    '@keywords': 'keyword',
+                    '@constants': 'constant',
+                    '@constructors': 'constructor',
+                    '@operatorKeywords': 'operators',
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+              [
+                /\b([A-Z][a-zA-Z0-9]+\.Type)\b/,
+                {
+                  cases: { '@builtinTypes': 'type', '@default': 'identifier' },
+                },
+              ],
+              [
+                /\b([A-Z][a-zA-Z0-9]+\.[A-Z][a-zA-Z0-9]+)\b/,
+                {
+                  cases: {
+                    '@builtinFunctions': 'keyword.function',
+                    '@builtinConstants': 'constant',
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+              [/\b([a-zA-Z_][\w\.]*)\b/, 'identifier'],
+              { include: '@whitespace' },
+              { include: '@comments' },
+              { include: '@strings' },
+              [/[{}()\[\]]/, '@brackets'],
+              [
+                /([=\+<>\-\*&@\?\/!])|([<>]=)|(<>)|(=>)|(\.\.\.)|(\.\.)/,
+                'operators',
+              ],
+              [/[,;]/, 'delimiter'],
+            ],
+            whitespace: [[/\s+/, 'white']],
+            comments: [
+              ['\\/\\*', 'comment', '@comment'],
+              ['\\/\\/+.*', 'comment'],
+            ],
+            comment: [
+              ['\\*\\/', 'comment', '@pop'],
+              ['.', 'comment'],
+            ],
+            strings: [['"', 'string', '@string']],
+            string: [
+              ['""', 'string.escape'],
+              ['"', 'string', '@pop'],
+              ['.', 'string'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/4902.4902.js

@@ -0,0 +1,96 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [4902],
+  {
+    4902: (e, t, a) => {
+      'use strict';
+      a.r(t), a.d(t, { conf: () => n, language: () => i });
+      var n = {
+          comments: { blockComment: ['\x3c!--', '--\x3e'] },
+          brackets: [['<', '>']],
+          autoClosingPairs: [
+            { open: '<', close: '>' },
+            { open: "'", close: "'" },
+            { open: '"', close: '"' },
+          ],
+          surroundingPairs: [
+            { open: '<', close: '>' },
+            { open: "'", close: "'" },
+            { open: '"', close: '"' },
+          ],
+        },
+        i = {
+          defaultToken: '',
+          tokenPostfix: '.xml',
+          ignoreCase: !0,
+          qualifiedName: /(?:[\w\.\-]+:)?[\w\.\-]+/,
+          tokenizer: {
+            root: [
+              [/[^<&]+/, ''],
+              { include: '@whitespace' },
+              [
+                /(<)(@qualifiedName)/,
+                [{ token: 'delimiter' }, { token: 'tag', next: '@tag' }],
+              ],
+              [
+                /(<\/)(@qualifiedName)(\s*)(>)/,
+                [
+                  { token: 'delimiter' },
+                  { token: 'tag' },
+                  '',
+                  { token: 'delimiter' },
+                ],
+              ],
+              [
+                /(<\?)(@qualifiedName)/,
+                [{ token: 'delimiter' }, { token: 'metatag', next: '@tag' }],
+              ],
+              [
+                /(<\!)(@qualifiedName)/,
+                [{ token: 'delimiter' }, { token: 'metatag', next: '@tag' }],
+              ],
+              [/<\!\[CDATA\[/, { token: 'delimiter.cdata', next: '@cdata' }],
+              [/&\w+;/, 'string.escape'],
+            ],
+            cdata: [
+              [/[^\]]+/, ''],
+              [/\]\]>/, { token: 'delimiter.cdata', next: '@pop' }],
+              [/\]/, ''],
+            ],
+            tag: [
+              [/[ \t\r\n]+/, ''],
+              [
+                /(@qualifiedName)(\s*=\s*)("[^"]*"|'[^']*')/,
+                ['attribute.name', '', 'attribute.value'],
+              ],
+              [
+                /(@qualifiedName)(\s*=\s*)("[^">?\/]*|'[^'>?\/]*)(?=[\?\/]\>)/,
+                ['attribute.name', '', 'attribute.value'],
+              ],
+              [
+                /(@qualifiedName)(\s*=\s*)("[^">]*|'[^'>]*)/,
+                ['attribute.name', '', 'attribute.value'],
+              ],
+              [/@qualifiedName/, 'attribute.name'],
+              [/\?>/, { token: 'delimiter', next: '@pop' }],
+              [
+                /(\/)(>)/,
+                [{ token: 'tag' }, { token: 'delimiter', next: '@pop' }],
+              ],
+              [/>/, { token: 'delimiter', next: '@pop' }],
+            ],
+            whitespace: [
+              [/[ \t\r\n]+/, ''],
+              [/<!--/, { token: 'comment', next: '@comment' }],
+            ],
+            comment: [
+              [/[^<\-]+/, 'comment.content'],
+              [/-->/, { token: 'comment', next: '@pop' }],
+              [/<!--/, 'comment.content.invalid'],
+              [/[<\-]/, 'comment.content'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/4912.4912.js

@@ -0,0 +1,167 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [4912],
+  {
+    64912: (e, t, i) => {
+      'use strict';
+      i.r(t), i.d(t, { conf: () => o, language: () => n });
+      var o = {
+          comments: { lineComment: 'COMMENT' },
+          brackets: [['(', ')']],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: ':', close: '.' },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '`', close: '`' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+            { open: ':', close: '.' },
+          ],
+          folding: {
+            markers: {
+              start: new RegExp('^\\s*(::\\s*|COMMENT\\s+)#region'),
+              end: new RegExp('^\\s*(::\\s*|COMMENT\\s+)#endregion'),
+            },
+          },
+        },
+        n = {
+          tokenPostfix: '.lexon',
+          ignoreCase: !0,
+          keywords: [
+            'lexon',
+            'lex',
+            'clause',
+            'terms',
+            'contracts',
+            'may',
+            'pay',
+            'pays',
+            'appoints',
+            'into',
+            'to',
+          ],
+          typeKeywords: [
+            'amount',
+            'person',
+            'key',
+            'time',
+            'date',
+            'asset',
+            'text',
+          ],
+          operators: [
+            'less',
+            'greater',
+            'equal',
+            'le',
+            'gt',
+            'or',
+            'and',
+            'add',
+            'added',
+            'subtract',
+            'subtracted',
+            'multiply',
+            'multiplied',
+            'times',
+            'divide',
+            'divided',
+            'is',
+            'be',
+            'certified',
+          ],
+          symbols: /[=><!~?:&|+\-*\/\^%]+/,
+          tokenizer: {
+            root: [
+              [/^(\s*)(comment:?(?:\s.*|))$/, ['', 'comment']],
+              [
+                /"/,
+                {
+                  token: 'identifier.quote',
+                  bracket: '@open',
+                  next: '@quoted_identifier',
+                },
+              ],
+              [
+                'LEX$',
+                {
+                  token: 'keyword',
+                  bracket: '@open',
+                  next: '@identifier_until_period',
+                },
+              ],
+              [
+                'LEXON',
+                { token: 'keyword', bracket: '@open', next: '@semver' },
+              ],
+              [
+                ':',
+                {
+                  token: 'delimiter',
+                  bracket: '@open',
+                  next: '@identifier_until_period',
+                },
+              ],
+              [
+                /[a-z_$][\w$]*/,
+                {
+                  cases: {
+                    '@operators': 'operator',
+                    '@typeKeywords': 'keyword.type',
+                    '@keywords': 'keyword',
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+              { include: '@whitespace' },
+              [/[{}()\[\]]/, '@brackets'],
+              [/[<>](?!@symbols)/, '@brackets'],
+              [/@symbols/, 'delimiter'],
+              [/\d*\.\d*\.\d*/, 'number.semver'],
+              [/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
+              [/0[xX][0-9a-fA-F]+/, 'number.hex'],
+              [/\d+/, 'number'],
+              [/[;,.]/, 'delimiter'],
+            ],
+            quoted_identifier: [
+              [/[^\\"]+/, 'identifier'],
+              [
+                /"/,
+                { token: 'identifier.quote', bracket: '@close', next: '@pop' },
+              ],
+            ],
+            space_identifier_until_period: [
+              [':', 'delimiter'],
+              [' ', { token: 'white', next: '@identifier_rest' }],
+            ],
+            identifier_until_period: [
+              { include: '@whitespace' },
+              [':', { token: 'delimiter', next: '@identifier_rest' }],
+              [/[^\\.]+/, 'identifier'],
+              [/\./, { token: 'delimiter', bracket: '@close', next: '@pop' }],
+            ],
+            identifier_rest: [
+              [/[^\\.]+/, 'identifier'],
+              [/\./, { token: 'delimiter', bracket: '@close', next: '@pop' }],
+            ],
+            semver: [
+              { include: '@whitespace' },
+              [':', 'delimiter'],
+              [
+                /\d*\.\d*\.\d*/,
+                { token: 'number.semver', bracket: '@close', next: '@pop' },
+              ],
+            ],
+            whitespace: [[/[ \t\r\n]+/, 'white']],
+          },
+        };
+    },
+  },
+]);

docs/4946.4946.js

@@ -0,0 +1,500 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [4946],
+  {
+    34946: (e, t, r) => {
+      'use strict';
+      r.r(t), r.d(t, { conf: () => n, language: () => o });
+      var n = {
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+        },
+        o = {
+          tokenPostfix: '.julia',
+          keywords: [
+            'begin',
+            'while',
+            'if',
+            'for',
+            'try',
+            'return',
+            'break',
+            'continue',
+            'function',
+            'macro',
+            'quote',
+            'let',
+            'local',
+            'global',
+            'const',
+            'do',
+            'struct',
+            'module',
+            'baremodule',
+            'using',
+            'import',
+            'export',
+            'end',
+            'else',
+            'elseif',
+            'catch',
+            'finally',
+            'mutable',
+            'primitive',
+            'abstract',
+            'type',
+            'in',
+            'isa',
+            'where',
+            'new',
+          ],
+          types: [
+            'LinRange',
+            'LineNumberNode',
+            'LinearIndices',
+            'LoadError',
+            'MIME',
+            'Matrix',
+            'Method',
+            'MethodError',
+            'Missing',
+            'MissingException',
+            'Module',
+            'NTuple',
+            'NamedTuple',
+            'Nothing',
+            'Number',
+            'OrdinalRange',
+            'OutOfMemoryError',
+            'OverflowError',
+            'Pair',
+            'PartialQuickSort',
+            'PermutedDimsArray',
+            'Pipe',
+            'Ptr',
+            'QuoteNode',
+            'Rational',
+            'RawFD',
+            'ReadOnlyMemoryError',
+            'Real',
+            'ReentrantLock',
+            'Ref',
+            'Regex',
+            'RegexMatch',
+            'RoundingMode',
+            'SegmentationFault',
+            'Set',
+            'Signed',
+            'Some',
+            'StackOverflowError',
+            'StepRange',
+            'StepRangeLen',
+            'StridedArray',
+            'StridedMatrix',
+            'StridedVecOrMat',
+            'StridedVector',
+            'String',
+            'StringIndexError',
+            'SubArray',
+            'SubString',
+            'SubstitutionString',
+            'Symbol',
+            'SystemError',
+            'Task',
+            'Text',
+            'TextDisplay',
+            'Timer',
+            'Tuple',
+            'Type',
+            'TypeError',
+            'TypeVar',
+            'UInt',
+            'UInt128',
+            'UInt16',
+            'UInt32',
+            'UInt64',
+            'UInt8',
+            'UndefInitializer',
+            'AbstractArray',
+            'UndefKeywordError',
+            'AbstractChannel',
+            'UndefRefError',
+            'AbstractChar',
+            'UndefVarError',
+            'AbstractDict',
+            'Union',
+            'AbstractDisplay',
+            'UnionAll',
+            'AbstractFloat',
+            'UnitRange',
+            'AbstractIrrational',
+            'Unsigned',
+            'AbstractMatrix',
+            'AbstractRange',
+            'Val',
+            'AbstractSet',
+            'Vararg',
+            'AbstractString',
+            'VecElement',
+            'AbstractUnitRange',
+            'VecOrMat',
+            'AbstractVecOrMat',
+            'Vector',
+            'AbstractVector',
+            'VersionNumber',
+            'Any',
+            'WeakKeyDict',
+            'ArgumentError',
+            'WeakRef',
+            'Array',
+            'AssertionError',
+            'BigFloat',
+            'BigInt',
+            'BitArray',
+            'BitMatrix',
+            'BitSet',
+            'BitVector',
+            'Bool',
+            'BoundsError',
+            'CapturedException',
+            'CartesianIndex',
+            'CartesianIndices',
+            'Cchar',
+            'Cdouble',
+            'Cfloat',
+            'Channel',
+            'Char',
+            'Cint',
+            'Cintmax_t',
+            'Clong',
+            'Clonglong',
+            'Cmd',
+            'Colon',
+            'Complex',
+            'ComplexF16',
+            'ComplexF32',
+            'ComplexF64',
+            'CompositeException',
+            'Condition',
+            'Cptrdiff_t',
+            'Cshort',
+            'Csize_t',
+            'Cssize_t',
+            'Cstring',
+            'Cuchar',
+            'Cuint',
+            'Cuintmax_t',
+            'Culong',
+            'Culonglong',
+            'Cushort',
+            'Cvoid',
+            'Cwchar_t',
+            'Cwstring',
+            'DataType',
+            'DenseArray',
+            'DenseMatrix',
+            'DenseVecOrMat',
+            'DenseVector',
+            'Dict',
+            'DimensionMismatch',
+            'Dims',
+            'DivideError',
+            'DomainError',
+            'EOFError',
+            'Enum',
+            'ErrorException',
+            'Exception',
+            'ExponentialBackOff',
+            'Expr',
+            'Float16',
+            'Float32',
+            'Float64',
+            'Function',
+            'GlobalRef',
+            'HTML',
+            'IO',
+            'IOBuffer',
+            'IOContext',
+            'IOStream',
+            'IdDict',
+            'IndexCartesian',
+            'IndexLinear',
+            'IndexStyle',
+            'InexactError',
+            'InitError',
+            'Int',
+            'Int128',
+            'Int16',
+            'Int32',
+            'Int64',
+            'Int8',
+            'Integer',
+            'InterruptException',
+            'InvalidStateException',
+            'Irrational',
+            'KeyError',
+          ],
+          keywordops: ['<:', '>:', ':', '=>', '...', '.', '->', '?'],
+          allops: /[^\w\d\s()\[\]{}"'#]+/,
+          constants: [
+            'true',
+            'false',
+            'nothing',
+            'missing',
+            'undef',
+            'Inf',
+            'pi',
+            'NaN',
+            'π',
+            'ℯ',
+            'ans',
+            'PROGRAM_FILE',
+            'ARGS',
+            'C_NULL',
+            'VERSION',
+            'DEPOT_PATH',
+            'LOAD_PATH',
+          ],
+          operators: [
+            '!',
+            '!=',
+            '!==',
+            '%',
+            '&',
+            '*',
+            '+',
+            '-',
+            '/',
+            '//',
+            '<',
+            '<<',
+            '<=',
+            '==',
+            '===',
+            '=>',
+            '>',
+            '>=',
+            '>>',
+            '>>>',
+            '\\',
+            '^',
+            '|',
+            '|>',
+            '~',
+            '÷',
+            '∈',
+            '∉',
+            '∋',
+            '∌',
+            '∘',
+            '√',
+            '∛',
+            '∩',
+            '∪',
+            '≈',
+            '≉',
+            '≠',
+            '≡',
+            '≢',
+            '≤',
+            '≥',
+            '⊆',
+            '⊇',
+            '⊈',
+            '⊉',
+            '⊊',
+            '⊋',
+            '⊻',
+          ],
+          brackets: [
+            { open: '(', close: ')', token: 'delimiter.parenthesis' },
+            { open: '{', close: '}', token: 'delimiter.curly' },
+            { open: '[', close: ']', token: 'delimiter.square' },
+          ],
+          ident: /π|ℯ|\b(?!\d)\w+\b/,
+          escape: /(?:[abefnrstv\\"'\n\r]|[0-7]{1,3}|x[0-9A-Fa-f]{1,2}|u[0-9A-Fa-f]{4})/,
+          escapes: /\\(?:C\-(@escape|.)|c(@escape|.)|@escape)/,
+          tokenizer: {
+            root: [
+              [/(::)\s*|\b(isa)\s+/, 'keyword', '@typeanno'],
+              [
+                /\b(isa)(\s*\(@ident\s*,\s*)/,
+                ['keyword', { token: '', next: '@typeanno' }],
+              ],
+              [/\b(type|struct)[ \t]+/, 'keyword', '@typeanno'],
+              [/^\s*:@ident[!?]?/, 'metatag'],
+              [/(return)(\s*:@ident[!?]?)/, ['keyword', 'metatag']],
+              [/(\(|\[|\{|@allops)(\s*:@ident[!?]?)/, ['', 'metatag']],
+              [/:\(/, 'metatag', '@quote'],
+              [/r"""/, 'regexp.delim', '@tregexp'],
+              [/r"/, 'regexp.delim', '@sregexp'],
+              [/raw"""/, 'string.delim', '@rtstring'],
+              [/[bv]?"""/, 'string.delim', '@dtstring'],
+              [/raw"/, 'string.delim', '@rsstring'],
+              [/[bv]?"/, 'string.delim', '@dsstring'],
+              [
+                /(@ident)\{/,
+                {
+                  cases: {
+                    '$1@types': { token: 'type', next: '@gen' },
+                    '@default': { token: 'type', next: '@gen' },
+                  },
+                },
+              ],
+              [
+                /@ident[!?'']?(?=\.?\()/,
+                {
+                  cases: {
+                    '@types': 'type',
+                    '@keywords': 'keyword',
+                    '@constants': 'variable',
+                    '@default': 'keyword.flow',
+                  },
+                },
+              ],
+              [
+                /@ident[!?']?/,
+                {
+                  cases: {
+                    '@types': 'type',
+                    '@keywords': 'keyword',
+                    '@constants': 'variable',
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+              [/\$\w+/, 'key'],
+              [/\$\(/, 'key', '@paste'],
+              [/@@ident/, 'annotation'],
+              { include: '@whitespace' },
+              [/'(?:@escapes|.)'/, 'string.character'],
+              [/[()\[\]{}]/, '@brackets'],
+              [
+                /@allops/,
+                {
+                  cases: { '@keywordops': 'keyword', '@operators': 'operator' },
+                },
+              ],
+              [/[;,]/, 'delimiter'],
+              [/0[xX][0-9a-fA-F](_?[0-9a-fA-F])*/, 'number.hex'],
+              [/0[_oO][0-7](_?[0-7])*/, 'number.octal'],
+              [/0[bB][01](_?[01])*/, 'number.binary'],
+              [/[+\-]?\d+(\.\d+)?(im?|[eE][+\-]?\d+(\.\d+)?)?/, 'number'],
+            ],
+            typeanno: [
+              [/[a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*\{/, 'type', '@gen'],
+              [
+                /([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)(\s*<:\s*)/,
+                ['type', 'keyword'],
+              ],
+              [/[a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*/, 'type', '@pop'],
+              ['', '', '@pop'],
+            ],
+            gen: [
+              [/[a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*\{/, 'type', '@push'],
+              [/[a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*/, 'type'],
+              [/<:/, 'keyword'],
+              [/(\})(\s*<:\s*)/, ['type', { token: 'keyword', next: '@pop' }]],
+              [/\}/, 'type', '@pop'],
+              { include: '@root' },
+            ],
+            quote: [
+              [/\$\(/, 'key', '@paste'],
+              [/\(/, '@brackets', '@paren'],
+              [/\)/, 'metatag', '@pop'],
+              { include: '@root' },
+            ],
+            paste: [
+              [/:\(/, 'metatag', '@quote'],
+              [/\(/, '@brackets', '@paren'],
+              [/\)/, 'key', '@pop'],
+              { include: '@root' },
+            ],
+            paren: [
+              [/\$\(/, 'key', '@paste'],
+              [/:\(/, 'metatag', '@quote'],
+              [/\(/, '@brackets', '@push'],
+              [/\)/, '@brackets', '@pop'],
+              { include: '@root' },
+            ],
+            sregexp: [
+              [/^.*/, 'invalid'],
+              [/[^\\"()\[\]{}]/, 'regexp'],
+              [/[()\[\]{}]/, '@brackets'],
+              [/\\./, 'operator.scss'],
+              [/"[imsx]*/, 'regexp.delim', '@pop'],
+            ],
+            tregexp: [
+              [/[^\\"()\[\]{}]/, 'regexp'],
+              [/[()\[\]{}]/, '@brackets'],
+              [/\\./, 'operator.scss'],
+              [/"(?!"")/, 'string'],
+              [/"""[imsx]*/, 'regexp.delim', '@pop'],
+            ],
+            rsstring: [
+              [/^.*/, 'invalid'],
+              [/[^\\"]/, 'string'],
+              [/\\./, 'string.escape'],
+              [/"/, 'string.delim', '@pop'],
+            ],
+            rtstring: [
+              [/[^\\"]/, 'string'],
+              [/\\./, 'string.escape'],
+              [/"(?!"")/, 'string'],
+              [/"""/, 'string.delim', '@pop'],
+            ],
+            dsstring: [
+              [/^.*/, 'invalid'],
+              [/[^\\"\$]/, 'string'],
+              [/\$/, '', '@interpolated'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/"/, 'string.delim', '@pop'],
+            ],
+            dtstring: [
+              [/[^\\"\$]/, 'string'],
+              [/\$/, '', '@interpolated'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/"(?!"")/, 'string'],
+              [/"""/, 'string.delim', '@pop'],
+            ],
+            interpolated: [
+              [/\(/, { token: '', switchTo: '@interpolated_compound' }],
+              [/[a-zA-Z_]\w*/, 'identifier'],
+              ['', '', '@pop'],
+            ],
+            interpolated_compound: [[/\)/, '', '@pop'], { include: '@root' }],
+            whitespace: [
+              [/[ \t\r\n]+/, ''],
+              [/#=/, 'comment', '@multi_comment'],
+              [/#.*$/, 'comment'],
+            ],
+            multi_comment: [
+              [/#=/, 'comment', '@push'],
+              [/=#/, 'comment', '@pop'],
+              [/=(?!#)|#(?!=)/, 'comment'],
+              [/[^#=]+/, 'comment'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/5062.5062.js

@@ -0,0 +1,114 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [5062],
+  {
+    78: (e, o, n) => {
+      'use strict';
+      n.r(o), n.d(o, { conf: () => t, language: () => r });
+      var t = {
+          comments: { lineComment: "'" },
+          brackets: [
+            ['(', ')'],
+            ['[', ']'],
+            ['If', 'EndIf'],
+            ['While', 'EndWhile'],
+            ['For', 'EndFor'],
+            ['Sub', 'EndSub'],
+          ],
+          autoClosingPairs: [
+            { open: '"', close: '"', notIn: ['string', 'comment'] },
+            { open: '(', close: ')', notIn: ['string', 'comment'] },
+            { open: '[', close: ']', notIn: ['string', 'comment'] },
+          ],
+        },
+        r = {
+          defaultToken: '',
+          tokenPostfix: '.sb',
+          ignoreCase: !0,
+          brackets: [
+            { token: 'delimiter.array', open: '[', close: ']' },
+            { token: 'delimiter.parenthesis', open: '(', close: ')' },
+            { token: 'keyword.tag-if', open: 'If', close: 'EndIf' },
+            { token: 'keyword.tag-while', open: 'While', close: 'EndWhile' },
+            { token: 'keyword.tag-for', open: 'For', close: 'EndFor' },
+            { token: 'keyword.tag-sub', open: 'Sub', close: 'EndSub' },
+          ],
+          keywords: [
+            'Else',
+            'ElseIf',
+            'EndFor',
+            'EndIf',
+            'EndSub',
+            'EndWhile',
+            'For',
+            'Goto',
+            'If',
+            'Step',
+            'Sub',
+            'Then',
+            'To',
+            'While',
+          ],
+          tagwords: ['If', 'Sub', 'While', 'For'],
+          operators: [
+            '>',
+            '<',
+            '<>',
+            '<=',
+            '>=',
+            'And',
+            'Or',
+            '+',
+            '-',
+            '*',
+            '/',
+            '=',
+          ],
+          identifier: /[a-zA-Z_][\w]*/,
+          symbols: /[=><:+\-*\/%\.,]+/,
+          escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+          tokenizer: {
+            root: [
+              { include: '@whitespace' },
+              [/(@identifier)(?=[.])/, 'type'],
+              [
+                /@identifier/,
+                {
+                  cases: {
+                    '@keywords': { token: 'keyword.$0' },
+                    '@operators': 'operator',
+                    '@default': 'variable.name',
+                  },
+                },
+              ],
+              [
+                /([.])(@identifier)/,
+                { cases: { $2: ['delimiter', 'type.member'], '@default': '' } },
+              ],
+              [/\d*\.\d+/, 'number.float'],
+              [/\d+/, 'number'],
+              [/[()\[\]]/, '@brackets'],
+              [
+                /@symbols/,
+                {
+                  cases: { '@operators': 'operator', '@default': 'delimiter' },
+                },
+              ],
+              [/"([^"\\]|\\.)*$/, 'string.invalid'],
+              [/"/, 'string', '@string'],
+            ],
+            whitespace: [
+              [/[ \t\r\n]+/, ''],
+              [/(\').*$/, 'comment'],
+            ],
+            string: [
+              [/[^\\"]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/"C?/, 'string', '@pop'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/525.525.js

@@ -0,0 +1,293 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [525],
+  {
+    90525: (e, t, n) => {
+      'use strict';
+      n.r(t), n.d(t, { conf: () => o, language: () => i });
+      var o = {
+          wordPattern: /(#?-?\d*\.\d\w*%?)|([@$#!.:]?[\w-?]+%?)|[@#!.]/g,
+          comments: { blockComment: ['/*', '*/'], lineComment: '//' },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}', notIn: ['string', 'comment'] },
+            { open: '[', close: ']', notIn: ['string', 'comment'] },
+            { open: '(', close: ')', notIn: ['string', 'comment'] },
+            { open: '"', close: '"', notIn: ['string', 'comment'] },
+            { open: "'", close: "'", notIn: ['string', 'comment'] },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          folding: {
+            markers: {
+              start: new RegExp('^\\s*\\/\\*\\s*#region\\b\\s*(.*?)\\s*\\*\\/'),
+              end: new RegExp('^\\s*\\/\\*\\s*#endregion\\b.*\\*\\/'),
+            },
+          },
+        },
+        i = {
+          defaultToken: '',
+          tokenPostfix: '.scss',
+          ws: '[ \t\n\r\f]*',
+          identifier:
+            '-?-?([a-zA-Z]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))([\\w\\-]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))*',
+          brackets: [
+            { open: '{', close: '}', token: 'delimiter.curly' },
+            { open: '[', close: ']', token: 'delimiter.bracket' },
+            { open: '(', close: ')', token: 'delimiter.parenthesis' },
+            { open: '<', close: '>', token: 'delimiter.angle' },
+          ],
+          tokenizer: {
+            root: [{ include: '@selector' }],
+            selector: [
+              { include: '@comments' },
+              { include: '@import' },
+              { include: '@variabledeclaration' },
+              { include: '@warndebug' },
+              [
+                '[@](include)',
+                { token: 'keyword', next: '@includedeclaration' },
+              ],
+              [
+                '[@](keyframes|-webkit-keyframes|-moz-keyframes|-o-keyframes)',
+                { token: 'keyword', next: '@keyframedeclaration' },
+              ],
+              [
+                '[@](page|content|font-face|-moz-document)',
+                { token: 'keyword' },
+              ],
+              [
+                '[@](charset|namespace)',
+                { token: 'keyword', next: '@declarationbody' },
+              ],
+              [
+                '[@](function)',
+                { token: 'keyword', next: '@functiondeclaration' },
+              ],
+              ['[@](mixin)', { token: 'keyword', next: '@mixindeclaration' }],
+              [
+                'url(\\-prefix)?\\(',
+                { token: 'meta', next: '@urldeclaration' },
+              ],
+              { include: '@controlstatement' },
+              { include: '@selectorname' },
+              ['[&\\*]', 'tag'],
+              ['[>\\+,]', 'delimiter'],
+              [
+                '\\[',
+                { token: 'delimiter.bracket', next: '@selectorattribute' },
+              ],
+              ['{', { token: 'delimiter.curly', next: '@selectorbody' }],
+            ],
+            selectorbody: [
+              [
+                '[*_]?@identifier@ws:(?=(\\s|\\d|[^{;}]*[;}]))',
+                'attribute.name',
+                '@rulevalue',
+              ],
+              { include: '@selector' },
+              ['[@](extend)', { token: 'keyword', next: '@extendbody' }],
+              ['[@](return)', { token: 'keyword', next: '@declarationbody' }],
+              ['}', { token: 'delimiter.curly', next: '@pop' }],
+            ],
+            selectorname: [
+              ['#{', { token: 'meta', next: '@variableinterpolation' }],
+              ['(\\.|#(?=[^{])|%|(@identifier)|:)+', 'tag'],
+            ],
+            selectorattribute: [
+              { include: '@term' },
+              [']', { token: 'delimiter.bracket', next: '@pop' }],
+            ],
+            term: [
+              { include: '@comments' },
+              [
+                'url(\\-prefix)?\\(',
+                { token: 'meta', next: '@urldeclaration' },
+              ],
+              { include: '@functioninvocation' },
+              { include: '@numbers' },
+              { include: '@strings' },
+              { include: '@variablereference' },
+              ['(and\\b|or\\b|not\\b)', 'operator'],
+              { include: '@name' },
+              ['([<>=\\+\\-\\*\\/\\^\\|\\~,])', 'operator'],
+              [',', 'delimiter'],
+              ['!default', 'literal'],
+              [
+                '\\(',
+                { token: 'delimiter.parenthesis', next: '@parenthizedterm' },
+              ],
+            ],
+            rulevalue: [
+              { include: '@term' },
+              ['!important', 'literal'],
+              [';', 'delimiter', '@pop'],
+              ['{', { token: 'delimiter.curly', switchTo: '@nestedproperty' }],
+              ['(?=})', { token: '', next: '@pop' }],
+            ],
+            nestedproperty: [
+              ['[*_]?@identifier@ws:', 'attribute.name', '@rulevalue'],
+              { include: '@comments' },
+              ['}', { token: 'delimiter.curly', next: '@pop' }],
+            ],
+            warndebug: [
+              [
+                '[@](warn|debug)',
+                { token: 'keyword', next: '@declarationbody' },
+              ],
+            ],
+            import: [
+              ['[@](import)', { token: 'keyword', next: '@declarationbody' }],
+            ],
+            variabledeclaration: [
+              ['\\$@identifier@ws:', 'variable.decl', '@declarationbody'],
+            ],
+            urldeclaration: [
+              { include: '@strings' },
+              ['[^)\r\n]+', 'string'],
+              ['\\)', { token: 'meta', next: '@pop' }],
+            ],
+            parenthizedterm: [
+              { include: '@term' },
+              ['\\)', { token: 'delimiter.parenthesis', next: '@pop' }],
+            ],
+            declarationbody: [
+              { include: '@term' },
+              [';', 'delimiter', '@pop'],
+              ['(?=})', { token: '', next: '@pop' }],
+            ],
+            extendbody: [
+              { include: '@selectorname' },
+              ['!optional', 'literal'],
+              [';', 'delimiter', '@pop'],
+              ['(?=})', { token: '', next: '@pop' }],
+            ],
+            variablereference: [
+              ['\\$@identifier', 'variable.ref'],
+              ['\\.\\.\\.', 'operator'],
+              ['#{', { token: 'meta', next: '@variableinterpolation' }],
+            ],
+            variableinterpolation: [
+              { include: '@variablereference' },
+              ['}', { token: 'meta', next: '@pop' }],
+            ],
+            comments: [
+              ['\\/\\*', 'comment', '@comment'],
+              ['\\/\\/+.*', 'comment'],
+            ],
+            comment: [
+              ['\\*\\/', 'comment', '@pop'],
+              ['.', 'comment'],
+            ],
+            name: [['@identifier', 'attribute.value']],
+            numbers: [
+              [
+                '(\\d*\\.)?\\d+([eE][\\-+]?\\d+)?',
+                { token: 'number', next: '@units' },
+              ],
+              ['#[0-9a-fA-F_]+(?!\\w)', 'number.hex'],
+            ],
+            units: [
+              [
+                '(em|ex|ch|rem|vmin|vmax|vw|vh|vm|cm|mm|in|px|pt|pc|deg|grad|rad|turn|s|ms|Hz|kHz|%)?',
+                'number',
+                '@pop',
+              ],
+            ],
+            functiondeclaration: [
+              [
+                '@identifier@ws\\(',
+                { token: 'meta', next: '@parameterdeclaration' },
+              ],
+              ['{', { token: 'delimiter.curly', switchTo: '@functionbody' }],
+            ],
+            mixindeclaration: [
+              [
+                '@identifier@ws\\(',
+                { token: 'meta', next: '@parameterdeclaration' },
+              ],
+              ['@identifier', 'meta'],
+              ['{', { token: 'delimiter.curly', switchTo: '@selectorbody' }],
+            ],
+            parameterdeclaration: [
+              ['\\$@identifier@ws:', 'variable.decl'],
+              ['\\.\\.\\.', 'operator'],
+              [',', 'delimiter'],
+              { include: '@term' },
+              ['\\)', { token: 'meta', next: '@pop' }],
+            ],
+            includedeclaration: [
+              { include: '@functioninvocation' },
+              ['@identifier', 'meta'],
+              [';', 'delimiter', '@pop'],
+              ['(?=})', { token: '', next: '@pop' }],
+              ['{', { token: 'delimiter.curly', switchTo: '@selectorbody' }],
+            ],
+            keyframedeclaration: [
+              ['@identifier', 'meta'],
+              ['{', { token: 'delimiter.curly', switchTo: '@keyframebody' }],
+            ],
+            keyframebody: [
+              { include: '@term' },
+              ['{', { token: 'delimiter.curly', next: '@selectorbody' }],
+              ['}', { token: 'delimiter.curly', next: '@pop' }],
+            ],
+            controlstatement: [
+              [
+                '[@](if|else|for|while|each|media)',
+                { token: 'keyword.flow', next: '@controlstatementdeclaration' },
+              ],
+            ],
+            controlstatementdeclaration: [
+              ['(in|from|through|if|to)\\b', { token: 'keyword.flow' }],
+              { include: '@term' },
+              ['{', { token: 'delimiter.curly', switchTo: '@selectorbody' }],
+            ],
+            functionbody: [
+              ['[@](return)', { token: 'keyword' }],
+              { include: '@variabledeclaration' },
+              { include: '@term' },
+              { include: '@controlstatement' },
+              [';', 'delimiter'],
+              ['}', { token: 'delimiter.curly', next: '@pop' }],
+            ],
+            functioninvocation: [
+              ['@identifier\\(', { token: 'meta', next: '@functionarguments' }],
+            ],
+            functionarguments: [
+              ['\\$@identifier@ws:', 'attribute.name'],
+              ['[,]', 'delimiter'],
+              { include: '@term' },
+              ['\\)', { token: 'meta', next: '@pop' }],
+            ],
+            strings: [
+              [
+                '~?"',
+                { token: 'string.delimiter', next: '@stringenddoublequote' },
+              ],
+              ["~?'", { token: 'string.delimiter', next: '@stringendquote' }],
+            ],
+            stringenddoublequote: [
+              ['\\\\.', 'string'],
+              ['"', { token: 'string.delimiter', next: '@pop' }],
+              ['.', 'string'],
+            ],
+            stringendquote: [
+              ['\\\\.', 'string'],
+              ["'", { token: 'string.delimiter', next: '@pop' }],
+              ['.', 'string'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/5593.5593.js

@@ -0,0 +1,177 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [5593],
+  {
+    35593: (e, t, n) => {
+      'use strict';
+      n.r(t), n.d(t, { conf: () => i, language: () => r });
+      var i = {
+          wordPattern: /(#?-?\d*\.\d\w*%?)|([@#!.:]?[\w-?]+%?)|[@#!.]/g,
+          comments: { blockComment: ['/*', '*/'], lineComment: '//' },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}', notIn: ['string', 'comment'] },
+            { open: '[', close: ']', notIn: ['string', 'comment'] },
+            { open: '(', close: ')', notIn: ['string', 'comment'] },
+            { open: '"', close: '"', notIn: ['string', 'comment'] },
+            { open: "'", close: "'", notIn: ['string', 'comment'] },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          folding: {
+            markers: {
+              start: new RegExp('^\\s*\\/\\*\\s*#region\\b\\s*(.*?)\\s*\\*\\/'),
+              end: new RegExp('^\\s*\\/\\*\\s*#endregion\\b.*\\*\\/'),
+            },
+          },
+        },
+        r = {
+          defaultToken: '',
+          tokenPostfix: '.less',
+          identifier:
+            '-?-?([a-zA-Z]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))([\\w\\-]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))*',
+          identifierPlus:
+            '-?-?([a-zA-Z:.]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))([\\w\\-:.]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))*',
+          brackets: [
+            { open: '{', close: '}', token: 'delimiter.curly' },
+            { open: '[', close: ']', token: 'delimiter.bracket' },
+            { open: '(', close: ')', token: 'delimiter.parenthesis' },
+            { open: '<', close: '>', token: 'delimiter.angle' },
+          ],
+          tokenizer: {
+            root: [
+              { include: '@nestedJSBegin' },
+              ['[ \\t\\r\\n]+', ''],
+              { include: '@comments' },
+              { include: '@keyword' },
+              { include: '@strings' },
+              { include: '@numbers' },
+              [
+                '[*_]?[a-zA-Z\\-\\s]+(?=:.*(;|(\\\\$)))',
+                'attribute.name',
+                '@attribute',
+              ],
+              ['url(\\-prefix)?\\(', { token: 'tag', next: '@urldeclaration' }],
+              ['[{}()\\[\\]]', '@brackets'],
+              ['[,:;]', 'delimiter'],
+              ['#@identifierPlus', 'tag.id'],
+              ['&', 'tag'],
+              ['\\.@identifierPlus(?=\\()', 'tag.class', '@attribute'],
+              ['\\.@identifierPlus', 'tag.class'],
+              ['@identifierPlus', 'tag'],
+              { include: '@operators' },
+              ['@(@identifier(?=[:,\\)]))', 'variable', '@attribute'],
+              ['@(@identifier)', 'variable'],
+              ['@', 'key', '@atRules'],
+            ],
+            nestedJSBegin: [
+              ['``', 'delimiter.backtick'],
+              [
+                '`',
+                {
+                  token: 'delimiter.backtick',
+                  next: '@nestedJSEnd',
+                  nextEmbedded: 'text/javascript',
+                },
+              ],
+            ],
+            nestedJSEnd: [
+              [
+                '`',
+                {
+                  token: 'delimiter.backtick',
+                  next: '@pop',
+                  nextEmbedded: '@pop',
+                },
+              ],
+            ],
+            operators: [['[<>=\\+\\-\\*\\/\\^\\|\\~]', 'operator']],
+            keyword: [
+              [
+                '(@[\\s]*import|![\\s]*important|true|false|when|iscolor|isnumber|isstring|iskeyword|isurl|ispixel|ispercentage|isem|hue|saturation|lightness|alpha|lighten|darken|saturate|desaturate|fadein|fadeout|fade|spin|mix|round|ceil|floor|percentage)\\b',
+                'keyword',
+              ],
+            ],
+            urldeclaration: [
+              { include: '@strings' },
+              ['[^)\r\n]+', 'string'],
+              ['\\)', { token: 'tag', next: '@pop' }],
+            ],
+            attribute: [
+              { include: '@nestedJSBegin' },
+              { include: '@comments' },
+              { include: '@strings' },
+              { include: '@numbers' },
+              { include: '@keyword' },
+              ['[a-zA-Z\\-]+(?=\\()', 'attribute.value', '@attribute'],
+              ['>', 'operator', '@pop'],
+              ['@identifier', 'attribute.value'],
+              { include: '@operators' },
+              ['@(@identifier)', 'variable'],
+              ['[)\\}]', '@brackets', '@pop'],
+              ['[{}()\\[\\]>]', '@brackets'],
+              ['[;]', 'delimiter', '@pop'],
+              ['[,=:]', 'delimiter'],
+              ['\\s', ''],
+              ['.', 'attribute.value'],
+            ],
+            comments: [
+              ['\\/\\*', 'comment', '@comment'],
+              ['\\/\\/+.*', 'comment'],
+            ],
+            comment: [
+              ['\\*\\/', 'comment', '@pop'],
+              ['.', 'comment'],
+            ],
+            numbers: [
+              [
+                '(\\d*\\.)?\\d+([eE][\\-+]?\\d+)?',
+                { token: 'attribute.value.number', next: '@units' },
+              ],
+              ['#[0-9a-fA-F_]+(?!\\w)', 'attribute.value.hex'],
+            ],
+            units: [
+              [
+                '(em|ex|ch|rem|vmin|vmax|vw|vh|vm|cm|mm|in|px|pt|pc|deg|grad|rad|turn|s|ms|Hz|kHz|%)?',
+                'attribute.value.unit',
+                '@pop',
+              ],
+            ],
+            strings: [
+              [
+                '~?"',
+                { token: 'string.delimiter', next: '@stringsEndDoubleQuote' },
+              ],
+              ["~?'", { token: 'string.delimiter', next: '@stringsEndQuote' }],
+            ],
+            stringsEndDoubleQuote: [
+              ['\\\\"', 'string'],
+              ['"', { token: 'string.delimiter', next: '@popall' }],
+              ['.', 'string'],
+            ],
+            stringsEndQuote: [
+              ["\\\\'", 'string'],
+              ["'", { token: 'string.delimiter', next: '@popall' }],
+              ['.', 'string'],
+            ],
+            atRules: [
+              { include: '@comments' },
+              { include: '@strings' },
+              ['[()]', 'delimiter'],
+              ['[\\{;]', 'delimiter', '@pop'],
+              ['.', 'key'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/5703.5703.js

@@ -0,0 +1,430 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [5703],
+  {
+    15703: (e, t, n) => {
+      'use strict';
+      n.r(t), n.d(t, { conf: () => m, language: () => i });
+      var a = n(89587),
+        r = [
+          'area',
+          'base',
+          'br',
+          'col',
+          'embed',
+          'hr',
+          'img',
+          'input',
+          'keygen',
+          'link',
+          'menuitem',
+          'meta',
+          'param',
+          'source',
+          'track',
+          'wbr',
+        ],
+        m = {
+          wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\$\^\&\*\(\)\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\s]+)/g,
+          comments: { blockComment: ['{{!--', '--}}'] },
+          brackets: [
+            ['\x3c!--', '--\x3e'],
+            ['<', '>'],
+            ['{{', '}}'],
+            ['{', '}'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          surroundingPairs: [
+            { open: '<', close: '>' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          onEnterRules: [
+            {
+              beforeText: new RegExp(
+                '<(?!(?:' +
+                  r.join('|') +
+                  '))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$',
+                'i'
+              ),
+              afterText: /^<\/(\w[\w\d]*)\s*>$/i,
+              action: { indentAction: a.Mj.IndentAction.IndentOutdent },
+            },
+            {
+              beforeText: new RegExp(
+                '<(?!(?:' +
+                  r.join('|') +
+                  '))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$',
+                'i'
+              ),
+              action: { indentAction: a.Mj.IndentAction.Indent },
+            },
+          ],
+        },
+        i = {
+          defaultToken: '',
+          tokenPostfix: '',
+          tokenizer: {
+            root: [
+              [/\{\{!--/, 'comment.block.start.handlebars', '@commentBlock'],
+              [/\{\{!/, 'comment.start.handlebars', '@comment'],
+              [
+                /\{\{/,
+                {
+                  token: '@rematch',
+                  switchTo: '@handlebarsInSimpleState.root',
+                },
+              ],
+              [/<!DOCTYPE/, 'metatag.html', '@doctype'],
+              [/<!--/, 'comment.html', '@commentHtml'],
+              [
+                /(<)(\w+)(\/>)/,
+                ['delimiter.html', 'tag.html', 'delimiter.html'],
+              ],
+              [
+                /(<)(script)/,
+                ['delimiter.html', { token: 'tag.html', next: '@script' }],
+              ],
+              [
+                /(<)(style)/,
+                ['delimiter.html', { token: 'tag.html', next: '@style' }],
+              ],
+              [
+                /(<)([:\w]+)/,
+                ['delimiter.html', { token: 'tag.html', next: '@otherTag' }],
+              ],
+              [
+                /(<\/)(\w+)/,
+                ['delimiter.html', { token: 'tag.html', next: '@otherTag' }],
+              ],
+              [/</, 'delimiter.html'],
+              [/\{/, 'delimiter.html'],
+              [/[^<{]+/],
+            ],
+            doctype: [
+              [
+                /\{\{/,
+                {
+                  token: '@rematch',
+                  switchTo: '@handlebarsInSimpleState.comment',
+                },
+              ],
+              [/[^>]+/, 'metatag.content.html'],
+              [/>/, 'metatag.html', '@pop'],
+            ],
+            comment: [
+              [/\}\}/, 'comment.end.handlebars', '@pop'],
+              [/./, 'comment.content.handlebars'],
+            ],
+            commentBlock: [
+              [/--\}\}/, 'comment.block.end.handlebars', '@pop'],
+              [/./, 'comment.content.handlebars'],
+            ],
+            commentHtml: [
+              [
+                /\{\{/,
+                {
+                  token: '@rematch',
+                  switchTo: '@handlebarsInSimpleState.comment',
+                },
+              ],
+              [/-->/, 'comment.html', '@pop'],
+              [/[^-]+/, 'comment.content.html'],
+              [/./, 'comment.content.html'],
+            ],
+            otherTag: [
+              [
+                /\{\{/,
+                {
+                  token: '@rematch',
+                  switchTo: '@handlebarsInSimpleState.otherTag',
+                },
+              ],
+              [/\/?>/, 'delimiter.html', '@pop'],
+              [/"([^"]*)"/, 'attribute.value'],
+              [/'([^']*)'/, 'attribute.value'],
+              [/[\w\-]+/, 'attribute.name'],
+              [/=/, 'delimiter'],
+              [/[ \t\r\n]+/],
+            ],
+            script: [
+              [
+                /\{\{/,
+                {
+                  token: '@rematch',
+                  switchTo: '@handlebarsInSimpleState.script',
+                },
+              ],
+              [/type/, 'attribute.name', '@scriptAfterType'],
+              [/"([^"]*)"/, 'attribute.value'],
+              [/'([^']*)'/, 'attribute.value'],
+              [/[\w\-]+/, 'attribute.name'],
+              [/=/, 'delimiter'],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@scriptEmbedded.text/javascript',
+                  nextEmbedded: 'text/javascript',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [
+                /(<\/)(script\s*)(>)/,
+                [
+                  'delimiter.html',
+                  'tag.html',
+                  { token: 'delimiter.html', next: '@pop' },
+                ],
+              ],
+            ],
+            scriptAfterType: [
+              [
+                /\{\{/,
+                {
+                  token: '@rematch',
+                  switchTo: '@handlebarsInSimpleState.scriptAfterType',
+                },
+              ],
+              [/=/, 'delimiter', '@scriptAfterTypeEquals'],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@scriptEmbedded.text/javascript',
+                  nextEmbedded: 'text/javascript',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            scriptAfterTypeEquals: [
+              [
+                /\{\{/,
+                {
+                  token: '@rematch',
+                  switchTo: '@handlebarsInSimpleState.scriptAfterTypeEquals',
+                },
+              ],
+              [
+                /"([^"]*)"/,
+                {
+                  token: 'attribute.value',
+                  switchTo: '@scriptWithCustomType.$1',
+                },
+              ],
+              [
+                /'([^']*)'/,
+                {
+                  token: 'attribute.value',
+                  switchTo: '@scriptWithCustomType.$1',
+                },
+              ],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@scriptEmbedded.text/javascript',
+                  nextEmbedded: 'text/javascript',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            scriptWithCustomType: [
+              [
+                /\{\{/,
+                {
+                  token: '@rematch',
+                  switchTo: '@handlebarsInSimpleState.scriptWithCustomType.$S2',
+                },
+              ],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@scriptEmbedded.$S2',
+                  nextEmbedded: '$S2',
+                },
+              ],
+              [/"([^"]*)"/, 'attribute.value'],
+              [/'([^']*)'/, 'attribute.value'],
+              [/[\w\-]+/, 'attribute.name'],
+              [/=/, 'delimiter'],
+              [/[ \t\r\n]+/],
+              [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            scriptEmbedded: [
+              [
+                /\{\{/,
+                {
+                  token: '@rematch',
+                  switchTo: '@handlebarsInEmbeddedState.scriptEmbedded.$S2',
+                  nextEmbedded: '@pop',
+                },
+              ],
+              [
+                /<\/script/,
+                { token: '@rematch', next: '@pop', nextEmbedded: '@pop' },
+              ],
+            ],
+            style: [
+              [
+                /\{\{/,
+                {
+                  token: '@rematch',
+                  switchTo: '@handlebarsInSimpleState.style',
+                },
+              ],
+              [/type/, 'attribute.name', '@styleAfterType'],
+              [/"([^"]*)"/, 'attribute.value'],
+              [/'([^']*)'/, 'attribute.value'],
+              [/[\w\-]+/, 'attribute.name'],
+              [/=/, 'delimiter'],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@styleEmbedded.text/css',
+                  nextEmbedded: 'text/css',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [
+                /(<\/)(style\s*)(>)/,
+                [
+                  'delimiter.html',
+                  'tag.html',
+                  { token: 'delimiter.html', next: '@pop' },
+                ],
+              ],
+            ],
+            styleAfterType: [
+              [
+                /\{\{/,
+                {
+                  token: '@rematch',
+                  switchTo: '@handlebarsInSimpleState.styleAfterType',
+                },
+              ],
+              [/=/, 'delimiter', '@styleAfterTypeEquals'],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@styleEmbedded.text/css',
+                  nextEmbedded: 'text/css',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            styleAfterTypeEquals: [
+              [
+                /\{\{/,
+                {
+                  token: '@rematch',
+                  switchTo: '@handlebarsInSimpleState.styleAfterTypeEquals',
+                },
+              ],
+              [
+                /"([^"]*)"/,
+                {
+                  token: 'attribute.value',
+                  switchTo: '@styleWithCustomType.$1',
+                },
+              ],
+              [
+                /'([^']*)'/,
+                {
+                  token: 'attribute.value',
+                  switchTo: '@styleWithCustomType.$1',
+                },
+              ],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@styleEmbedded.text/css',
+                  nextEmbedded: 'text/css',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            styleWithCustomType: [
+              [
+                /\{\{/,
+                {
+                  token: '@rematch',
+                  switchTo: '@handlebarsInSimpleState.styleWithCustomType.$S2',
+                },
+              ],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@styleEmbedded.$S2',
+                  nextEmbedded: '$S2',
+                },
+              ],
+              [/"([^"]*)"/, 'attribute.value'],
+              [/'([^']*)'/, 'attribute.value'],
+              [/[\w\-]+/, 'attribute.name'],
+              [/=/, 'delimiter'],
+              [/[ \t\r\n]+/],
+              [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            styleEmbedded: [
+              [
+                /\{\{/,
+                {
+                  token: '@rematch',
+                  switchTo: '@handlebarsInEmbeddedState.styleEmbedded.$S2',
+                  nextEmbedded: '@pop',
+                },
+              ],
+              [
+                /<\/style/,
+                { token: '@rematch', next: '@pop', nextEmbedded: '@pop' },
+              ],
+            ],
+            handlebarsInSimpleState: [
+              [/\{\{\{?/, 'delimiter.handlebars'],
+              [
+                /\}\}\}?/,
+                { token: 'delimiter.handlebars', switchTo: '@$S2.$S3' },
+              ],
+              { include: 'handlebarsRoot' },
+            ],
+            handlebarsInEmbeddedState: [
+              [/\{\{\{?/, 'delimiter.handlebars'],
+              [
+                /\}\}\}?/,
+                {
+                  token: 'delimiter.handlebars',
+                  switchTo: '@$S2.$S3',
+                  nextEmbedded: '$S3',
+                },
+              ],
+              { include: 'handlebarsRoot' },
+            ],
+            handlebarsRoot: [
+              [/"[^"]*"/, 'string.handlebars'],
+              [/[#/][^\s}]+/, 'keyword.helper.handlebars'],
+              [/else\b/, 'keyword.helper.handlebars'],
+              [/[\s]+/],
+              [/[^}]/, 'variable.parameter.handlebars'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/5849.5849.js

@@ -0,0 +1,128 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [5849],
+  {
+    25849: (e, s, o) => {
+      'use strict';
+      o.r(s), o.d(s, { conf: () => n, language: () => l });
+      var n = {
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+        },
+        l = {
+          defaultToken: '',
+          tokenPostfix: '.dockerfile',
+          variable: /\${?[\w]+}?/,
+          tokenizer: {
+            root: [
+              { include: '@whitespace' },
+              { include: '@comment' },
+              [/(ONBUILD)(\s+)/, ['keyword', '']],
+              [
+                /(ENV)(\s+)([\w]+)/,
+                ['keyword', '', { token: 'variable', next: '@arguments' }],
+              ],
+              [
+                /(FROM|MAINTAINER|RUN|EXPOSE|ENV|ADD|ARG|VOLUME|LABEL|USER|WORKDIR|COPY|CMD|STOPSIGNAL|SHELL|HEALTHCHECK|ENTRYPOINT)/,
+                { token: 'keyword', next: '@arguments' },
+              ],
+            ],
+            arguments: [
+              { include: '@whitespace' },
+              { include: '@strings' },
+              [
+                /(@variable)/,
+                {
+                  cases: {
+                    '@eos': { token: 'variable', next: '@popall' },
+                    '@default': 'variable',
+                  },
+                },
+              ],
+              [/\\/, { cases: { '@eos': '', '@default': '' } }],
+              [
+                /./,
+                {
+                  cases: {
+                    '@eos': { token: '', next: '@popall' },
+                    '@default': '',
+                  },
+                },
+              ],
+            ],
+            whitespace: [
+              [
+                /\s+/,
+                {
+                  cases: {
+                    '@eos': { token: '', next: '@popall' },
+                    '@default': '',
+                  },
+                },
+              ],
+            ],
+            comment: [[/(^#.*$)/, 'comment', '@popall']],
+            strings: [
+              [/\\'$/, '', '@popall'],
+              [/\\'/, ''],
+              [/'$/, 'string', '@popall'],
+              [/'/, 'string', '@stringBody'],
+              [/"$/, 'string', '@popall'],
+              [/"/, 'string', '@dblStringBody'],
+            ],
+            stringBody: [
+              [
+                /[^\\\$']/,
+                {
+                  cases: {
+                    '@eos': { token: 'string', next: '@popall' },
+                    '@default': 'string',
+                  },
+                },
+              ],
+              [/\\./, 'string.escape'],
+              [/'$/, 'string', '@popall'],
+              [/'/, 'string', '@pop'],
+              [/(@variable)/, 'variable'],
+              [/\\$/, 'string'],
+              [/$/, 'string', '@popall'],
+            ],
+            dblStringBody: [
+              [
+                /[^\\\$"]/,
+                {
+                  cases: {
+                    '@eos': { token: 'string', next: '@popall' },
+                    '@default': 'string',
+                  },
+                },
+              ],
+              [/\\./, 'string.escape'],
+              [/"$/, 'string', '@popall'],
+              [/"/, 'string', '@pop'],
+              [/(@variable)/, 'variable'],
+              [/\\$/, 'string'],
+              [/$/, 'string', '@popall'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/6082.6082.js

@@ -0,0 +1,237 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [6082],
+  {
+    86082: (e, t, o) => {
+      'use strict';
+      o.r(t), o.d(t, { conf: () => r, language: () => n });
+      var r = {
+          wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+          comments: { lineComment: '//', blockComment: ['{', '}'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+            ['<', '>'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '<', close: '>' },
+            { open: "'", close: "'" },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '<', close: '>' },
+            { open: "'", close: "'" },
+          ],
+          folding: {
+            markers: {
+              start: new RegExp("^\\s*\\{\\$REGION(\\s\\'.*\\')?\\}"),
+              end: new RegExp('^\\s*\\{\\$ENDREGION\\}'),
+            },
+          },
+        },
+        n = {
+          defaultToken: '',
+          tokenPostfix: '.pascal',
+          ignoreCase: !0,
+          brackets: [
+            { open: '{', close: '}', token: 'delimiter.curly' },
+            { open: '[', close: ']', token: 'delimiter.square' },
+            { open: '(', close: ')', token: 'delimiter.parenthesis' },
+            { open: '<', close: '>', token: 'delimiter.angle' },
+          ],
+          keywords: [
+            'absolute',
+            'abstract',
+            'all',
+            'and_then',
+            'array',
+            'as',
+            'asm',
+            'attribute',
+            'begin',
+            'bindable',
+            'case',
+            'class',
+            'const',
+            'contains',
+            'default',
+            'div',
+            'else',
+            'end',
+            'except',
+            'exports',
+            'external',
+            'far',
+            'file',
+            'finalization',
+            'finally',
+            'forward',
+            'generic',
+            'goto',
+            'if',
+            'implements',
+            'import',
+            'in',
+            'index',
+            'inherited',
+            'initialization',
+            'interrupt',
+            'is',
+            'label',
+            'library',
+            'mod',
+            'module',
+            'name',
+            'near',
+            'not',
+            'object',
+            'of',
+            'on',
+            'only',
+            'operator',
+            'or_else',
+            'otherwise',
+            'override',
+            'package',
+            'packed',
+            'pow',
+            'private',
+            'program',
+            'protected',
+            'public',
+            'published',
+            'interface',
+            'implementation',
+            'qualified',
+            'read',
+            'record',
+            'resident',
+            'requires',
+            'resourcestring',
+            'restricted',
+            'segment',
+            'set',
+            'shl',
+            'shr',
+            'specialize',
+            'stored',
+            'then',
+            'threadvar',
+            'to',
+            'try',
+            'type',
+            'unit',
+            'uses',
+            'var',
+            'view',
+            'virtual',
+            'dynamic',
+            'overload',
+            'reintroduce',
+            'with',
+            'write',
+            'xor',
+            'true',
+            'false',
+            'procedure',
+            'function',
+            'constructor',
+            'destructor',
+            'property',
+            'break',
+            'continue',
+            'exit',
+            'abort',
+            'while',
+            'do',
+            'for',
+            'raise',
+            'repeat',
+            'until',
+          ],
+          typeKeywords: [
+            'boolean',
+            'double',
+            'byte',
+            'integer',
+            'shortint',
+            'char',
+            'longint',
+            'float',
+            'string',
+          ],
+          operators: [
+            '=',
+            '>',
+            '<',
+            '<=',
+            '>=',
+            '<>',
+            ':',
+            ':=',
+            'and',
+            'or',
+            '+',
+            '-',
+            '*',
+            '/',
+            '@',
+            '&',
+            '^',
+            '%',
+          ],
+          symbols: /[=><:@\^&|+\-*\/\^%]+/,
+          tokenizer: {
+            root: [
+              [
+                /[a-zA-Z_][\w]*/,
+                {
+                  cases: {
+                    '@keywords': { token: 'keyword.$0' },
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+              { include: '@whitespace' },
+              [/[{}()\[\]]/, '@brackets'],
+              [/[<>](?!@symbols)/, '@brackets'],
+              [
+                /@symbols/,
+                { cases: { '@operators': 'delimiter', '@default': '' } },
+              ],
+              [/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
+              [/\$[0-9a-fA-F]{1,16}/, 'number.hex'],
+              [/\d+/, 'number'],
+              [/[;,.]/, 'delimiter'],
+              [/'([^'\\]|\\.)*$/, 'string.invalid'],
+              [/'/, 'string', '@string'],
+              [/'[^\\']'/, 'string'],
+              [/'/, 'string.invalid'],
+              [/\#\d+/, 'string'],
+            ],
+            comment: [
+              [/[^\*\}]+/, 'comment'],
+              [/\}/, 'comment', '@pop'],
+              [/[\{]/, 'comment'],
+            ],
+            string: [
+              [/[^\\']+/, 'string'],
+              [/\\./, 'string.escape.invalid'],
+              [/'/, { token: 'string.quote', bracket: '@close', next: '@pop' }],
+            ],
+            whitespace: [
+              [/[ \t\r\n]+/, 'white'],
+              [/\{/, 'comment', '@comment'],
+              [/\/\/.*$/, 'comment'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/6241.6241.js

@@ -0,0 +1,212 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [6241],
+  {
+    96241: (e, n, t) => {
+      'use strict';
+      t.r(n), t.d(n, { conf: () => s, language: () => i });
+      var s = {
+          comments: { lineComment: '//', blockComment: ['(*', '*)'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          folding: {
+            markers: {
+              start: new RegExp(
+                '^\\s*//\\s*#region\\b|^\\s*\\(\\*\\s*#region(.*)\\*\\)'
+              ),
+              end: new RegExp(
+                '^\\s*//\\s*#endregion\\b|^\\s*\\(\\*\\s*#endregion\\s*\\*\\)'
+              ),
+            },
+          },
+        },
+        i = {
+          defaultToken: '',
+          tokenPostfix: '.fs',
+          keywords: [
+            'abstract',
+            'and',
+            'atomic',
+            'as',
+            'assert',
+            'asr',
+            'base',
+            'begin',
+            'break',
+            'checked',
+            'component',
+            'const',
+            'constraint',
+            'constructor',
+            'continue',
+            'class',
+            'default',
+            'delegate',
+            'do',
+            'done',
+            'downcast',
+            'downto',
+            'elif',
+            'else',
+            'end',
+            'exception',
+            'eager',
+            'event',
+            'external',
+            'extern',
+            'false',
+            'finally',
+            'for',
+            'fun',
+            'function',
+            'fixed',
+            'functor',
+            'global',
+            'if',
+            'in',
+            'include',
+            'inherit',
+            'inline',
+            'interface',
+            'internal',
+            'land',
+            'lor',
+            'lsl',
+            'lsr',
+            'lxor',
+            'lazy',
+            'let',
+            'match',
+            'member',
+            'mod',
+            'module',
+            'mutable',
+            'namespace',
+            'method',
+            'mixin',
+            'new',
+            'not',
+            'null',
+            'of',
+            'open',
+            'or',
+            'object',
+            'override',
+            'private',
+            'parallel',
+            'process',
+            'protected',
+            'pure',
+            'public',
+            'rec',
+            'return',
+            'static',
+            'sealed',
+            'struct',
+            'sig',
+            'then',
+            'to',
+            'true',
+            'tailcall',
+            'trait',
+            'try',
+            'type',
+            'upcast',
+            'use',
+            'val',
+            'void',
+            'virtual',
+            'volatile',
+            'when',
+            'while',
+            'with',
+            'yield',
+          ],
+          symbols: /[=><!~?:&|+\-*\^%;\.,\/]+/,
+          escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+          integersuffix: /[uU]?[yslnLI]?/,
+          floatsuffix: /[fFmM]?/,
+          tokenizer: {
+            root: [
+              [
+                /[a-zA-Z_]\w*/,
+                {
+                  cases: {
+                    '@keywords': { token: 'keyword.$0' },
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+              { include: '@whitespace' },
+              [/\[<.*>\]/, 'annotation'],
+              [/^#(if|else|endif)/, 'keyword'],
+              [/[{}()\[\]]/, '@brackets'],
+              [/[<>](?!@symbols)/, '@brackets'],
+              [/@symbols/, 'delimiter'],
+              [/\d*\d+[eE]([\-+]?\d+)?(@floatsuffix)/, 'number.float'],
+              [/\d*\.\d+([eE][\-+]?\d+)?(@floatsuffix)/, 'number.float'],
+              [/0x[0-9a-fA-F]+LF/, 'number.float'],
+              [/0x[0-9a-fA-F]+(@integersuffix)/, 'number.hex'],
+              [/0b[0-1]+(@integersuffix)/, 'number.bin'],
+              [/\d+(@integersuffix)/, 'number'],
+              [/[;,.]/, 'delimiter'],
+              [/"([^"\\]|\\.)*$/, 'string.invalid'],
+              [/"""/, 'string', '@string."""'],
+              [/"/, 'string', '@string."'],
+              [/\@"/, { token: 'string.quote', next: '@litstring' }],
+              [/'[^\\']'B?/, 'string'],
+              [/(')(@escapes)(')/, ['string', 'string.escape', 'string']],
+              [/'/, 'string.invalid'],
+            ],
+            whitespace: [
+              [/[ \t\r\n]+/, ''],
+              [/\(\*(?!\))/, 'comment', '@comment'],
+              [/\/\/.*$/, 'comment'],
+            ],
+            comment: [
+              [/[^*(]+/, 'comment'],
+              [/\*\)/, 'comment', '@pop'],
+              [/\*/, 'comment'],
+              [/\(\*\)/, 'comment'],
+              [/\(/, 'comment'],
+            ],
+            string: [
+              [/[^\\"]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [
+                /("""|"B?)/,
+                {
+                  cases: {
+                    '$#==$S2': { token: 'string', next: '@pop' },
+                    '@default': 'string',
+                  },
+                },
+              ],
+            ],
+            litstring: [
+              [/[^"]+/, 'string'],
+              [/""/, 'string.escape'],
+              [/"/, { token: 'string.quote', next: '@pop' }],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/6424.6424.js

@@ -0,0 +1,572 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [6424],
+  {
+    76424: (e, t, r) => {
+      'use strict';
+      r.r(t), r.d(t, { conf: () => m, language: () => n });
+      var o = r(89587),
+        i = [
+          'area',
+          'base',
+          'br',
+          'col',
+          'embed',
+          'hr',
+          'img',
+          'input',
+          'keygen',
+          'link',
+          'menuitem',
+          'meta',
+          'param',
+          'source',
+          'track',
+          'wbr',
+        ],
+        m = {
+          wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\$\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\s]+)/g,
+          comments: { blockComment: ['\x3c!--', '--\x3e'] },
+          brackets: [
+            ['\x3c!--', '--\x3e'],
+            ['<', '>'],
+            ['{', '}'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          surroundingPairs: [
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+            { open: '<', close: '>' },
+          ],
+          onEnterRules: [
+            {
+              beforeText: new RegExp(
+                '<(?!(?:' +
+                  i.join('|') +
+                  '))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$',
+                'i'
+              ),
+              afterText: /^<\/(\w[\w\d]*)\s*>$/i,
+              action: { indentAction: o.Mj.IndentAction.IndentOutdent },
+            },
+            {
+              beforeText: new RegExp(
+                '<(?!(?:' +
+                  i.join('|') +
+                  '))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$',
+                'i'
+              ),
+              action: { indentAction: o.Mj.IndentAction.Indent },
+            },
+          ],
+        },
+        n = {
+          defaultToken: '',
+          tokenPostfix: '',
+          tokenizer: {
+            root: [
+              [/@@/],
+              [
+                /@[^@]/,
+                { token: '@rematch', switchTo: '@razorInSimpleState.root' },
+              ],
+              [/<!DOCTYPE/, 'metatag.html', '@doctype'],
+              [/<!--/, 'comment.html', '@comment'],
+              [
+                /(<)(\w+)(\/>)/,
+                ['delimiter.html', 'tag.html', 'delimiter.html'],
+              ],
+              [
+                /(<)(script)/,
+                ['delimiter.html', { token: 'tag.html', next: '@script' }],
+              ],
+              [
+                /(<)(style)/,
+                ['delimiter.html', { token: 'tag.html', next: '@style' }],
+              ],
+              [
+                /(<)([:\w]+)/,
+                ['delimiter.html', { token: 'tag.html', next: '@otherTag' }],
+              ],
+              [
+                /(<\/)(\w+)/,
+                ['delimiter.html', { token: 'tag.html', next: '@otherTag' }],
+              ],
+              [/</, 'delimiter.html'],
+              [/[ \t\r\n]+/],
+              [/[^<@]+/],
+            ],
+            doctype: [
+              [
+                /@[^@]/,
+                { token: '@rematch', switchTo: '@razorInSimpleState.comment' },
+              ],
+              [/[^>]+/, 'metatag.content.html'],
+              [/>/, 'metatag.html', '@pop'],
+            ],
+            comment: [
+              [
+                /@[^@]/,
+                { token: '@rematch', switchTo: '@razorInSimpleState.comment' },
+              ],
+              [/-->/, 'comment.html', '@pop'],
+              [/[^-]+/, 'comment.content.html'],
+              [/./, 'comment.content.html'],
+            ],
+            otherTag: [
+              [
+                /@[^@]/,
+                { token: '@rematch', switchTo: '@razorInSimpleState.otherTag' },
+              ],
+              [/\/?>/, 'delimiter.html', '@pop'],
+              [/"([^"]*)"/, 'attribute.value'],
+              [/'([^']*)'/, 'attribute.value'],
+              [/[\w\-]+/, 'attribute.name'],
+              [/=/, 'delimiter'],
+              [/[ \t\r\n]+/],
+            ],
+            script: [
+              [
+                /@[^@]/,
+                { token: '@rematch', switchTo: '@razorInSimpleState.script' },
+              ],
+              [/type/, 'attribute.name', '@scriptAfterType'],
+              [/"([^"]*)"/, 'attribute.value'],
+              [/'([^']*)'/, 'attribute.value'],
+              [/[\w\-]+/, 'attribute.name'],
+              [/=/, 'delimiter'],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@scriptEmbedded.text/javascript',
+                  nextEmbedded: 'text/javascript',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [
+                /(<\/)(script\s*)(>)/,
+                [
+                  'delimiter.html',
+                  'tag.html',
+                  { token: 'delimiter.html', next: '@pop' },
+                ],
+              ],
+            ],
+            scriptAfterType: [
+              [
+                /@[^@]/,
+                {
+                  token: '@rematch',
+                  switchTo: '@razorInSimpleState.scriptAfterType',
+                },
+              ],
+              [/=/, 'delimiter', '@scriptAfterTypeEquals'],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@scriptEmbedded.text/javascript',
+                  nextEmbedded: 'text/javascript',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            scriptAfterTypeEquals: [
+              [
+                /@[^@]/,
+                {
+                  token: '@rematch',
+                  switchTo: '@razorInSimpleState.scriptAfterTypeEquals',
+                },
+              ],
+              [
+                /"([^"]*)"/,
+                {
+                  token: 'attribute.value',
+                  switchTo: '@scriptWithCustomType.$1',
+                },
+              ],
+              [
+                /'([^']*)'/,
+                {
+                  token: 'attribute.value',
+                  switchTo: '@scriptWithCustomType.$1',
+                },
+              ],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@scriptEmbedded.text/javascript',
+                  nextEmbedded: 'text/javascript',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            scriptWithCustomType: [
+              [
+                /@[^@]/,
+                {
+                  token: '@rematch',
+                  switchTo: '@razorInSimpleState.scriptWithCustomType.$S2',
+                },
+              ],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@scriptEmbedded.$S2',
+                  nextEmbedded: '$S2',
+                },
+              ],
+              [/"([^"]*)"/, 'attribute.value'],
+              [/'([^']*)'/, 'attribute.value'],
+              [/[\w\-]+/, 'attribute.name'],
+              [/=/, 'delimiter'],
+              [/[ \t\r\n]+/],
+              [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            scriptEmbedded: [
+              [
+                /@[^@]/,
+                {
+                  token: '@rematch',
+                  switchTo: '@razorInEmbeddedState.scriptEmbedded.$S2',
+                  nextEmbedded: '@pop',
+                },
+              ],
+              [
+                /<\/script/,
+                { token: '@rematch', next: '@pop', nextEmbedded: '@pop' },
+              ],
+            ],
+            style: [
+              [
+                /@[^@]/,
+                { token: '@rematch', switchTo: '@razorInSimpleState.style' },
+              ],
+              [/type/, 'attribute.name', '@styleAfterType'],
+              [/"([^"]*)"/, 'attribute.value'],
+              [/'([^']*)'/, 'attribute.value'],
+              [/[\w\-]+/, 'attribute.name'],
+              [/=/, 'delimiter'],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@styleEmbedded.text/css',
+                  nextEmbedded: 'text/css',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [
+                /(<\/)(style\s*)(>)/,
+                [
+                  'delimiter.html',
+                  'tag.html',
+                  { token: 'delimiter.html', next: '@pop' },
+                ],
+              ],
+            ],
+            styleAfterType: [
+              [
+                /@[^@]/,
+                {
+                  token: '@rematch',
+                  switchTo: '@razorInSimpleState.styleAfterType',
+                },
+              ],
+              [/=/, 'delimiter', '@styleAfterTypeEquals'],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@styleEmbedded.text/css',
+                  nextEmbedded: 'text/css',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            styleAfterTypeEquals: [
+              [
+                /@[^@]/,
+                {
+                  token: '@rematch',
+                  switchTo: '@razorInSimpleState.styleAfterTypeEquals',
+                },
+              ],
+              [
+                /"([^"]*)"/,
+                {
+                  token: 'attribute.value',
+                  switchTo: '@styleWithCustomType.$1',
+                },
+              ],
+              [
+                /'([^']*)'/,
+                {
+                  token: 'attribute.value',
+                  switchTo: '@styleWithCustomType.$1',
+                },
+              ],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@styleEmbedded.text/css',
+                  nextEmbedded: 'text/css',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            styleWithCustomType: [
+              [
+                /@[^@]/,
+                {
+                  token: '@rematch',
+                  switchTo: '@razorInSimpleState.styleWithCustomType.$S2',
+                },
+              ],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@styleEmbedded.$S2',
+                  nextEmbedded: '$S2',
+                },
+              ],
+              [/"([^"]*)"/, 'attribute.value'],
+              [/'([^']*)'/, 'attribute.value'],
+              [/[\w\-]+/, 'attribute.name'],
+              [/=/, 'delimiter'],
+              [/[ \t\r\n]+/],
+              [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            styleEmbedded: [
+              [
+                /@[^@]/,
+                {
+                  token: '@rematch',
+                  switchTo: '@razorInEmbeddedState.styleEmbedded.$S2',
+                  nextEmbedded: '@pop',
+                },
+              ],
+              [
+                /<\/style/,
+                { token: '@rematch', next: '@pop', nextEmbedded: '@pop' },
+              ],
+            ],
+            razorInSimpleState: [
+              [/@\*/, 'comment.cs', '@razorBlockCommentTopLevel'],
+              [/@[{(]/, 'metatag.cs', '@razorRootTopLevel'],
+              [
+                /(@)(\s*[\w]+)/,
+                [
+                  'metatag.cs',
+                  { token: 'identifier.cs', switchTo: '@$S2.$S3' },
+                ],
+              ],
+              [/[})]/, { token: 'metatag.cs', switchTo: '@$S2.$S3' }],
+              [/\*@/, { token: 'comment.cs', switchTo: '@$S2.$S3' }],
+            ],
+            razorInEmbeddedState: [
+              [/@\*/, 'comment.cs', '@razorBlockCommentTopLevel'],
+              [/@[{(]/, 'metatag.cs', '@razorRootTopLevel'],
+              [
+                /(@)(\s*[\w]+)/,
+                [
+                  'metatag.cs',
+                  {
+                    token: 'identifier.cs',
+                    switchTo: '@$S2.$S3',
+                    nextEmbedded: '$S3',
+                  },
+                ],
+              ],
+              [
+                /[})]/,
+                {
+                  token: 'metatag.cs',
+                  switchTo: '@$S2.$S3',
+                  nextEmbedded: '$S3',
+                },
+              ],
+              [
+                /\*@/,
+                {
+                  token: 'comment.cs',
+                  switchTo: '@$S2.$S3',
+                  nextEmbedded: '$S3',
+                },
+              ],
+            ],
+            razorBlockCommentTopLevel: [
+              [/\*@/, '@rematch', '@pop'],
+              [/[^*]+/, 'comment.cs'],
+              [/./, 'comment.cs'],
+            ],
+            razorBlockComment: [
+              [/\*@/, 'comment.cs', '@pop'],
+              [/[^*]+/, 'comment.cs'],
+              [/./, 'comment.cs'],
+            ],
+            razorRootTopLevel: [
+              [/\{/, 'delimiter.bracket.cs', '@razorRoot'],
+              [/\(/, 'delimiter.parenthesis.cs', '@razorRoot'],
+              [/[})]/, '@rematch', '@pop'],
+              { include: 'razorCommon' },
+            ],
+            razorRoot: [
+              [/\{/, 'delimiter.bracket.cs', '@razorRoot'],
+              [/\(/, 'delimiter.parenthesis.cs', '@razorRoot'],
+              [/\}/, 'delimiter.bracket.cs', '@pop'],
+              [/\)/, 'delimiter.parenthesis.cs', '@pop'],
+              { include: 'razorCommon' },
+            ],
+            razorCommon: [
+              [
+                /[a-zA-Z_]\w*/,
+                {
+                  cases: {
+                    '@razorKeywords': { token: 'keyword.cs' },
+                    '@default': 'identifier.cs',
+                  },
+                },
+              ],
+              [/[\[\]]/, 'delimiter.array.cs'],
+              [/[ \t\r\n]+/],
+              [/\/\/.*$/, 'comment.cs'],
+              [/@\*/, 'comment.cs', '@razorBlockComment'],
+              [/"([^"]*)"/, 'string.cs'],
+              [/'([^']*)'/, 'string.cs'],
+              [
+                /(<)(\w+)(\/>)/,
+                ['delimiter.html', 'tag.html', 'delimiter.html'],
+              ],
+              [/(<)(\w+)(>)/, ['delimiter.html', 'tag.html', 'delimiter.html']],
+              [
+                /(<\/)(\w+)(>)/,
+                ['delimiter.html', 'tag.html', 'delimiter.html'],
+              ],
+              [/[\+\-\*\%\&\|\^\~\!\=\<\>\/\?\;\:\.\,]/, 'delimiter.cs'],
+              [/\d*\d+[eE]([\-+]?\d+)?/, 'number.float.cs'],
+              [/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float.cs'],
+              [/0[xX][0-9a-fA-F']*[0-9a-fA-F]/, 'number.hex.cs'],
+              [/0[0-7']*[0-7]/, 'number.octal.cs'],
+              [/0[bB][0-1']*[0-1]/, 'number.binary.cs'],
+              [/\d[\d']*/, 'number.cs'],
+              [/\d/, 'number.cs'],
+            ],
+          },
+          razorKeywords: [
+            'abstract',
+            'as',
+            'async',
+            'await',
+            'base',
+            'bool',
+            'break',
+            'by',
+            'byte',
+            'case',
+            'catch',
+            'char',
+            'checked',
+            'class',
+            'const',
+            'continue',
+            'decimal',
+            'default',
+            'delegate',
+            'do',
+            'double',
+            'descending',
+            'explicit',
+            'event',
+            'extern',
+            'else',
+            'enum',
+            'false',
+            'finally',
+            'fixed',
+            'float',
+            'for',
+            'foreach',
+            'from',
+            'goto',
+            'group',
+            'if',
+            'implicit',
+            'in',
+            'int',
+            'interface',
+            'internal',
+            'into',
+            'is',
+            'lock',
+            'long',
+            'nameof',
+            'new',
+            'null',
+            'namespace',
+            'object',
+            'operator',
+            'out',
+            'override',
+            'orderby',
+            'params',
+            'private',
+            'protected',
+            'public',
+            'readonly',
+            'ref',
+            'return',
+            'switch',
+            'struct',
+            'sbyte',
+            'sealed',
+            'short',
+            'sizeof',
+            'stackalloc',
+            'static',
+            'string',
+            'select',
+            'this',
+            'throw',
+            'true',
+            'try',
+            'typeof',
+            'uint',
+            'ulong',
+            'unchecked',
+            'unsafe',
+            'ushort',
+            'using',
+            'var',
+            'virtual',
+            'volatile',
+            'void',
+            'when',
+            'while',
+            'where',
+            'yield',
+            'model',
+            'inject',
+          ],
+          escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+        };
+    },
+  },
+]);

docs/6449.6449.js

@@ -0,0 +1,804 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [6449],
+  {
+    56449: (e, _, t) => {
+      'use strict';
+      t.r(_), t.d(_, { conf: () => r, language: () => i });
+      var r = {
+          comments: { lineComment: '--', blockComment: ['/*', '*/'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+        },
+        i = {
+          defaultToken: '',
+          tokenPostfix: '.sql',
+          ignoreCase: !0,
+          brackets: [
+            { open: '[', close: ']', token: 'delimiter.square' },
+            { open: '(', close: ')', token: 'delimiter.parenthesis' },
+          ],
+          keywords: [
+            'AES128',
+            'AES256',
+            'ALL',
+            'ALLOWOVERWRITE',
+            'ANALYSE',
+            'ANALYZE',
+            'AND',
+            'ANY',
+            'ARRAY',
+            'AS',
+            'ASC',
+            'AUTHORIZATION',
+            'BACKUP',
+            'BETWEEN',
+            'BINARY',
+            'BLANKSASNULL',
+            'BOTH',
+            'BYTEDICT',
+            'BZIP2',
+            'CASE',
+            'CAST',
+            'CHECK',
+            'COLLATE',
+            'COLUMN',
+            'CONSTRAINT',
+            'CREATE',
+            'CREDENTIALS',
+            'CROSS',
+            'CURRENT_DATE',
+            'CURRENT_TIME',
+            'CURRENT_TIMESTAMP',
+            'CURRENT_USER',
+            'CURRENT_USER_ID',
+            'DEFAULT',
+            'DEFERRABLE',
+            'DEFLATE',
+            'DEFRAG',
+            'DELTA',
+            'DELTA32K',
+            'DESC',
+            'DISABLE',
+            'DISTINCT',
+            'DO',
+            'ELSE',
+            'EMPTYASNULL',
+            'ENABLE',
+            'ENCODE',
+            'ENCRYPT',
+            'ENCRYPTION',
+            'END',
+            'EXCEPT',
+            'EXPLICIT',
+            'FALSE',
+            'FOR',
+            'FOREIGN',
+            'FREEZE',
+            'FROM',
+            'FULL',
+            'GLOBALDICT256',
+            'GLOBALDICT64K',
+            'GRANT',
+            'GROUP',
+            'GZIP',
+            'HAVING',
+            'IDENTITY',
+            'IGNORE',
+            'ILIKE',
+            'IN',
+            'INITIALLY',
+            'INNER',
+            'INTERSECT',
+            'INTO',
+            'IS',
+            'ISNULL',
+            'JOIN',
+            'LEADING',
+            'LEFT',
+            'LIKE',
+            'LIMIT',
+            'LOCALTIME',
+            'LOCALTIMESTAMP',
+            'LUN',
+            'LUNS',
+            'LZO',
+            'LZOP',
+            'MINUS',
+            'MOSTLY13',
+            'MOSTLY32',
+            'MOSTLY8',
+            'NATURAL',
+            'NEW',
+            'NOT',
+            'NOTNULL',
+            'NULL',
+            'NULLS',
+            'OFF',
+            'OFFLINE',
+            'OFFSET',
+            'OID',
+            'OLD',
+            'ON',
+            'ONLY',
+            'OPEN',
+            'OR',
+            'ORDER',
+            'OUTER',
+            'OVERLAPS',
+            'PARALLEL',
+            'PARTITION',
+            'PERCENT',
+            'PERMISSIONS',
+            'PLACING',
+            'PRIMARY',
+            'RAW',
+            'READRATIO',
+            'RECOVER',
+            'REFERENCES',
+            'RESPECT',
+            'REJECTLOG',
+            'RESORT',
+            'RESTORE',
+            'RIGHT',
+            'SELECT',
+            'SESSION_USER',
+            'SIMILAR',
+            'SNAPSHOT',
+            'SOME',
+            'SYSDATE',
+            'SYSTEM',
+            'TABLE',
+            'TAG',
+            'TDES',
+            'TEXT255',
+            'TEXT32K',
+            'THEN',
+            'TIMESTAMP',
+            'TO',
+            'TOP',
+            'TRAILING',
+            'TRUE',
+            'TRUNCATECOLUMNS',
+            'UNION',
+            'UNIQUE',
+            'USER',
+            'USING',
+            'VERBOSE',
+            'WALLET',
+            'WHEN',
+            'WHERE',
+            'WITH',
+            'WITHOUT',
+          ],
+          operators: [
+            'AND',
+            'BETWEEN',
+            'IN',
+            'LIKE',
+            'NOT',
+            'OR',
+            'IS',
+            'NULL',
+            'INTERSECT',
+            'UNION',
+            'INNER',
+            'JOIN',
+            'LEFT',
+            'OUTER',
+            'RIGHT',
+          ],
+          builtinFunctions: [
+            'current_schema',
+            'current_schemas',
+            'has_database_privilege',
+            'has_schema_privilege',
+            'has_table_privilege',
+            'age',
+            'current_time',
+            'current_timestamp',
+            'localtime',
+            'isfinite',
+            'now',
+            'ascii',
+            'get_bit',
+            'get_byte',
+            'set_bit',
+            'set_byte',
+            'to_ascii',
+            'approximate percentile_disc',
+            'avg',
+            'count',
+            'listagg',
+            'max',
+            'median',
+            'min',
+            'percentile_cont',
+            'stddev_samp',
+            'stddev_pop',
+            'sum',
+            'var_samp',
+            'var_pop',
+            'bit_and',
+            'bit_or',
+            'bool_and',
+            'bool_or',
+            'cume_dist',
+            'first_value',
+            'lag',
+            'last_value',
+            'lead',
+            'nth_value',
+            'ratio_to_report',
+            'dense_rank',
+            'ntile',
+            'percent_rank',
+            'rank',
+            'row_number',
+            'case',
+            'coalesce',
+            'decode',
+            'greatest',
+            'least',
+            'nvl',
+            'nvl2',
+            'nullif',
+            'add_months',
+            'at time zone',
+            'convert_timezone',
+            'current_date',
+            'date_cmp',
+            'date_cmp_timestamp',
+            'date_cmp_timestamptz',
+            'date_part_year',
+            'dateadd',
+            'datediff',
+            'date_part',
+            'date_trunc',
+            'extract',
+            'getdate',
+            'interval_cmp',
+            'last_day',
+            'months_between',
+            'next_day',
+            'sysdate',
+            'timeofday',
+            'timestamp_cmp',
+            'timestamp_cmp_date',
+            'timestamp_cmp_timestamptz',
+            'timestamptz_cmp',
+            'timestamptz_cmp_date',
+            'timestamptz_cmp_timestamp',
+            'timezone',
+            'to_timestamp',
+            'trunc',
+            'abs',
+            'acos',
+            'asin',
+            'atan',
+            'atan2',
+            'cbrt',
+            'ceil',
+            'ceiling',
+            'checksum',
+            'cos',
+            'cot',
+            'degrees',
+            'dexp',
+            'dlog1',
+            'dlog10',
+            'exp',
+            'floor',
+            'ln',
+            'log',
+            'mod',
+            'pi',
+            'power',
+            'radians',
+            'random',
+            'round',
+            'sin',
+            'sign',
+            'sqrt',
+            'tan',
+            'to_hex',
+            'bpcharcmp',
+            'btrim',
+            'bttext_pattern_cmp',
+            'char_length',
+            'character_length',
+            'charindex',
+            'chr',
+            'concat',
+            'crc32',
+            'func_sha1',
+            'initcap',
+            'left and rights',
+            'len',
+            'length',
+            'lower',
+            'lpad and rpads',
+            'ltrim',
+            'md5',
+            'octet_length',
+            'position',
+            'quote_ident',
+            'quote_literal',
+            'regexp_count',
+            'regexp_instr',
+            'regexp_replace',
+            'regexp_substr',
+            'repeat',
+            'replace',
+            'replicate',
+            'reverse',
+            'rtrim',
+            'split_part',
+            'strpos',
+            'strtol',
+            'substring',
+            'textlen',
+            'translate',
+            'trim',
+            'upper',
+            'cast',
+            'convert',
+            'to_char',
+            'to_date',
+            'to_number',
+            'json_array_length',
+            'json_extract_array_element_text',
+            'json_extract_path_text',
+            'current_setting',
+            'pg_cancel_backend',
+            'pg_terminate_backend',
+            'set_config',
+            'current_database',
+            'current_user',
+            'current_user_id',
+            'pg_backend_pid',
+            'pg_last_copy_count',
+            'pg_last_copy_id',
+            'pg_last_query_id',
+            'pg_last_unload_count',
+            'session_user',
+            'slice_num',
+            'user',
+            'version',
+            'abbrev',
+            'acosd',
+            'any',
+            'area',
+            'array_agg',
+            'array_append',
+            'array_cat',
+            'array_dims',
+            'array_fill',
+            'array_length',
+            'array_lower',
+            'array_ndims',
+            'array_position',
+            'array_positions',
+            'array_prepend',
+            'array_remove',
+            'array_replace',
+            'array_to_json',
+            'array_to_string',
+            'array_to_tsvector',
+            'array_upper',
+            'asind',
+            'atan2d',
+            'atand',
+            'bit',
+            'bit_length',
+            'bound_box',
+            'box',
+            'brin_summarize_new_values',
+            'broadcast',
+            'cardinality',
+            'center',
+            'circle',
+            'clock_timestamp',
+            'col_description',
+            'concat_ws',
+            'convert_from',
+            'convert_to',
+            'corr',
+            'cosd',
+            'cotd',
+            'covar_pop',
+            'covar_samp',
+            'current_catalog',
+            'current_query',
+            'current_role',
+            'currval',
+            'cursor_to_xml',
+            'diameter',
+            'div',
+            'encode',
+            'enum_first',
+            'enum_last',
+            'enum_range',
+            'every',
+            'family',
+            'format',
+            'format_type',
+            'generate_series',
+            'generate_subscripts',
+            'get_current_ts_config',
+            'gin_clean_pending_list',
+            'grouping',
+            'has_any_column_privilege',
+            'has_column_privilege',
+            'has_foreign_data_wrapper_privilege',
+            'has_function_privilege',
+            'has_language_privilege',
+            'has_sequence_privilege',
+            'has_server_privilege',
+            'has_tablespace_privilege',
+            'has_type_privilege',
+            'height',
+            'host',
+            'hostmask',
+            'inet_client_addr',
+            'inet_client_port',
+            'inet_merge',
+            'inet_same_family',
+            'inet_server_addr',
+            'inet_server_port',
+            'isclosed',
+            'isempty',
+            'isopen',
+            'json_agg',
+            'json_object',
+            'json_object_agg',
+            'json_populate_record',
+            'json_populate_recordset',
+            'json_to_record',
+            'json_to_recordset',
+            'jsonb_agg',
+            'jsonb_object_agg',
+            'justify_days',
+            'justify_hours',
+            'justify_interval',
+            'lastval',
+            'left',
+            'line',
+            'localtimestamp',
+            'lower_inc',
+            'lower_inf',
+            'lpad',
+            'lseg',
+            'make_date',
+            'make_interval',
+            'make_time',
+            'make_timestamp',
+            'make_timestamptz',
+            'masklen',
+            'mode',
+            'netmask',
+            'network',
+            'nextval',
+            'npoints',
+            'num_nonnulls',
+            'num_nulls',
+            'numnode',
+            'obj_description',
+            'overlay',
+            'parse_ident',
+            'path',
+            'pclose',
+            'percentile_disc',
+            'pg_advisory_lock',
+            'pg_advisory_lock_shared',
+            'pg_advisory_unlock',
+            'pg_advisory_unlock_all',
+            'pg_advisory_unlock_shared',
+            'pg_advisory_xact_lock',
+            'pg_advisory_xact_lock_shared',
+            'pg_backup_start_time',
+            'pg_blocking_pids',
+            'pg_client_encoding',
+            'pg_collation_is_visible',
+            'pg_column_size',
+            'pg_conf_load_time',
+            'pg_control_checkpoint',
+            'pg_control_init',
+            'pg_control_recovery',
+            'pg_control_system',
+            'pg_conversion_is_visible',
+            'pg_create_logical_replication_slot',
+            'pg_create_physical_replication_slot',
+            'pg_create_restore_point',
+            'pg_current_xlog_flush_location',
+            'pg_current_xlog_insert_location',
+            'pg_current_xlog_location',
+            'pg_database_size',
+            'pg_describe_object',
+            'pg_drop_replication_slot',
+            'pg_export_snapshot',
+            'pg_filenode_relation',
+            'pg_function_is_visible',
+            'pg_get_constraintdef',
+            'pg_get_expr',
+            'pg_get_function_arguments',
+            'pg_get_function_identity_arguments',
+            'pg_get_function_result',
+            'pg_get_functiondef',
+            'pg_get_indexdef',
+            'pg_get_keywords',
+            'pg_get_object_address',
+            'pg_get_owned_sequence',
+            'pg_get_ruledef',
+            'pg_get_serial_sequence',
+            'pg_get_triggerdef',
+            'pg_get_userbyid',
+            'pg_get_viewdef',
+            'pg_has_role',
+            'pg_identify_object',
+            'pg_identify_object_as_address',
+            'pg_index_column_has_property',
+            'pg_index_has_property',
+            'pg_indexam_has_property',
+            'pg_indexes_size',
+            'pg_is_in_backup',
+            'pg_is_in_recovery',
+            'pg_is_other_temp_schema',
+            'pg_is_xlog_replay_paused',
+            'pg_last_committed_xact',
+            'pg_last_xact_replay_timestamp',
+            'pg_last_xlog_receive_location',
+            'pg_last_xlog_replay_location',
+            'pg_listening_channels',
+            'pg_logical_emit_message',
+            'pg_logical_slot_get_binary_changes',
+            'pg_logical_slot_get_changes',
+            'pg_logical_slot_peek_binary_changes',
+            'pg_logical_slot_peek_changes',
+            'pg_ls_dir',
+            'pg_my_temp_schema',
+            'pg_notification_queue_usage',
+            'pg_opclass_is_visible',
+            'pg_operator_is_visible',
+            'pg_opfamily_is_visible',
+            'pg_options_to_table',
+            'pg_postmaster_start_time',
+            'pg_read_binary_file',
+            'pg_read_file',
+            'pg_relation_filenode',
+            'pg_relation_filepath',
+            'pg_relation_size',
+            'pg_reload_conf',
+            'pg_replication_origin_create',
+            'pg_replication_origin_drop',
+            'pg_replication_origin_oid',
+            'pg_replication_origin_progress',
+            'pg_replication_origin_session_is_setup',
+            'pg_replication_origin_session_progress',
+            'pg_replication_origin_session_reset',
+            'pg_replication_origin_session_setup',
+            'pg_replication_origin_xact_reset',
+            'pg_replication_origin_xact_setup',
+            'pg_rotate_logfile',
+            'pg_size_bytes',
+            'pg_size_pretty',
+            'pg_sleep',
+            'pg_sleep_for',
+            'pg_sleep_until',
+            'pg_start_backup',
+            'pg_stat_file',
+            'pg_stop_backup',
+            'pg_switch_xlog',
+            'pg_table_is_visible',
+            'pg_table_size',
+            'pg_tablespace_databases',
+            'pg_tablespace_location',
+            'pg_tablespace_size',
+            'pg_total_relation_size',
+            'pg_trigger_depth',
+            'pg_try_advisory_lock',
+            'pg_try_advisory_lock_shared',
+            'pg_try_advisory_xact_lock',
+            'pg_try_advisory_xact_lock_shared',
+            'pg_ts_config_is_visible',
+            'pg_ts_dict_is_visible',
+            'pg_ts_parser_is_visible',
+            'pg_ts_template_is_visible',
+            'pg_type_is_visible',
+            'pg_typeof',
+            'pg_xact_commit_timestamp',
+            'pg_xlog_location_diff',
+            'pg_xlog_replay_pause',
+            'pg_xlog_replay_resume',
+            'pg_xlogfile_name',
+            'pg_xlogfile_name_offset',
+            'phraseto_tsquery',
+            'plainto_tsquery',
+            'point',
+            'polygon',
+            'popen',
+            'pqserverversion',
+            'query_to_xml',
+            'querytree',
+            'quote_nullable',
+            'radius',
+            'range_merge',
+            'regexp_matches',
+            'regexp_split_to_array',
+            'regexp_split_to_table',
+            'regr_avgx',
+            'regr_avgy',
+            'regr_count',
+            'regr_intercept',
+            'regr_r2',
+            'regr_slope',
+            'regr_sxx',
+            'regr_sxy',
+            'regr_syy',
+            'right',
+            'row_security_active',
+            'row_to_json',
+            'rpad',
+            'scale',
+            'set_masklen',
+            'setseed',
+            'setval',
+            'setweight',
+            'shobj_description',
+            'sind',
+            'sprintf',
+            'statement_timestamp',
+            'stddev',
+            'string_agg',
+            'string_to_array',
+            'strip',
+            'substr',
+            'table_to_xml',
+            'table_to_xml_and_xmlschema',
+            'tand',
+            'text',
+            'to_json',
+            'to_regclass',
+            'to_regnamespace',
+            'to_regoper',
+            'to_regoperator',
+            'to_regproc',
+            'to_regprocedure',
+            'to_regrole',
+            'to_regtype',
+            'to_tsquery',
+            'to_tsvector',
+            'transaction_timestamp',
+            'ts_debug',
+            'ts_delete',
+            'ts_filter',
+            'ts_headline',
+            'ts_lexize',
+            'ts_parse',
+            'ts_rank',
+            'ts_rank_cd',
+            'ts_rewrite',
+            'ts_stat',
+            'ts_token_type',
+            'tsquery_phrase',
+            'tsvector_to_array',
+            'tsvector_update_trigger',
+            'tsvector_update_trigger_column',
+            'txid_current',
+            'txid_current_snapshot',
+            'txid_snapshot_xip',
+            'txid_snapshot_xmax',
+            'txid_snapshot_xmin',
+            'txid_visible_in_snapshot',
+            'unnest',
+            'upper_inc',
+            'upper_inf',
+            'variance',
+            'width',
+            'width_bucket',
+            'xml_is_well_formed',
+            'xml_is_well_formed_content',
+            'xml_is_well_formed_document',
+            'xmlagg',
+            'xmlcomment',
+            'xmlconcat',
+            'xmlelement',
+            'xmlexists',
+            'xmlforest',
+            'xmlparse',
+            'xmlpi',
+            'xmlroot',
+            'xmlserialize',
+            'xpath',
+            'xpath_exists',
+          ],
+          builtinVariables: [],
+          pseudoColumns: [],
+          tokenizer: {
+            root: [
+              { include: '@comments' },
+              { include: '@whitespace' },
+              { include: '@pseudoColumns' },
+              { include: '@numbers' },
+              { include: '@strings' },
+              { include: '@complexIdentifiers' },
+              { include: '@scopes' },
+              [/[;,.]/, 'delimiter'],
+              [/[()]/, '@brackets'],
+              [
+                /[\w@#$]+/,
+                {
+                  cases: {
+                    '@keywords': 'keyword',
+                    '@operators': 'operator',
+                    '@builtinVariables': 'predefined',
+                    '@builtinFunctions': 'predefined',
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+              [/[<>=!%&+\-*/|~^]/, 'operator'],
+            ],
+            whitespace: [[/\s+/, 'white']],
+            comments: [
+              [/--+.*/, 'comment'],
+              [/\/\*/, { token: 'comment.quote', next: '@comment' }],
+            ],
+            comment: [
+              [/[^*/]+/, 'comment'],
+              [/\*\//, { token: 'comment.quote', next: '@pop' }],
+              [/./, 'comment'],
+            ],
+            pseudoColumns: [
+              [
+                /[$][A-Za-z_][\w@#$]*/,
+                {
+                  cases: {
+                    '@pseudoColumns': 'predefined',
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+            ],
+            numbers: [
+              [/0[xX][0-9a-fA-F]*/, 'number'],
+              [/[$][+-]*\d*(\.\d*)?/, 'number'],
+              [/((\d+(\.\d*)?)|(\.\d+))([eE][\-+]?\d+)?/, 'number'],
+            ],
+            strings: [[/'/, { token: 'string', next: '@string' }]],
+            string: [
+              [/[^']+/, 'string'],
+              [/''/, 'string'],
+              [/'/, { token: 'string', next: '@pop' }],
+            ],
+            complexIdentifiers: [
+              [/"/, { token: 'identifier.quote', next: '@quotedIdentifier' }],
+            ],
+            quotedIdentifier: [
+              [/[^"]+/, 'identifier'],
+              [/""/, 'identifier'],
+              [/"/, { token: 'identifier.quote', next: '@pop' }],
+            ],
+            scopes: [],
+          },
+        };
+    },
+  },
+]);

docs/6489.6489.js

@@ -0,0 +1,154 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [6489],
+  {
+    66489: (e, n, t) => {
+      'use strict';
+      t.r(n), t.d(n, { conf: () => o, language: () => s });
+      var o = {
+          comments: { lineComment: '#' },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"""', close: '"""', notIn: ['string', 'comment'] },
+            { open: '"', close: '"', notIn: ['string', 'comment'] },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"""', close: '"""' },
+            { open: '"', close: '"' },
+          ],
+          folding: { offSide: !0 },
+        },
+        s = {
+          defaultToken: 'invalid',
+          tokenPostfix: '.gql',
+          keywords: [
+            'null',
+            'true',
+            'false',
+            'query',
+            'mutation',
+            'subscription',
+            'extend',
+            'schema',
+            'directive',
+            'scalar',
+            'type',
+            'interface',
+            'union',
+            'enum',
+            'input',
+            'implements',
+            'fragment',
+            'on',
+          ],
+          typeKeywords: ['Int', 'Float', 'String', 'Boolean', 'ID'],
+          directiveLocations: [
+            'SCHEMA',
+            'SCALAR',
+            'OBJECT',
+            'FIELD_DEFINITION',
+            'ARGUMENT_DEFINITION',
+            'INTERFACE',
+            'UNION',
+            'ENUM',
+            'ENUM_VALUE',
+            'INPUT_OBJECT',
+            'INPUT_FIELD_DEFINITION',
+            'QUERY',
+            'MUTATION',
+            'SUBSCRIPTION',
+            'FIELD',
+            'FRAGMENT_DEFINITION',
+            'FRAGMENT_SPREAD',
+            'INLINE_FRAGMENT',
+            'VARIABLE_DEFINITION',
+          ],
+          operators: ['=', '!', '?', ':', '&', '|'],
+          symbols: /[=!?:&|]+/,
+          escapes: /\\(?:["\\\/bfnrt]|u[0-9A-Fa-f]{4})/,
+          tokenizer: {
+            root: [
+              [
+                /[a-z_][\w$]*/,
+                {
+                  cases: {
+                    '@keywords': 'keyword',
+                    '@default': 'key.identifier',
+                  },
+                },
+              ],
+              [
+                /[$][\w$]*/,
+                {
+                  cases: {
+                    '@keywords': 'keyword',
+                    '@default': 'argument.identifier',
+                  },
+                },
+              ],
+              [
+                /[A-Z][\w\$]*/,
+                {
+                  cases: {
+                    '@typeKeywords': 'keyword',
+                    '@default': 'type.identifier',
+                  },
+                },
+              ],
+              { include: '@whitespace' },
+              [/[{}()\[\]]/, '@brackets'],
+              [
+                /@symbols/,
+                { cases: { '@operators': 'operator', '@default': '' } },
+              ],
+              [
+                /@\s*[a-zA-Z_\$][\w\$]*/,
+                { token: 'annotation', log: 'annotation token: $0' },
+              ],
+              [/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
+              [/0[xX][0-9a-fA-F]+/, 'number.hex'],
+              [/\d+/, 'number'],
+              [/[;,.]/, 'delimiter'],
+              [
+                /"""/,
+                {
+                  token: 'string',
+                  next: '@mlstring',
+                  nextEmbedded: 'markdown',
+                },
+              ],
+              [/"([^"\\]|\\.)*$/, 'string.invalid'],
+              [
+                /"/,
+                { token: 'string.quote', bracket: '@open', next: '@string' },
+              ],
+            ],
+            mlstring: [
+              [/[^"]+/, 'string'],
+              ['"""', { token: 'string', next: '@pop', nextEmbedded: '@pop' }],
+            ],
+            string: [
+              [/[^\\"]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/"/, { token: 'string.quote', bracket: '@close', next: '@pop' }],
+            ],
+            whitespace: [
+              [/[ \t\r\n]+/, ''],
+              [/#.*$/, 'comment'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/6587.6587.js

@@ -0,0 +1,421 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [6587],
+  {
+    75458: (e, n, o) => {
+      'use strict';
+      o.r(n), o.d(n, { conf: () => t, language: () => r });
+      var t = {
+          comments: { lineComment: '//', blockComment: ['(*', '*)'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+            ['var', 'end_var'],
+            ['var_input', 'end_var'],
+            ['var_output', 'end_var'],
+            ['var_in_out', 'end_var'],
+            ['var_temp', 'end_var'],
+            ['var_global', 'end_var'],
+            ['var_access', 'end_var'],
+            ['var_external', 'end_var'],
+            ['type', 'end_type'],
+            ['struct', 'end_struct'],
+            ['program', 'end_program'],
+            ['function', 'end_function'],
+            ['function_block', 'end_function_block'],
+            ['action', 'end_action'],
+            ['step', 'end_step'],
+            ['initial_step', 'end_step'],
+            ['transaction', 'end_transaction'],
+            ['configuration', 'end_configuration'],
+            ['tcp', 'end_tcp'],
+            ['recource', 'end_recource'],
+            ['channel', 'end_channel'],
+            ['library', 'end_library'],
+            ['folder', 'end_folder'],
+            ['binaries', 'end_binaries'],
+            ['includes', 'end_includes'],
+            ['sources', 'end_sources'],
+          ],
+          autoClosingPairs: [
+            { open: '[', close: ']' },
+            { open: '{', close: '}' },
+            { open: '(', close: ')' },
+            { open: '/*', close: '*/' },
+            { open: "'", close: "'", notIn: ['string_sq'] },
+            { open: '"', close: '"', notIn: ['string_dq'] },
+            { open: 'var_input', close: 'end_var' },
+            { open: 'var_output', close: 'end_var' },
+            { open: 'var_in_out', close: 'end_var' },
+            { open: 'var_temp', close: 'end_var' },
+            { open: 'var_global', close: 'end_var' },
+            { open: 'var_access', close: 'end_var' },
+            { open: 'var_external', close: 'end_var' },
+            { open: 'type', close: 'end_type' },
+            { open: 'struct', close: 'end_struct' },
+            { open: 'program', close: 'end_program' },
+            { open: 'function', close: 'end_function' },
+            { open: 'function_block', close: 'end_function_block' },
+            { open: 'action', close: 'end_action' },
+            { open: 'step', close: 'end_step' },
+            { open: 'initial_step', close: 'end_step' },
+            { open: 'transaction', close: 'end_transaction' },
+            { open: 'configuration', close: 'end_configuration' },
+            { open: 'tcp', close: 'end_tcp' },
+            { open: 'recource', close: 'end_recource' },
+            { open: 'channel', close: 'end_channel' },
+            { open: 'library', close: 'end_library' },
+            { open: 'folder', close: 'end_folder' },
+            { open: 'binaries', close: 'end_binaries' },
+            { open: 'includes', close: 'end_includes' },
+            { open: 'sources', close: 'end_sources' },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+            { open: 'var', close: 'end_var' },
+            { open: 'var_input', close: 'end_var' },
+            { open: 'var_output', close: 'end_var' },
+            { open: 'var_in_out', close: 'end_var' },
+            { open: 'var_temp', close: 'end_var' },
+            { open: 'var_global', close: 'end_var' },
+            { open: 'var_access', close: 'end_var' },
+            { open: 'var_external', close: 'end_var' },
+            { open: 'type', close: 'end_type' },
+            { open: 'struct', close: 'end_struct' },
+            { open: 'program', close: 'end_program' },
+            { open: 'function', close: 'end_function' },
+            { open: 'function_block', close: 'end_function_block' },
+            { open: 'action', close: 'end_action' },
+            { open: 'step', close: 'end_step' },
+            { open: 'initial_step', close: 'end_step' },
+            { open: 'transaction', close: 'end_transaction' },
+            { open: 'configuration', close: 'end_configuration' },
+            { open: 'tcp', close: 'end_tcp' },
+            { open: 'recource', close: 'end_recource' },
+            { open: 'channel', close: 'end_channel' },
+            { open: 'library', close: 'end_library' },
+            { open: 'folder', close: 'end_folder' },
+            { open: 'binaries', close: 'end_binaries' },
+            { open: 'includes', close: 'end_includes' },
+            { open: 'sources', close: 'end_sources' },
+          ],
+          folding: {
+            markers: {
+              start: new RegExp('^\\s*#pragma\\s+region\\b'),
+              end: new RegExp('^\\s*#pragma\\s+endregion\\b'),
+            },
+          },
+        },
+        r = {
+          defaultToken: '',
+          tokenPostfix: '.st',
+          ignoreCase: !0,
+          brackets: [
+            { token: 'delimiter.curly', open: '{', close: '}' },
+            { token: 'delimiter.parenthesis', open: '(', close: ')' },
+            { token: 'delimiter.square', open: '[', close: ']' },
+          ],
+          keywords: [
+            'if',
+            'end_if',
+            'elsif',
+            'else',
+            'case',
+            'of',
+            'to',
+            '__try',
+            '__catch',
+            '__finally',
+            'do',
+            'with',
+            'by',
+            'while',
+            'repeat',
+            'end_while',
+            'end_repeat',
+            'end_case',
+            'for',
+            'end_for',
+            'task',
+            'retain',
+            'non_retain',
+            'constant',
+            'with',
+            'at',
+            'exit',
+            'return',
+            'interval',
+            'priority',
+            'address',
+            'port',
+            'on_channel',
+            'then',
+            'iec',
+            'file',
+            'uses',
+            'version',
+            'packagetype',
+            'displayname',
+            'copyright',
+            'summary',
+            'vendor',
+            'common_source',
+            'from',
+            'extends',
+          ],
+          constant: ['false', 'true', 'null'],
+          defineKeywords: [
+            'var',
+            'var_input',
+            'var_output',
+            'var_in_out',
+            'var_temp',
+            'var_global',
+            'var_access',
+            'var_external',
+            'end_var',
+            'type',
+            'end_type',
+            'struct',
+            'end_struct',
+            'program',
+            'end_program',
+            'function',
+            'end_function',
+            'function_block',
+            'end_function_block',
+            'interface',
+            'end_interface',
+            'method',
+            'end_method',
+            'property',
+            'end_property',
+            'namespace',
+            'end_namespace',
+            'configuration',
+            'end_configuration',
+            'tcp',
+            'end_tcp',
+            'resource',
+            'end_resource',
+            'channel',
+            'end_channel',
+            'library',
+            'end_library',
+            'folder',
+            'end_folder',
+            'binaries',
+            'end_binaries',
+            'includes',
+            'end_includes',
+            'sources',
+            'end_sources',
+            'action',
+            'end_action',
+            'step',
+            'initial_step',
+            'end_step',
+            'transaction',
+            'end_transaction',
+          ],
+          typeKeywords: [
+            'int',
+            'sint',
+            'dint',
+            'lint',
+            'usint',
+            'uint',
+            'udint',
+            'ulint',
+            'real',
+            'lreal',
+            'time',
+            'date',
+            'time_of_day',
+            'date_and_time',
+            'string',
+            'bool',
+            'byte',
+            'word',
+            'dword',
+            'array',
+            'pointer',
+            'lword',
+          ],
+          operators: [
+            '=',
+            '>',
+            '<',
+            ':',
+            ':=',
+            '<=',
+            '>=',
+            '<>',
+            '&',
+            '+',
+            '-',
+            '*',
+            '**',
+            'MOD',
+            '^',
+            'or',
+            'and',
+            'not',
+            'xor',
+            'abs',
+            'acos',
+            'asin',
+            'atan',
+            'cos',
+            'exp',
+            'expt',
+            'ln',
+            'log',
+            'sin',
+            'sqrt',
+            'tan',
+            'sel',
+            'max',
+            'min',
+            'limit',
+            'mux',
+            'shl',
+            'shr',
+            'rol',
+            'ror',
+            'indexof',
+            'sizeof',
+            'adr',
+            'adrinst',
+            'bitadr',
+            'is_valid',
+            'ref',
+            'ref_to',
+          ],
+          builtinVariables: [],
+          builtinFunctions: [
+            'sr',
+            'rs',
+            'tp',
+            'ton',
+            'tof',
+            'eq',
+            'ge',
+            'le',
+            'lt',
+            'ne',
+            'round',
+            'trunc',
+            'ctd',
+            'сtu',
+            'ctud',
+            'r_trig',
+            'f_trig',
+            'move',
+            'concat',
+            'delete',
+            'find',
+            'insert',
+            'left',
+            'len',
+            'replace',
+            'right',
+            'rtc',
+          ],
+          symbols: /[=><!~?:&|+\-*\/\^%]+/,
+          escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+          tokenizer: {
+            root: [
+              [/(\.\.)/, 'delimiter'],
+              [/\b(16#[0-9A-Fa-f\_]*)+\b/, 'number.hex'],
+              [/\b(2#[01\_]+)+\b/, 'number.binary'],
+              [/\b(8#[0-9\_]*)+\b/, 'number.octal'],
+              [/\b\d*\.\d+([eE][\-+]?\d+)?\b/, 'number.float'],
+              [/\b(L?REAL)#[0-9\_\.e]+\b/, 'number.float'],
+              [/\b(BYTE|(?:D|L)?WORD|U?(?:S|D|L)?INT)#[0-9\_]+\b/, 'number'],
+              [/\d+/, 'number'],
+              [/\b(T|DT|TOD)#[0-9:-_shmyd]+\b/, 'tag'],
+              [/\%(I|Q|M)(X|B|W|D|L)[0-9\.]+/, 'tag'],
+              [/\%(I|Q|M)[0-9\.]*/, 'tag'],
+              [/\b[A-Za-z]{1,6}#[0-9]+\b/, 'tag'],
+              [/\b(TO_|CTU_|CTD_|CTUD_|MUX_|SEL_)[A_Za-z]+\b/, 'predefined'],
+              [/\b[A_Za-z]+(_TO_)[A_Za-z]+\b/, 'predefined'],
+              [/[;]/, 'delimiter'],
+              [/[.]/, { token: 'delimiter', next: '@params' }],
+              [
+                /[a-zA-Z_]\w*/,
+                {
+                  cases: {
+                    '@operators': 'operators',
+                    '@keywords': 'keyword',
+                    '@typeKeywords': 'type',
+                    '@defineKeywords': 'variable',
+                    '@constant': 'constant',
+                    '@builtinVariables': 'predefined',
+                    '@builtinFunctions': 'predefined',
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+              { include: '@whitespace' },
+              [/[{}()\[\]]/, '@brackets'],
+              [/"([^"\\]|\\.)*$/, 'string.invalid'],
+              [
+                /"/,
+                { token: 'string.quote', bracket: '@open', next: '@string_dq' },
+              ],
+              [
+                /'/,
+                { token: 'string.quote', bracket: '@open', next: '@string_sq' },
+              ],
+              [/'[^\\']'/, 'string'],
+              [/(')(@escapes)(')/, ['string', 'string.escape', 'string']],
+              [/'/, 'string.invalid'],
+            ],
+            params: [
+              [
+                /\b[A-Za-z0-9_]+\b(?=\()/,
+                { token: 'identifier', next: '@pop' },
+              ],
+              [/\b[A-Za-z0-9_]+\b/, 'variable.name', '@pop'],
+            ],
+            comment: [
+              [/[^\/*]+/, 'comment'],
+              [/\/\*/, 'comment', '@push'],
+              ['\\*/', 'comment', '@pop'],
+              [/[\/*]/, 'comment'],
+            ],
+            comment2: [
+              [/[^\(*]+/, 'comment'],
+              [/\(\*/, 'comment', '@push'],
+              ['\\*\\)', 'comment', '@pop'],
+              [/[\(*]/, 'comment'],
+            ],
+            whitespace: [
+              [/[ \t\r\n]+/, 'white'],
+              [/\/\/.*$/, 'comment'],
+              [/\/\*/, 'comment', '@comment'],
+              [/\(\*/, 'comment', '@comment2'],
+            ],
+            string_dq: [
+              [/[^\\"]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/"/, { token: 'string.quote', bracket: '@close', next: '@pop' }],
+            ],
+            string_sq: [
+              [/[^\\']+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/'/, { token: 'string.quote', bracket: '@close', next: '@pop' }],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/6717.6717.js

@@ -0,0 +1,322 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [6717],
+  {
+    96717: (e, t, n) => {
+      'use strict';
+      n.r(t), n.d(t, { conf: () => i, language: () => r });
+      var o = n(89587),
+        i = {
+          wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+          comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          onEnterRules: [
+            {
+              beforeText: /^\s*\/\*\*(?!\/)([^\*]|\*(?!\/))*$/,
+              afterText: /^\s*\*\/$/,
+              action: {
+                indentAction: o.Mj.IndentAction.IndentOutdent,
+                appendText: ' * ',
+              },
+            },
+            {
+              beforeText: /^\s*\/\*\*(?!\/)([^\*]|\*(?!\/))*$/,
+              action: {
+                indentAction: o.Mj.IndentAction.None,
+                appendText: ' * ',
+              },
+            },
+            {
+              beforeText: /^(\t|(\ \ ))*\ \*(\ ([^\*]|\*(?!\/))*)?$/,
+              action: {
+                indentAction: o.Mj.IndentAction.None,
+                appendText: '* ',
+              },
+            },
+            {
+              beforeText: /^(\t|(\ \ ))*\ \*\/\s*$/,
+              action: { indentAction: o.Mj.IndentAction.None, removeText: 1 },
+            },
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"', notIn: ['string'] },
+            { open: "'", close: "'", notIn: ['string', 'comment'] },
+            { open: '`', close: '`', notIn: ['string', 'comment'] },
+            { open: '/**', close: ' */', notIn: ['string'] },
+          ],
+          folding: {
+            markers: {
+              start: new RegExp('^\\s*//\\s*#?region\\b'),
+              end: new RegExp('^\\s*//\\s*#?endregion\\b'),
+            },
+          },
+        },
+        r = {
+          defaultToken: 'invalid',
+          tokenPostfix: '.ts',
+          keywords: [
+            'abstract',
+            'any',
+            'as',
+            'asserts',
+            'bigint',
+            'boolean',
+            'break',
+            'case',
+            'catch',
+            'class',
+            'continue',
+            'const',
+            'constructor',
+            'debugger',
+            'declare',
+            'default',
+            'delete',
+            'do',
+            'else',
+            'enum',
+            'export',
+            'extends',
+            'false',
+            'finally',
+            'for',
+            'from',
+            'function',
+            'get',
+            'if',
+            'implements',
+            'import',
+            'in',
+            'infer',
+            'instanceof',
+            'interface',
+            'is',
+            'keyof',
+            'let',
+            'module',
+            'namespace',
+            'never',
+            'new',
+            'null',
+            'number',
+            'object',
+            'package',
+            'private',
+            'protected',
+            'public',
+            'readonly',
+            'require',
+            'global',
+            'return',
+            'set',
+            'static',
+            'string',
+            'super',
+            'switch',
+            'symbol',
+            'this',
+            'throw',
+            'true',
+            'try',
+            'type',
+            'typeof',
+            'undefined',
+            'unique',
+            'unknown',
+            'var',
+            'void',
+            'while',
+            'with',
+            'yield',
+            'async',
+            'await',
+            'of',
+          ],
+          operators: [
+            '<=',
+            '>=',
+            '==',
+            '!=',
+            '===',
+            '!==',
+            '=>',
+            '+',
+            '-',
+            '**',
+            '*',
+            '/',
+            '%',
+            '++',
+            '--',
+            '<<',
+            '</',
+            '>>',
+            '>>>',
+            '&',
+            '|',
+            '^',
+            '!',
+            '~',
+            '&&',
+            '||',
+            '??',
+            '?',
+            ':',
+            '=',
+            '+=',
+            '-=',
+            '*=',
+            '**=',
+            '/=',
+            '%=',
+            '<<=',
+            '>>=',
+            '>>>=',
+            '&=',
+            '|=',
+            '^=',
+            '@',
+          ],
+          symbols: /[=><!~?:&|+\-*\/\^%]+/,
+          escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+          digits: /\d+(_+\d+)*/,
+          octaldigits: /[0-7]+(_+[0-7]+)*/,
+          binarydigits: /[0-1]+(_+[0-1]+)*/,
+          hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+          regexpctl: /[(){}\[\]\$\^|\-*+?\.]/,
+          regexpesc: /\\(?:[bBdDfnrstvwWn0\\\/]|@regexpctl|c[A-Z]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4})/,
+          tokenizer: {
+            root: [[/[{}]/, 'delimiter.bracket'], { include: 'common' }],
+            common: [
+              [
+                /[a-z_$][\w$]*/,
+                { cases: { '@keywords': 'keyword', '@default': 'identifier' } },
+              ],
+              [/[A-Z][\w\$]*/, 'type.identifier'],
+              { include: '@whitespace' },
+              [
+                /\/(?=([^\\\/]|\\.)+\/([gimsuy]*)(\s*)(\.|;|,|\)|\]|\}|$))/,
+                { token: 'regexp', bracket: '@open', next: '@regexp' },
+              ],
+              [/[()\[\]]/, '@brackets'],
+              [/[<>](?!@symbols)/, '@brackets'],
+              [/!(?=([^=]|$))/, 'delimiter'],
+              [
+                /@symbols/,
+                { cases: { '@operators': 'delimiter', '@default': '' } },
+              ],
+              [/(@digits)[eE]([\-+]?(@digits))?/, 'number.float'],
+              [/(@digits)\.(@digits)([eE][\-+]?(@digits))?/, 'number.float'],
+              [/0[xX](@hexdigits)n?/, 'number.hex'],
+              [/0[oO]?(@octaldigits)n?/, 'number.octal'],
+              [/0[bB](@binarydigits)n?/, 'number.binary'],
+              [/(@digits)n?/, 'number'],
+              [/[;,.]/, 'delimiter'],
+              [/"([^"\\]|\\.)*$/, 'string.invalid'],
+              [/'([^'\\]|\\.)*$/, 'string.invalid'],
+              [/"/, 'string', '@string_double'],
+              [/'/, 'string', '@string_single'],
+              [/`/, 'string', '@string_backtick'],
+            ],
+            whitespace: [
+              [/[ \t\r\n]+/, ''],
+              [/\/\*\*(?!\/)/, 'comment.doc', '@jsdoc'],
+              [/\/\*/, 'comment', '@comment'],
+              [/\/\/.*$/, 'comment'],
+            ],
+            comment: [
+              [/[^\/*]+/, 'comment'],
+              [/\*\//, 'comment', '@pop'],
+              [/[\/*]/, 'comment'],
+            ],
+            jsdoc: [
+              [/[^\/*]+/, 'comment.doc'],
+              [/\*\//, 'comment.doc', '@pop'],
+              [/[\/*]/, 'comment.doc'],
+            ],
+            regexp: [
+              [
+                /(\{)(\d+(?:,\d*)?)(\})/,
+                [
+                  'regexp.escape.control',
+                  'regexp.escape.control',
+                  'regexp.escape.control',
+                ],
+              ],
+              [
+                /(\[)(\^?)(?=(?:[^\]\\\/]|\\.)+)/,
+                [
+                  'regexp.escape.control',
+                  { token: 'regexp.escape.control', next: '@regexrange' },
+                ],
+              ],
+              [
+                /(\()(\?:|\?=|\?!)/,
+                ['regexp.escape.control', 'regexp.escape.control'],
+              ],
+              [/[()]/, 'regexp.escape.control'],
+              [/@regexpctl/, 'regexp.escape.control'],
+              [/[^\\\/]/, 'regexp'],
+              [/@regexpesc/, 'regexp.escape'],
+              [/\\\./, 'regexp.invalid'],
+              [
+                /(\/)([gimsuy]*)/,
+                [
+                  { token: 'regexp', bracket: '@close', next: '@pop' },
+                  'keyword.other',
+                ],
+              ],
+            ],
+            regexrange: [
+              [/-/, 'regexp.escape.control'],
+              [/\^/, 'regexp.invalid'],
+              [/@regexpesc/, 'regexp.escape'],
+              [/[^\]]/, 'regexp'],
+              [
+                /\]/,
+                {
+                  token: 'regexp.escape.control',
+                  next: '@pop',
+                  bracket: '@close',
+                },
+              ],
+            ],
+            string_double: [
+              [/[^\\"]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/"/, 'string', '@pop'],
+            ],
+            string_single: [
+              [/[^\\']+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/'/, 'string', '@pop'],
+            ],
+            string_backtick: [
+              [
+                /\$\{/,
+                { token: 'delimiter.bracket', next: '@bracketCounting' },
+              ],
+              [/[^\\`$]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/`/, 'string', '@pop'],
+            ],
+            bracketCounting: [
+              [/\{/, 'delimiter.bracket', '@bracketCounting'],
+              [/\}/, 'delimiter.bracket', '@pop'],
+              { include: 'common' },
+            ],
+          },
+        };
+    },
+  },
+]);

docs/7043.7043.js

@@ -0,0 +1,207 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [7043],
+  {
+    17043: (e, t, o) => {
+      'use strict';
+      o.r(t), o.d(t, { conf: () => s, language: () => i });
+      var s = {
+          wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+          comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+            { open: '<', close: '>' },
+          ],
+          folding: {
+            markers: {
+              start: new RegExp(
+                '^\\s*//\\s*(?:(?:#?region\\b)|(?:<editor-fold\\b))'
+              ),
+              end: new RegExp(
+                '^\\s*//\\s*(?:(?:#?endregion\\b)|(?:</editor-fold>))'
+              ),
+            },
+          },
+        },
+        i = {
+          defaultToken: '',
+          tokenPostfix: '.java',
+          keywords: [
+            'abstract',
+            'continue',
+            'for',
+            'new',
+            'switch',
+            'assert',
+            'default',
+            'goto',
+            'package',
+            'synchronized',
+            'boolean',
+            'do',
+            'if',
+            'private',
+            'this',
+            'break',
+            'double',
+            'implements',
+            'protected',
+            'throw',
+            'byte',
+            'else',
+            'import',
+            'public',
+            'throws',
+            'case',
+            'enum',
+            'instanceof',
+            'return',
+            'transient',
+            'catch',
+            'extends',
+            'int',
+            'short',
+            'try',
+            'char',
+            'final',
+            'interface',
+            'static',
+            'void',
+            'class',
+            'finally',
+            'long',
+            'strictfp',
+            'volatile',
+            'const',
+            'float',
+            'native',
+            'super',
+            'while',
+            'true',
+            'false',
+          ],
+          operators: [
+            '=',
+            '>',
+            '<',
+            '!',
+            '~',
+            '?',
+            ':',
+            '==',
+            '<=',
+            '>=',
+            '!=',
+            '&&',
+            '||',
+            '++',
+            '--',
+            '+',
+            '-',
+            '*',
+            '/',
+            '&',
+            '|',
+            '^',
+            '%',
+            '<<',
+            '>>',
+            '>>>',
+            '+=',
+            '-=',
+            '*=',
+            '/=',
+            '&=',
+            '|=',
+            '^=',
+            '%=',
+            '<<=',
+            '>>=',
+            '>>>=',
+          ],
+          symbols: /[=><!~?:&|+\-*\/\^%]+/,
+          escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+          digits: /\d+(_+\d+)*/,
+          octaldigits: /[0-7]+(_+[0-7]+)*/,
+          binarydigits: /[0-1]+(_+[0-1]+)*/,
+          hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+          tokenizer: {
+            root: [
+              [
+                /[a-zA-Z_$][\w$]*/,
+                {
+                  cases: {
+                    '@keywords': { token: 'keyword.$0' },
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+              { include: '@whitespace' },
+              [/[{}()\[\]]/, '@brackets'],
+              [/[<>](?!@symbols)/, '@brackets'],
+              [
+                /@symbols/,
+                { cases: { '@operators': 'delimiter', '@default': '' } },
+              ],
+              [/@\s*[a-zA-Z_\$][\w\$]*/, 'annotation'],
+              [/(@digits)[eE]([\-+]?(@digits))?[fFdD]?/, 'number.float'],
+              [
+                /(@digits)\.(@digits)([eE][\-+]?(@digits))?[fFdD]?/,
+                'number.float',
+              ],
+              [/0[xX](@hexdigits)[Ll]?/, 'number.hex'],
+              [/0(@octaldigits)[Ll]?/, 'number.octal'],
+              [/0[bB](@binarydigits)[Ll]?/, 'number.binary'],
+              [/(@digits)[fFdD]/, 'number.float'],
+              [/(@digits)[lL]?/, 'number'],
+              [/[;,.]/, 'delimiter'],
+              [/"([^"\\]|\\.)*$/, 'string.invalid'],
+              [/"/, 'string', '@string'],
+              [/'[^\\']'/, 'string'],
+              [/(')(@escapes)(')/, ['string', 'string.escape', 'string']],
+              [/'/, 'string.invalid'],
+            ],
+            whitespace: [
+              [/[ \t\r\n]+/, ''],
+              [/\/\*\*(?!\/)/, 'comment.doc', '@javadoc'],
+              [/\/\*/, 'comment', '@comment'],
+              [/\/\/.*$/, 'comment'],
+            ],
+            comment: [
+              [/[^\/*]+/, 'comment'],
+              [/\*\//, 'comment', '@pop'],
+              [/[\/*]/, 'comment'],
+            ],
+            javadoc: [
+              [/[^\/*]+/, 'comment.doc'],
+              [/\/\*/, 'comment.doc.invalid'],
+              [/\*\//, 'comment.doc', '@pop'],
+              [/[\/*]/, 'comment.doc'],
+            ],
+            string: [
+              [/[^\\"]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/"/, 'string', '@pop'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/7287.7287.js

@@ -0,0 +1,244 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [7287],
+  {
+    37287: (e, n, s) => {
+      'use strict';
+      s.r(n), s.d(n, { conf: () => r, language: () => i });
+      var t = s(89587),
+        r = {
+          comments: { lineComment: '#', blockComment: ["'''", "'''"] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"', notIn: ['string'] },
+            { open: "'", close: "'", notIn: ['string', 'comment'] },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          onEnterRules: [
+            {
+              beforeText: new RegExp(
+                '^\\s*(?:def|class|for|if|elif|else|while|try|with|finally|except|async).*?:\\s*$'
+              ),
+              action: { indentAction: t.Mj.IndentAction.Indent },
+            },
+          ],
+          folding: {
+            offSide: !0,
+            markers: {
+              start: new RegExp('^\\s*#region\\b'),
+              end: new RegExp('^\\s*#endregion\\b'),
+            },
+          },
+        },
+        i = {
+          defaultToken: '',
+          tokenPostfix: '.python',
+          keywords: [
+            'False',
+            'None',
+            'True',
+            'and',
+            'as',
+            'assert',
+            'async',
+            'await',
+            'break',
+            'class',
+            'continue',
+            'def',
+            'del',
+            'elif',
+            'else',
+            'except',
+            'exec',
+            'finally',
+            'for',
+            'from',
+            'global',
+            'if',
+            'import',
+            'in',
+            'is',
+            'lambda',
+            'nonlocal',
+            'not',
+            'or',
+            'pass',
+            'print',
+            'raise',
+            'return',
+            'try',
+            'while',
+            'with',
+            'yield',
+            'int',
+            'float',
+            'long',
+            'complex',
+            'hex',
+            'abs',
+            'all',
+            'any',
+            'apply',
+            'basestring',
+            'bin',
+            'bool',
+            'buffer',
+            'bytearray',
+            'callable',
+            'chr',
+            'classmethod',
+            'cmp',
+            'coerce',
+            'compile',
+            'complex',
+            'delattr',
+            'dict',
+            'dir',
+            'divmod',
+            'enumerate',
+            'eval',
+            'execfile',
+            'file',
+            'filter',
+            'format',
+            'frozenset',
+            'getattr',
+            'globals',
+            'hasattr',
+            'hash',
+            'help',
+            'id',
+            'input',
+            'intern',
+            'isinstance',
+            'issubclass',
+            'iter',
+            'len',
+            'locals',
+            'list',
+            'map',
+            'max',
+            'memoryview',
+            'min',
+            'next',
+            'object',
+            'oct',
+            'open',
+            'ord',
+            'pow',
+            'print',
+            'property',
+            'reversed',
+            'range',
+            'raw_input',
+            'reduce',
+            'reload',
+            'repr',
+            'reversed',
+            'round',
+            'self',
+            'set',
+            'setattr',
+            'slice',
+            'sorted',
+            'staticmethod',
+            'str',
+            'sum',
+            'super',
+            'tuple',
+            'type',
+            'unichr',
+            'unicode',
+            'vars',
+            'xrange',
+            'zip',
+            '__dict__',
+            '__methods__',
+            '__members__',
+            '__class__',
+            '__bases__',
+            '__name__',
+            '__mro__',
+            '__subclasses__',
+            '__init__',
+            '__import__',
+          ],
+          brackets: [
+            { open: '{', close: '}', token: 'delimiter.curly' },
+            { open: '[', close: ']', token: 'delimiter.bracket' },
+            { open: '(', close: ')', token: 'delimiter.parenthesis' },
+          ],
+          tokenizer: {
+            root: [
+              { include: '@whitespace' },
+              { include: '@numbers' },
+              { include: '@strings' },
+              [/[,:;]/, 'delimiter'],
+              [/[{}\[\]()]/, '@brackets'],
+              [/@[a-zA-Z_]\w*/, 'tag'],
+              [
+                /[a-zA-Z_]\w*/,
+                { cases: { '@keywords': 'keyword', '@default': 'identifier' } },
+              ],
+            ],
+            whitespace: [
+              [/\s+/, 'white'],
+              [/(^#.*$)/, 'comment'],
+              [/'''/, 'string', '@endDocString'],
+              [/"""/, 'string', '@endDblDocString'],
+            ],
+            endDocString: [
+              [/[^']+/, 'string'],
+              [/\\'/, 'string'],
+              [/'''/, 'string', '@popall'],
+              [/'/, 'string'],
+            ],
+            endDblDocString: [
+              [/[^"]+/, 'string'],
+              [/\\"/, 'string'],
+              [/"""/, 'string', '@popall'],
+              [/"/, 'string'],
+            ],
+            numbers: [
+              [/-?0x([abcdef]|[ABCDEF]|\d)+[lL]?/, 'number.hex'],
+              [/-?(\d*\.)?\d+([eE][+\-]?\d+)?[jJ]?[lL]?/, 'number'],
+            ],
+            strings: [
+              [/'$/, 'string.escape', '@popall'],
+              [/'/, 'string.escape', '@stringBody'],
+              [/"$/, 'string.escape', '@popall'],
+              [/"/, 'string.escape', '@dblStringBody'],
+            ],
+            stringBody: [
+              [/[^\\']+$/, 'string', '@popall'],
+              [/[^\\']+/, 'string'],
+              [/\\./, 'string'],
+              [/'/, 'string.escape', '@popall'],
+              [/\\$/, 'string'],
+            ],
+            dblStringBody: [
+              [/[^\\"]+$/, 'string', '@popall'],
+              [/[^\\"]+/, 'string'],
+              [/\\./, 'string'],
+              [/"/, 'string.escape', '@popall'],
+              [/\\$/, 'string'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/7562.7562.js

@@ -0,0 +1,218 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [7562],
+  {
+    37562: (e, n, s) => {
+      'use strict';
+      s.r(n), s.d(n, { conf: () => t, language: () => o });
+      var t = {
+          wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#%\^\&\*\(\)\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+          comments: { lineComment: '#', blockComment: ['<#', '#>'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"', notIn: ['string'] },
+            { open: "'", close: "'", notIn: ['string', 'comment'] },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          folding: {
+            markers: {
+              start: new RegExp('^\\s*#region\\b'),
+              end: new RegExp('^\\s*#endregion\\b'),
+            },
+          },
+        },
+        o = {
+          defaultToken: '',
+          ignoreCase: !0,
+          tokenPostfix: '.ps1',
+          brackets: [
+            { token: 'delimiter.curly', open: '{', close: '}' },
+            { token: 'delimiter.square', open: '[', close: ']' },
+            { token: 'delimiter.parenthesis', open: '(', close: ')' },
+          ],
+          keywords: [
+            'begin',
+            'break',
+            'catch',
+            'class',
+            'continue',
+            'data',
+            'define',
+            'do',
+            'dynamicparam',
+            'else',
+            'elseif',
+            'end',
+            'exit',
+            'filter',
+            'finally',
+            'for',
+            'foreach',
+            'from',
+            'function',
+            'if',
+            'in',
+            'param',
+            'process',
+            'return',
+            'switch',
+            'throw',
+            'trap',
+            'try',
+            'until',
+            'using',
+            'var',
+            'while',
+            'workflow',
+            'parallel',
+            'sequence',
+            'inlinescript',
+            'configuration',
+          ],
+          helpKeywords: /SYNOPSIS|DESCRIPTION|PARAMETER|EXAMPLE|INPUTS|OUTPUTS|NOTES|LINK|COMPONENT|ROLE|FUNCTIONALITY|FORWARDHELPTARGETNAME|FORWARDHELPCATEGORY|REMOTEHELPRUNSPACE|EXTERNALHELP/,
+          symbols: /[=><!~?&%|+\-*\/\^;\.,]+/,
+          escapes: /`(?:[abfnrtv\\"'$]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+          tokenizer: {
+            root: [
+              [
+                /[a-zA-Z_][\w-]*/,
+                {
+                  cases: {
+                    '@keywords': { token: 'keyword.$0' },
+                    '@default': '',
+                  },
+                },
+              ],
+              [/[ \t\r\n]+/, ''],
+              [/^:\w*/, 'metatag'],
+              [
+                /\$(\{((global|local|private|script|using):)?[\w]+\}|((global|local|private|script|using):)?[\w]+)/,
+                'variable',
+              ],
+              [/<#/, 'comment', '@comment'],
+              [/#.*$/, 'comment'],
+              [/[{}()\[\]]/, '@brackets'],
+              [/@symbols/, 'delimiter'],
+              [/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
+              [/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/, 'number.hex'],
+              [/\d+?/, 'number'],
+              [/[;,.]/, 'delimiter'],
+              [/\@"/, 'string', '@herestring."'],
+              [/\@'/, 'string', "@herestring.'"],
+              [
+                /"/,
+                {
+                  cases: {
+                    '@eos': 'string',
+                    '@default': { token: 'string', next: '@string."' },
+                  },
+                },
+              ],
+              [
+                /'/,
+                {
+                  cases: {
+                    '@eos': 'string',
+                    '@default': { token: 'string', next: "@string.'" },
+                  },
+                },
+              ],
+            ],
+            string: [
+              [
+                /[^"'\$`]+/,
+                {
+                  cases: {
+                    '@eos': { token: 'string', next: '@popall' },
+                    '@default': 'string',
+                  },
+                },
+              ],
+              [
+                /@escapes/,
+                {
+                  cases: {
+                    '@eos': { token: 'string.escape', next: '@popall' },
+                    '@default': 'string.escape',
+                  },
+                },
+              ],
+              [
+                /`./,
+                {
+                  cases: {
+                    '@eos': { token: 'string.escape.invalid', next: '@popall' },
+                    '@default': 'string.escape.invalid',
+                  },
+                },
+              ],
+              [
+                /\$[\w]+$/,
+                {
+                  cases: {
+                    '$S2=="': { token: 'variable', next: '@popall' },
+                    '@default': { token: 'string', next: '@popall' },
+                  },
+                },
+              ],
+              [
+                /\$[\w]+/,
+                { cases: { '$S2=="': 'variable', '@default': 'string' } },
+              ],
+              [
+                /["']/,
+                {
+                  cases: {
+                    '$#==$S2': { token: 'string', next: '@pop' },
+                    '@default': {
+                      cases: {
+                        '@eos': { token: 'string', next: '@popall' },
+                        '@default': 'string',
+                      },
+                    },
+                  },
+                },
+              ],
+            ],
+            herestring: [
+              [
+                /^\s*(["'])@/,
+                {
+                  cases: {
+                    '$1==$S2': { token: 'string', next: '@pop' },
+                    '@default': 'string',
+                  },
+                },
+              ],
+              [/[^\$`]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/`./, 'string.escape.invalid'],
+              [
+                /\$[\w]+/,
+                { cases: { '$S2=="': 'variable', '@default': 'string' } },
+              ],
+            ],
+            comment: [
+              [/[^#\.]+/, 'comment'],
+              [/#>/, 'comment', '@pop'],
+              [/(\.)(@helpKeywords)(?!\w)/, { token: 'comment.keyword.$2' }],
+              [/[\.#]/, 'comment'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/7637.7637.js

@@ -0,0 +1,248 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [7637],
+  {
+    57637: (e, t, n) => {
+      'use strict';
+      n.r(t), n.d(t, { conf: () => o, language: () => s });
+      var o = {
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+        },
+        s = {
+          tokenPostfix: '.tcl',
+          specialFunctions: [
+            'set',
+            'unset',
+            'rename',
+            'variable',
+            'proc',
+            'coroutine',
+            'foreach',
+            'incr',
+            'append',
+            'lappend',
+            'linsert',
+            'lreplace',
+          ],
+          mainFunctions: [
+            'if',
+            'then',
+            'elseif',
+            'else',
+            'case',
+            'switch',
+            'while',
+            'for',
+            'break',
+            'continue',
+            'return',
+            'package',
+            'namespace',
+            'catch',
+            'exit',
+            'eval',
+            'expr',
+            'uplevel',
+            'upvar',
+          ],
+          builtinFunctions: [
+            'file',
+            'info',
+            'concat',
+            'join',
+            'lindex',
+            'list',
+            'llength',
+            'lrange',
+            'lsearch',
+            'lsort',
+            'split',
+            'array',
+            'parray',
+            'binary',
+            'format',
+            'regexp',
+            'regsub',
+            'scan',
+            'string',
+            'subst',
+            'dict',
+            'cd',
+            'clock',
+            'exec',
+            'glob',
+            'pid',
+            'pwd',
+            'close',
+            'eof',
+            'fblocked',
+            'fconfigure',
+            'fcopy',
+            'fileevent',
+            'flush',
+            'gets',
+            'open',
+            'puts',
+            'read',
+            'seek',
+            'socket',
+            'tell',
+            'interp',
+            'after',
+            'auto_execok',
+            'auto_load',
+            'auto_mkindex',
+            'auto_reset',
+            'bgerror',
+            'error',
+            'global',
+            'history',
+            'load',
+            'source',
+            'time',
+            'trace',
+            'unknown',
+            'unset',
+            'update',
+            'vwait',
+            'winfo',
+            'wm',
+            'bind',
+            'event',
+            'pack',
+            'place',
+            'grid',
+            'font',
+            'bell',
+            'clipboard',
+            'destroy',
+            'focus',
+            'grab',
+            'lower',
+            'option',
+            'raise',
+            'selection',
+            'send',
+            'tk',
+            'tkwait',
+            'tk_bisque',
+            'tk_focusNext',
+            'tk_focusPrev',
+            'tk_focusFollowsMouse',
+            'tk_popup',
+            'tk_setPalette',
+          ],
+          symbols: /[=><!~?:&|+\-*\/\^%]+/,
+          brackets: [
+            { open: '(', close: ')', token: 'delimiter.parenthesis' },
+            { open: '{', close: '}', token: 'delimiter.curly' },
+            { open: '[', close: ']', token: 'delimiter.square' },
+          ],
+          escapes: /\\(?:[abfnrtv\\"'\[\]\{\};\$]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+          variables: /(?:\$+(?:(?:\:\:?)?[a-zA-Z_]\w*)+)/,
+          tokenizer: {
+            root: [
+              [
+                /[a-zA-Z_]\w*/,
+                {
+                  cases: {
+                    '@specialFunctions': {
+                      token: 'keyword.flow',
+                      next: '@specialFunc',
+                    },
+                    '@mainFunctions': 'keyword',
+                    '@builtinFunctions': 'variable',
+                    '@default': 'operator.scss',
+                  },
+                },
+              ],
+              [/\s+\-+(?!\d|\.)\w*|{\*}/, 'metatag'],
+              { include: '@whitespace' },
+              [/[{}()\[\]]/, '@brackets'],
+              [/@symbols/, 'operator'],
+              [
+                /\$+(?:\:\:)?\{/,
+                { token: 'identifier', next: '@nestedVariable' },
+              ],
+              [/@variables/, 'type.identifier'],
+              [/\.(?!\d|\.)[\w\-]*/, 'operator.sql'],
+              [/\d+(\.\d+)?/, 'number'],
+              [/\d+/, 'number'],
+              [/;/, 'delimiter'],
+              [
+                /"/,
+                { token: 'string.quote', bracket: '@open', next: '@dstring' },
+              ],
+              [
+                /'/,
+                { token: 'string.quote', bracket: '@open', next: '@sstring' },
+              ],
+            ],
+            dstring: [
+              [/\[/, { token: '@brackets', next: '@nestedCall' }],
+              [
+                /\$+(?:\:\:)?\{/,
+                { token: 'identifier', next: '@nestedVariable' },
+              ],
+              [/@variables/, 'type.identifier'],
+              [/[^\\$\[\]"]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/"/, { token: 'string.quote', bracket: '@close', next: '@pop' }],
+            ],
+            sstring: [
+              [/\[/, { token: '@brackets', next: '@nestedCall' }],
+              [
+                /\$+(?:\:\:)?\{/,
+                { token: 'identifier', next: '@nestedVariable' },
+              ],
+              [/@variables/, 'type.identifier'],
+              [/[^\\$\[\]']+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/'/, { token: 'string.quote', bracket: '@close', next: '@pop' }],
+            ],
+            whitespace: [
+              [/[ \t\r\n]+/, 'white'],
+              [/#.*\\$/, { token: 'comment', next: '@newlineComment' }],
+              [/#.*(?!\\)$/, 'comment'],
+            ],
+            newlineComment: [
+              [/.*\\$/, 'comment'],
+              [/.*(?!\\)$/, { token: 'comment', next: '@pop' }],
+            ],
+            nestedVariable: [
+              [/[^\{\}\$]+/, 'type.identifier'],
+              [/\}/, { token: 'identifier', next: '@pop' }],
+            ],
+            nestedCall: [
+              [/\[/, { token: '@brackets', next: '@nestedCall' }],
+              [/\]/, { token: '@brackets', next: '@pop' }],
+              { include: 'root' },
+            ],
+            specialFunc: [
+              [/"/, { token: 'string', next: '@dstring' }],
+              [/'/, { token: 'string', next: '@sstring' }],
+              [/\S+/, { token: 'type', next: '@pop' }],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/7835.7835.js

@@ -0,0 +1,516 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [7835],
+  {
+    47835: (e, t, p) => {
+      'use strict';
+      p.r(t), p.d(t, { conf: () => n, language: () => i });
+      var n = {
+          wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+          comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}', notIn: ['string'] },
+            { open: '[', close: ']', notIn: ['string'] },
+            { open: '(', close: ')', notIn: ['string'] },
+            { open: '"', close: '"', notIn: ['string'] },
+            { open: "'", close: "'", notIn: ['string', 'comment'] },
+          ],
+          folding: {
+            markers: {
+              start: new RegExp('^\\s*(#|//)region\\b'),
+              end: new RegExp('^\\s*(#|//)endregion\\b'),
+            },
+          },
+        },
+        i = {
+          defaultToken: '',
+          tokenPostfix: '',
+          tokenizer: {
+            root: [
+              [
+                /<\?((php)|=)?/,
+                { token: '@rematch', switchTo: '@phpInSimpleState.root' },
+              ],
+              [/<!DOCTYPE/, 'metatag.html', '@doctype'],
+              [/<!--/, 'comment.html', '@comment'],
+              [
+                /(<)(\w+)(\/>)/,
+                ['delimiter.html', 'tag.html', 'delimiter.html'],
+              ],
+              [
+                /(<)(script)/,
+                ['delimiter.html', { token: 'tag.html', next: '@script' }],
+              ],
+              [
+                /(<)(style)/,
+                ['delimiter.html', { token: 'tag.html', next: '@style' }],
+              ],
+              [
+                /(<)([:\w]+)/,
+                ['delimiter.html', { token: 'tag.html', next: '@otherTag' }],
+              ],
+              [
+                /(<\/)(\w+)/,
+                ['delimiter.html', { token: 'tag.html', next: '@otherTag' }],
+              ],
+              [/</, 'delimiter.html'],
+              [/[^<]+/],
+            ],
+            doctype: [
+              [
+                /<\?((php)|=)?/,
+                { token: '@rematch', switchTo: '@phpInSimpleState.comment' },
+              ],
+              [/[^>]+/, 'metatag.content.html'],
+              [/>/, 'metatag.html', '@pop'],
+            ],
+            comment: [
+              [
+                /<\?((php)|=)?/,
+                { token: '@rematch', switchTo: '@phpInSimpleState.comment' },
+              ],
+              [/-->/, 'comment.html', '@pop'],
+              [/[^-]+/, 'comment.content.html'],
+              [/./, 'comment.content.html'],
+            ],
+            otherTag: [
+              [
+                /<\?((php)|=)?/,
+                { token: '@rematch', switchTo: '@phpInSimpleState.otherTag' },
+              ],
+              [/\/?>/, 'delimiter.html', '@pop'],
+              [/"([^"]*)"/, 'attribute.value'],
+              [/'([^']*)'/, 'attribute.value'],
+              [/[\w\-]+/, 'attribute.name'],
+              [/=/, 'delimiter'],
+              [/[ \t\r\n]+/],
+            ],
+            script: [
+              [
+                /<\?((php)|=)?/,
+                { token: '@rematch', switchTo: '@phpInSimpleState.script' },
+              ],
+              [/type/, 'attribute.name', '@scriptAfterType'],
+              [/"([^"]*)"/, 'attribute.value'],
+              [/'([^']*)'/, 'attribute.value'],
+              [/[\w\-]+/, 'attribute.name'],
+              [/=/, 'delimiter'],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@scriptEmbedded.text/javascript',
+                  nextEmbedded: 'text/javascript',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [
+                /(<\/)(script\s*)(>)/,
+                [
+                  'delimiter.html',
+                  'tag.html',
+                  { token: 'delimiter.html', next: '@pop' },
+                ],
+              ],
+            ],
+            scriptAfterType: [
+              [
+                /<\?((php)|=)?/,
+                {
+                  token: '@rematch',
+                  switchTo: '@phpInSimpleState.scriptAfterType',
+                },
+              ],
+              [/=/, 'delimiter', '@scriptAfterTypeEquals'],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@scriptEmbedded.text/javascript',
+                  nextEmbedded: 'text/javascript',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            scriptAfterTypeEquals: [
+              [
+                /<\?((php)|=)?/,
+                {
+                  token: '@rematch',
+                  switchTo: '@phpInSimpleState.scriptAfterTypeEquals',
+                },
+              ],
+              [
+                /"([^"]*)"/,
+                {
+                  token: 'attribute.value',
+                  switchTo: '@scriptWithCustomType.$1',
+                },
+              ],
+              [
+                /'([^']*)'/,
+                {
+                  token: 'attribute.value',
+                  switchTo: '@scriptWithCustomType.$1',
+                },
+              ],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@scriptEmbedded.text/javascript',
+                  nextEmbedded: 'text/javascript',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            scriptWithCustomType: [
+              [
+                /<\?((php)|=)?/,
+                {
+                  token: '@rematch',
+                  switchTo: '@phpInSimpleState.scriptWithCustomType.$S2',
+                },
+              ],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@scriptEmbedded.$S2',
+                  nextEmbedded: '$S2',
+                },
+              ],
+              [/"([^"]*)"/, 'attribute.value'],
+              [/'([^']*)'/, 'attribute.value'],
+              [/[\w\-]+/, 'attribute.name'],
+              [/=/, 'delimiter'],
+              [/[ \t\r\n]+/],
+              [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            scriptEmbedded: [
+              [
+                /<\?((php)|=)?/,
+                {
+                  token: '@rematch',
+                  switchTo: '@phpInEmbeddedState.scriptEmbedded.$S2',
+                  nextEmbedded: '@pop',
+                },
+              ],
+              [
+                /<\/script/,
+                { token: '@rematch', next: '@pop', nextEmbedded: '@pop' },
+              ],
+            ],
+            style: [
+              [
+                /<\?((php)|=)?/,
+                { token: '@rematch', switchTo: '@phpInSimpleState.style' },
+              ],
+              [/type/, 'attribute.name', '@styleAfterType'],
+              [/"([^"]*)"/, 'attribute.value'],
+              [/'([^']*)'/, 'attribute.value'],
+              [/[\w\-]+/, 'attribute.name'],
+              [/=/, 'delimiter'],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@styleEmbedded.text/css',
+                  nextEmbedded: 'text/css',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [
+                /(<\/)(style\s*)(>)/,
+                [
+                  'delimiter.html',
+                  'tag.html',
+                  { token: 'delimiter.html', next: '@pop' },
+                ],
+              ],
+            ],
+            styleAfterType: [
+              [
+                /<\?((php)|=)?/,
+                {
+                  token: '@rematch',
+                  switchTo: '@phpInSimpleState.styleAfterType',
+                },
+              ],
+              [/=/, 'delimiter', '@styleAfterTypeEquals'],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@styleEmbedded.text/css',
+                  nextEmbedded: 'text/css',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            styleAfterTypeEquals: [
+              [
+                /<\?((php)|=)?/,
+                {
+                  token: '@rematch',
+                  switchTo: '@phpInSimpleState.styleAfterTypeEquals',
+                },
+              ],
+              [
+                /"([^"]*)"/,
+                {
+                  token: 'attribute.value',
+                  switchTo: '@styleWithCustomType.$1',
+                },
+              ],
+              [
+                /'([^']*)'/,
+                {
+                  token: 'attribute.value',
+                  switchTo: '@styleWithCustomType.$1',
+                },
+              ],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@styleEmbedded.text/css',
+                  nextEmbedded: 'text/css',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            styleWithCustomType: [
+              [
+                /<\?((php)|=)?/,
+                {
+                  token: '@rematch',
+                  switchTo: '@phpInSimpleState.styleWithCustomType.$S2',
+                },
+              ],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@styleEmbedded.$S2',
+                  nextEmbedded: '$S2',
+                },
+              ],
+              [/"([^"]*)"/, 'attribute.value'],
+              [/'([^']*)'/, 'attribute.value'],
+              [/[\w\-]+/, 'attribute.name'],
+              [/=/, 'delimiter'],
+              [/[ \t\r\n]+/],
+              [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            styleEmbedded: [
+              [
+                /<\?((php)|=)?/,
+                {
+                  token: '@rematch',
+                  switchTo: '@phpInEmbeddedState.styleEmbedded.$S2',
+                  nextEmbedded: '@pop',
+                },
+              ],
+              [
+                /<\/style/,
+                { token: '@rematch', next: '@pop', nextEmbedded: '@pop' },
+              ],
+            ],
+            phpInSimpleState: [
+              [/<\?((php)|=)?/, 'metatag.php'],
+              [/\?>/, { token: 'metatag.php', switchTo: '@$S2.$S3' }],
+              { include: 'phpRoot' },
+            ],
+            phpInEmbeddedState: [
+              [/<\?((php)|=)?/, 'metatag.php'],
+              [
+                /\?>/,
+                {
+                  token: 'metatag.php',
+                  switchTo: '@$S2.$S3',
+                  nextEmbedded: '$S3',
+                },
+              ],
+              { include: 'phpRoot' },
+            ],
+            phpRoot: [
+              [
+                /[a-zA-Z_]\w*/,
+                {
+                  cases: {
+                    '@phpKeywords': { token: 'keyword.php' },
+                    '@phpCompileTimeConstants': { token: 'constant.php' },
+                    '@default': 'identifier.php',
+                  },
+                },
+              ],
+              [
+                /[$a-zA-Z_]\w*/,
+                {
+                  cases: {
+                    '@phpPreDefinedVariables': {
+                      token: 'variable.predefined.php',
+                    },
+                    '@default': 'variable.php',
+                  },
+                },
+              ],
+              [/[{}]/, 'delimiter.bracket.php'],
+              [/[\[\]]/, 'delimiter.array.php'],
+              [/[()]/, 'delimiter.parenthesis.php'],
+              [/[ \t\r\n]+/],
+              [/(#|\/\/)$/, 'comment.php'],
+              [/(#|\/\/)/, 'comment.php', '@phpLineComment'],
+              [/\/\*/, 'comment.php', '@phpComment'],
+              [/"/, 'string.php', '@phpDoubleQuoteString'],
+              [/'/, 'string.php', '@phpSingleQuoteString'],
+              [/[\+\-\*\%\&\|\^\~\!\=\<\>\/\?\;\:\.\,\@]/, 'delimiter.php'],
+              [/\d*\d+[eE]([\-+]?\d+)?/, 'number.float.php'],
+              [/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float.php'],
+              [/0[xX][0-9a-fA-F']*[0-9a-fA-F]/, 'number.hex.php'],
+              [/0[0-7']*[0-7]/, 'number.octal.php'],
+              [/0[bB][0-1']*[0-1]/, 'number.binary.php'],
+              [/\d[\d']*/, 'number.php'],
+              [/\d/, 'number.php'],
+            ],
+            phpComment: [
+              [/\*\//, 'comment.php', '@pop'],
+              [/[^*]+/, 'comment.php'],
+              [/./, 'comment.php'],
+            ],
+            phpLineComment: [
+              [/\?>/, { token: '@rematch', next: '@pop' }],
+              [/.$/, 'comment.php', '@pop'],
+              [/[^?]+$/, 'comment.php', '@pop'],
+              [/[^?]+/, 'comment.php'],
+              [/./, 'comment.php'],
+            ],
+            phpDoubleQuoteString: [
+              [/[^\\"]+/, 'string.php'],
+              [/@escapes/, 'string.escape.php'],
+              [/\\./, 'string.escape.invalid.php'],
+              [/"/, 'string.php', '@pop'],
+            ],
+            phpSingleQuoteString: [
+              [/[^\\']+/, 'string.php'],
+              [/@escapes/, 'string.escape.php'],
+              [/\\./, 'string.escape.invalid.php'],
+              [/'/, 'string.php', '@pop'],
+            ],
+          },
+          phpKeywords: [
+            'abstract',
+            'and',
+            'array',
+            'as',
+            'break',
+            'callable',
+            'case',
+            'catch',
+            'cfunction',
+            'class',
+            'clone',
+            'const',
+            'continue',
+            'declare',
+            'default',
+            'do',
+            'else',
+            'elseif',
+            'enddeclare',
+            'endfor',
+            'endforeach',
+            'endif',
+            'endswitch',
+            'endwhile',
+            'extends',
+            'false',
+            'final',
+            'for',
+            'foreach',
+            'function',
+            'global',
+            'goto',
+            'if',
+            'implements',
+            'interface',
+            'instanceof',
+            'insteadof',
+            'namespace',
+            'new',
+            'null',
+            'object',
+            'old_function',
+            'or',
+            'private',
+            'protected',
+            'public',
+            'resource',
+            'static',
+            'switch',
+            'throw',
+            'trait',
+            'try',
+            'true',
+            'use',
+            'var',
+            'while',
+            'xor',
+            'die',
+            'echo',
+            'empty',
+            'exit',
+            'eval',
+            'include',
+            'include_once',
+            'isset',
+            'list',
+            'require',
+            'require_once',
+            'return',
+            'print',
+            'unset',
+            'yield',
+            '__construct',
+          ],
+          phpCompileTimeConstants: [
+            '__CLASS__',
+            '__DIR__',
+            '__FILE__',
+            '__LINE__',
+            '__NAMESPACE__',
+            '__METHOD__',
+            '__FUNCTION__',
+            '__TRAIT__',
+          ],
+          phpPreDefinedVariables: [
+            '$GLOBALS',
+            '$_SERVER',
+            '$_GET',
+            '$_POST',
+            '$_FILES',
+            '$_REQUEST',
+            '$_SESSION',
+            '$_ENV',
+            '$_COOKIE',
+            '$php_errormsg',
+            '$HTTP_RAW_POST_DATA',
+            '$http_response_header',
+            '$argc',
+            '$argv',
+          ],
+          escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+        };
+    },
+  },
+]);

docs/8070.8070.js

@@ -0,0 +1,676 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [8070],
+  {
+    8070: (e, t, s) => {
+      'use strict';
+      s.r(t), s.d(t, { conf: () => r, language: () => i });
+      var r = {
+          comments: { lineComment: '#' },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+            { open: '`', close: '`' },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+            { open: '`', close: '`' },
+          ],
+        },
+        i = {
+          defaultToken: '',
+          tokenPostfix: '.perl',
+          brackets: [
+            { token: 'delimiter.bracket', open: '{', close: '}' },
+            { token: 'delimiter.parenthesis', open: '(', close: ')' },
+            { token: 'delimiter.square', open: '[', close: ']' },
+          ],
+          keywords: [
+            '__DATA__',
+            'else',
+            'lock',
+            '__END__',
+            'elsif',
+            'lt',
+            '__FILE__',
+            'eq',
+            '__LINE__',
+            'exp',
+            'ne',
+            'sub',
+            '__PACKAGE__',
+            'for',
+            'no',
+            'and',
+            'foreach',
+            'or',
+            'unless',
+            'cmp',
+            'ge',
+            'package',
+            'until',
+            'continue',
+            'gt',
+            'while',
+            'CORE',
+            'if',
+            'xor',
+            'do',
+            'le',
+            '__DIE__',
+            '__WARN__',
+          ],
+          builtinFunctions: [
+            '-A',
+            'END',
+            'length',
+            'setpgrp',
+            '-B',
+            'endgrent',
+            'link',
+            'setpriority',
+            '-b',
+            'endhostent',
+            'listen',
+            'setprotoent',
+            '-C',
+            'endnetent',
+            'local',
+            'setpwent',
+            '-c',
+            'endprotoent',
+            'localtime',
+            'setservent',
+            '-d',
+            'endpwent',
+            'log',
+            'setsockopt',
+            '-e',
+            'endservent',
+            'lstat',
+            'shift',
+            '-f',
+            'eof',
+            'map',
+            'shmctl',
+            '-g',
+            'eval',
+            'mkdir',
+            'shmget',
+            '-k',
+            'exec',
+            'msgctl',
+            'shmread',
+            '-l',
+            'exists',
+            'msgget',
+            'shmwrite',
+            '-M',
+            'exit',
+            'msgrcv',
+            'shutdown',
+            '-O',
+            'fcntl',
+            'msgsnd',
+            'sin',
+            '-o',
+            'fileno',
+            'my',
+            'sleep',
+            '-p',
+            'flock',
+            'next',
+            'socket',
+            '-r',
+            'fork',
+            'not',
+            'socketpair',
+            '-R',
+            'format',
+            'oct',
+            'sort',
+            '-S',
+            'formline',
+            'open',
+            'splice',
+            '-s',
+            'getc',
+            'opendir',
+            'split',
+            '-T',
+            'getgrent',
+            'ord',
+            'sprintf',
+            '-t',
+            'getgrgid',
+            'our',
+            'sqrt',
+            '-u',
+            'getgrnam',
+            'pack',
+            'srand',
+            '-w',
+            'gethostbyaddr',
+            'pipe',
+            'stat',
+            '-W',
+            'gethostbyname',
+            'pop',
+            'state',
+            '-X',
+            'gethostent',
+            'pos',
+            'study',
+            '-x',
+            'getlogin',
+            'print',
+            'substr',
+            '-z',
+            'getnetbyaddr',
+            'printf',
+            'symlink',
+            'abs',
+            'getnetbyname',
+            'prototype',
+            'syscall',
+            'accept',
+            'getnetent',
+            'push',
+            'sysopen',
+            'alarm',
+            'getpeername',
+            'quotemeta',
+            'sysread',
+            'atan2',
+            'getpgrp',
+            'rand',
+            'sysseek',
+            'AUTOLOAD',
+            'getppid',
+            'read',
+            'system',
+            'BEGIN',
+            'getpriority',
+            'readdir',
+            'syswrite',
+            'bind',
+            'getprotobyname',
+            'readline',
+            'tell',
+            'binmode',
+            'getprotobynumber',
+            'readlink',
+            'telldir',
+            'bless',
+            'getprotoent',
+            'readpipe',
+            'tie',
+            'break',
+            'getpwent',
+            'recv',
+            'tied',
+            'caller',
+            'getpwnam',
+            'redo',
+            'time',
+            'chdir',
+            'getpwuid',
+            'ref',
+            'times',
+            'CHECK',
+            'getservbyname',
+            'rename',
+            'truncate',
+            'chmod',
+            'getservbyport',
+            'require',
+            'uc',
+            'chomp',
+            'getservent',
+            'reset',
+            'ucfirst',
+            'chop',
+            'getsockname',
+            'return',
+            'umask',
+            'chown',
+            'getsockopt',
+            'reverse',
+            'undef',
+            'chr',
+            'glob',
+            'rewinddir',
+            'UNITCHECK',
+            'chroot',
+            'gmtime',
+            'rindex',
+            'unlink',
+            'close',
+            'goto',
+            'rmdir',
+            'unpack',
+            'closedir',
+            'grep',
+            'say',
+            'unshift',
+            'connect',
+            'hex',
+            'scalar',
+            'untie',
+            'cos',
+            'index',
+            'seek',
+            'use',
+            'crypt',
+            'INIT',
+            'seekdir',
+            'utime',
+            'dbmclose',
+            'int',
+            'select',
+            'values',
+            'dbmopen',
+            'ioctl',
+            'semctl',
+            'vec',
+            'defined',
+            'join',
+            'semget',
+            'wait',
+            'delete',
+            'keys',
+            'semop',
+            'waitpid',
+            'DESTROY',
+            'kill',
+            'send',
+            'wantarray',
+            'die',
+            'last',
+            'setgrent',
+            'warn',
+            'dump',
+            'lc',
+            'sethostent',
+            'write',
+            'each',
+            'lcfirst',
+            'setnetent',
+          ],
+          builtinFileHandlers: [
+            'ARGV',
+            'STDERR',
+            'STDOUT',
+            'ARGVOUT',
+            'STDIN',
+            'ENV',
+          ],
+          builtinVariables: [
+            '$!',
+            '$^RE_TRIE_MAXBUF',
+            '$LAST_REGEXP_CODE_RESULT',
+            '$"',
+            '$^S',
+            '$LIST_SEPARATOR',
+            '$#',
+            '$^T',
+            '$MATCH',
+            '$$',
+            '$^TAINT',
+            '$MULTILINE_MATCHING',
+            '$%',
+            '$^UNICODE',
+            '$NR',
+            '$&',
+            '$^UTF8LOCALE',
+            '$OFMT',
+            "$'",
+            '$^V',
+            '$OFS',
+            '$(',
+            '$^W',
+            '$ORS',
+            '$)',
+            '$^WARNING_BITS',
+            '$OS_ERROR',
+            '$*',
+            '$^WIDE_SYSTEM_CALLS',
+            '$OSNAME',
+            '$+',
+            '$^X',
+            '$OUTPUT_AUTO_FLUSH',
+            '$,',
+            '$_',
+            '$OUTPUT_FIELD_SEPARATOR',
+            '$-',
+            '$`',
+            '$OUTPUT_RECORD_SEPARATOR',
+            '$.',
+            '$a',
+            '$PERL_VERSION',
+            '$/',
+            '$ACCUMULATOR',
+            '$PERLDB',
+            '$0',
+            '$ARG',
+            '$PID',
+            '$:',
+            '$ARGV',
+            '$POSTMATCH',
+            '$;',
+            '$b',
+            '$PREMATCH',
+            '$<',
+            '$BASETIME',
+            '$PROCESS_ID',
+            '$=',
+            '$CHILD_ERROR',
+            '$PROGRAM_NAME',
+            '$>',
+            '$COMPILING',
+            '$REAL_GROUP_ID',
+            '$?',
+            '$DEBUGGING',
+            '$REAL_USER_ID',
+            '$@',
+            '$EFFECTIVE_GROUP_ID',
+            '$RS',
+            '$[',
+            '$EFFECTIVE_USER_ID',
+            '$SUBSCRIPT_SEPARATOR',
+            '$\\',
+            '$EGID',
+            '$SUBSEP',
+            '$]',
+            '$ERRNO',
+            '$SYSTEM_FD_MAX',
+            '$^',
+            '$EUID',
+            '$UID',
+            '$^A',
+            '$EVAL_ERROR',
+            '$WARNING',
+            '$^C',
+            '$EXCEPTIONS_BEING_CAUGHT',
+            '$|',
+            '$^CHILD_ERROR_NATIVE',
+            '$EXECUTABLE_NAME',
+            '$~',
+            '$^D',
+            '$EXTENDED_OS_ERROR',
+            '%!',
+            '$^E',
+            '$FORMAT_FORMFEED',
+            '%^H',
+            '$^ENCODING',
+            '$FORMAT_LINE_BREAK_CHARACTERS',
+            '%ENV',
+            '$^F',
+            '$FORMAT_LINES_LEFT',
+            '%INC',
+            '$^H',
+            '$FORMAT_LINES_PER_PAGE',
+            '%OVERLOAD',
+            '$^I',
+            '$FORMAT_NAME',
+            '%SIG',
+            '$^L',
+            '$FORMAT_PAGE_NUMBER',
+            '@+',
+            '$^M',
+            '$FORMAT_TOP_NAME',
+            '@-',
+            '$^N',
+            '$GID',
+            '@_',
+            '$^O',
+            '$INPLACE_EDIT',
+            '@ARGV',
+            '$^OPEN',
+            '$INPUT_LINE_NUMBER',
+            '@INC',
+            '$^P',
+            '$INPUT_RECORD_SEPARATOR',
+            '@LAST_MATCH_START',
+            '$^R',
+            '$LAST_MATCH_END',
+            '$^RE_DEBUG_FLAGS',
+            '$LAST_PAREN_MATCH',
+          ],
+          symbols: /[:+\-\^*$&%@=<>!?|\/~\.]/,
+          quoteLikeOps: ['qr', 'm', 's', 'q', 'qq', 'qx', 'qw', 'tr', 'y'],
+          escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+          tokenizer: {
+            root: [
+              { include: '@whitespace' },
+              [
+                /[a-zA-Z\-_][\w\-_]*/,
+                {
+                  cases: {
+                    '@keywords': 'keyword',
+                    '@builtinFunctions': 'type.identifier',
+                    '@builtinFileHandlers': 'variable.predefined',
+                    '@quoteLikeOps': {
+                      token: '@rematch',
+                      next: 'quotedConstructs',
+                    },
+                    '@default': '',
+                  },
+                },
+              ],
+              [
+                /[\$@%][*@#?\+\-\$!\w\\\^><~:;\.]+/,
+                {
+                  cases: {
+                    '@builtinVariables': 'variable.predefined',
+                    '@default': 'variable',
+                  },
+                },
+              ],
+              { include: '@strings' },
+              { include: '@dblStrings' },
+              { include: '@perldoc' },
+              { include: '@heredoc' },
+              [/[{}\[\]()]/, '@brackets'],
+              [
+                /[\/](?:(?:\[(?:\\]|[^\]])+\])|(?:\\\/|[^\]\/]))*[\/]\w*\s*(?=[).,;]|$)/,
+                'regexp',
+              ],
+              [/@symbols/, 'operators'],
+              { include: '@numbers' },
+              [/[,;]/, 'delimiter'],
+            ],
+            whitespace: [
+              [/\s+/, 'white'],
+              [/(^#!.*$)/, 'metatag'],
+              [/(^#.*$)/, 'comment'],
+            ],
+            numbers: [
+              [/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
+              [/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/, 'number.hex'],
+              [/\d+/, 'number'],
+            ],
+            strings: [[/'/, 'string', '@stringBody']],
+            stringBody: [
+              [/'/, 'string', '@popall'],
+              [/\\'/, 'string.escape'],
+              [/./, 'string'],
+            ],
+            dblStrings: [[/"/, 'string', '@dblStringBody']],
+            dblStringBody: [
+              [/"/, 'string', '@popall'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              { include: '@variables' },
+              [/./, 'string'],
+            ],
+            quotedConstructs: [
+              [
+                /(q|qw|tr|y)\s*\(/,
+                { token: 'string.delim', switchTo: '@qstring.(.)' },
+              ],
+              [
+                /(q|qw|tr|y)\s*\[/,
+                { token: 'string.delim', switchTo: '@qstring.[.]' },
+              ],
+              [
+                /(q|qw|tr|y)\s*\{/,
+                { token: 'string.delim', switchTo: '@qstring.{.}' },
+              ],
+              [
+                /(q|qw|tr|y)\s*</,
+                { token: 'string.delim', switchTo: '@qstring.<.>' },
+              ],
+              [
+                /(q|qw|tr|y)#/,
+                { token: 'string.delim', switchTo: '@qstring.#.#' },
+              ],
+              [
+                /(q|qw|tr|y)\s*([^A-Za-z0-9#\s])/,
+                { token: 'string.delim', switchTo: '@qstring.$2.$2' },
+              ],
+              [
+                /(q|qw|tr|y)\s+(\w)/,
+                { token: 'string.delim', switchTo: '@qstring.$2.$2' },
+              ],
+              [
+                /(qr|m|s)\s*\(/,
+                { token: 'regexp.delim', switchTo: '@qregexp.(.)' },
+              ],
+              [
+                /(qr|m|s)\s*\[/,
+                { token: 'regexp.delim', switchTo: '@qregexp.[.]' },
+              ],
+              [
+                /(qr|m|s)\s*\{/,
+                { token: 'regexp.delim', switchTo: '@qregexp.{.}' },
+              ],
+              [
+                /(qr|m|s)\s*</,
+                { token: 'regexp.delim', switchTo: '@qregexp.<.>' },
+              ],
+              [
+                /(qr|m|s)#/,
+                { token: 'regexp.delim', switchTo: '@qregexp.#.#' },
+              ],
+              [
+                /(qr|m|s)\s*([^A-Za-z0-9_#\s])/,
+                { token: 'regexp.delim', switchTo: '@qregexp.$2.$2' },
+              ],
+              [
+                /(qr|m|s)\s+(\w)/,
+                { token: 'regexp.delim', switchTo: '@qregexp.$2.$2' },
+              ],
+              [
+                /(qq|qx)\s*\(/,
+                { token: 'string.delim', switchTo: '@qqstring.(.)' },
+              ],
+              [
+                /(qq|qx)\s*\[/,
+                { token: 'string.delim', switchTo: '@qqstring.[.]' },
+              ],
+              [
+                /(qq|qx)\s*\{/,
+                { token: 'string.delim', switchTo: '@qqstring.{.}' },
+              ],
+              [
+                /(qq|qx)\s*</,
+                { token: 'string.delim', switchTo: '@qqstring.<.>' },
+              ],
+              [
+                /(qq|qx)#/,
+                { token: 'string.delim', switchTo: '@qqstring.#.#' },
+              ],
+              [
+                /(qq|qx)\s*([^A-Za-z0-9#\s])/,
+                { token: 'string.delim', switchTo: '@qqstring.$2.$2' },
+              ],
+              [
+                /(qq|qx)\s+(\w)/,
+                { token: 'string.delim', switchTo: '@qqstring.$2.$2' },
+              ],
+            ],
+            qstring: [
+              [/\\./, 'string.escape'],
+              [
+                /./,
+                {
+                  cases: {
+                    '$#==$S3': { token: 'string.delim', next: '@pop' },
+                    '$#==$S2': { token: 'string.delim', next: '@push' },
+                    '@default': 'string',
+                  },
+                },
+              ],
+            ],
+            qregexp: [
+              { include: '@variables' },
+              [/\\./, 'regexp.escape'],
+              [
+                /./,
+                {
+                  cases: {
+                    '$#==$S3': {
+                      token: 'regexp.delim',
+                      next: '@regexpModifiers',
+                    },
+                    '$#==$S2': { token: 'regexp.delim', next: '@push' },
+                    '@default': 'regexp',
+                  },
+                },
+              ],
+            ],
+            regexpModifiers: [
+              [
+                /[msixpodualngcer]+/,
+                { token: 'regexp.modifier', next: '@popall' },
+              ],
+            ],
+            qqstring: [{ include: '@variables' }, { include: '@qstring' }],
+            heredoc: [
+              [
+                /<<\s*['"`]?([\w\-]+)['"`]?/,
+                { token: 'string.heredoc.delimiter', next: '@heredocBody.$1' },
+              ],
+            ],
+            heredocBody: [
+              [
+                /^([\w\-]+)$/,
+                {
+                  cases: {
+                    '$1==$S2': [
+                      { token: 'string.heredoc.delimiter', next: '@popall' },
+                    ],
+                    '@default': 'string.heredoc',
+                  },
+                },
+              ],
+              [/./, 'string.heredoc'],
+            ],
+            perldoc: [[/^=\w/, 'comment.doc', '@perldocBody']],
+            perldocBody: [
+              [/^=cut\b/, 'type.identifier', '@popall'],
+              [/./, 'comment.doc'],
+            ],
+            variables: [
+              [/\$\w+/, 'variable'],
+              [/@\w+/, 'variable'],
+              [/%\w+/, 'variable'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/8084.8084.js

@@ -0,0 +1,151 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [8084],
+  {
+    98084: (e, o, n) => {
+      'use strict';
+      n.r(o), n.d(o, { conf: () => t, language: () => s });
+      var t = {
+          comments: { lineComment: '//', blockComment: ['(*', '*)'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+            ['<', '>'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '<', close: '>' },
+            { open: "'", close: "'" },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '<', close: '>' },
+            { open: "'", close: "'" },
+          ],
+        },
+        s = {
+          defaultToken: '',
+          tokenPostfix: '.pascaligo',
+          ignoreCase: !0,
+          brackets: [
+            { open: '{', close: '}', token: 'delimiter.curly' },
+            { open: '[', close: ']', token: 'delimiter.square' },
+            { open: '(', close: ')', token: 'delimiter.parenthesis' },
+            { open: '<', close: '>', token: 'delimiter.angle' },
+          ],
+          keywords: [
+            'begin',
+            'block',
+            'case',
+            'const',
+            'else',
+            'end',
+            'fail',
+            'for',
+            'from',
+            'function',
+            'if',
+            'is',
+            'nil',
+            'of',
+            'remove',
+            'return',
+            'skip',
+            'then',
+            'type',
+            'var',
+            'while',
+            'with',
+            'option',
+            'None',
+            'transaction',
+          ],
+          typeKeywords: [
+            'bool',
+            'int',
+            'list',
+            'map',
+            'nat',
+            'record',
+            'string',
+            'unit',
+            'address',
+            'map',
+            'mtz',
+            'xtz',
+          ],
+          operators: [
+            '=',
+            '>',
+            '<',
+            '<=',
+            '>=',
+            '<>',
+            ':',
+            ':=',
+            'and',
+            'mod',
+            'or',
+            '+',
+            '-',
+            '*',
+            '/',
+            '@',
+            '&',
+            '^',
+            '%',
+          ],
+          symbols: /[=><:@\^&|+\-*\/\^%]+/,
+          tokenizer: {
+            root: [
+              [
+                /[a-zA-Z_][\w]*/,
+                {
+                  cases: {
+                    '@keywords': { token: 'keyword.$0' },
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+              { include: '@whitespace' },
+              [/[{}()\[\]]/, '@brackets'],
+              [/[<>](?!@symbols)/, '@brackets'],
+              [
+                /@symbols/,
+                { cases: { '@operators': 'delimiter', '@default': '' } },
+              ],
+              [/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
+              [/\$[0-9a-fA-F]{1,16}/, 'number.hex'],
+              [/\d+/, 'number'],
+              [/[;,.]/, 'delimiter'],
+              [/'([^'\\]|\\.)*$/, 'string.invalid'],
+              [/'/, 'string', '@string'],
+              [/'[^\\']'/, 'string'],
+              [/'/, 'string.invalid'],
+              [/\#\d+/, 'string'],
+            ],
+            comment: [
+              [/[^\(\*]+/, 'comment'],
+              [/\*\)/, 'comment', '@pop'],
+              [/\(\*/, 'comment'],
+            ],
+            string: [
+              [/[^\\']+/, 'string'],
+              [/\\./, 'string.escape.invalid'],
+              [/'/, { token: 'string.quote', bracket: '@close', next: '@pop' }],
+            ],
+            whitespace: [
+              [/[ \t\r\n]+/, 'white'],
+              [/\(\*/, 'comment', '@comment'],
+              [/\/\/.*$/, 'comment'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/8180.8180.js

@@ -0,0 +1,516 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [8180],
+  {
+    48180: (e, t, n) => {
+      'use strict';
+      n.r(t), n.d(t, { conf: () => i, language: () => o });
+      var i = {
+          comments: { lineComment: '//', blockComment: ['(*', '*)'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+            ['<', '>'],
+          ],
+          autoClosingPairs: [
+            { open: '"', close: '"', notIn: ['string', 'comment'] },
+            { open: '{', close: '}', notIn: ['string', 'comment'] },
+            { open: '[', close: ']', notIn: ['string', 'comment'] },
+            { open: '(', close: ')', notIn: ['string', 'comment'] },
+          ],
+        },
+        o = {
+          tokenPostfix: '.pats',
+          defaultToken: 'invalid',
+          keywords: [
+            'abstype',
+            'abst0ype',
+            'absprop',
+            'absview',
+            'absvtype',
+            'absviewtype',
+            'absvt0ype',
+            'absviewt0ype',
+            'as',
+            'and',
+            'assume',
+            'begin',
+            'classdec',
+            'datasort',
+            'datatype',
+            'dataprop',
+            'dataview',
+            'datavtype',
+            'dataviewtype',
+            'do',
+            'end',
+            'extern',
+            'extype',
+            'extvar',
+            'exception',
+            'fn',
+            'fnx',
+            'fun',
+            'prfn',
+            'prfun',
+            'praxi',
+            'castfn',
+            'if',
+            'then',
+            'else',
+            'ifcase',
+            'in',
+            'infix',
+            'infixl',
+            'infixr',
+            'prefix',
+            'postfix',
+            'implmnt',
+            'implement',
+            'primplmnt',
+            'primplement',
+            'import',
+            'let',
+            'local',
+            'macdef',
+            'macrodef',
+            'nonfix',
+            'symelim',
+            'symintr',
+            'overload',
+            'of',
+            'op',
+            'rec',
+            'sif',
+            'scase',
+            'sortdef',
+            'sta',
+            'stacst',
+            'stadef',
+            'static',
+            'staload',
+            'dynload',
+            'try',
+            'tkindef',
+            'typedef',
+            'propdef',
+            'viewdef',
+            'vtypedef',
+            'viewtypedef',
+            'prval',
+            'var',
+            'prvar',
+            'when',
+            'where',
+            'with',
+            'withtype',
+            'withprop',
+            'withview',
+            'withvtype',
+            'withviewtype',
+          ],
+          keywords_dlr: [
+            '$delay',
+            '$ldelay',
+            '$arrpsz',
+            '$arrptrsize',
+            '$d2ctype',
+            '$effmask',
+            '$effmask_ntm',
+            '$effmask_exn',
+            '$effmask_ref',
+            '$effmask_wrt',
+            '$effmask_all',
+            '$extern',
+            '$extkind',
+            '$extype',
+            '$extype_struct',
+            '$extval',
+            '$extfcall',
+            '$extmcall',
+            '$literal',
+            '$myfilename',
+            '$mylocation',
+            '$myfunction',
+            '$lst',
+            '$lst_t',
+            '$lst_vt',
+            '$list',
+            '$list_t',
+            '$list_vt',
+            '$rec',
+            '$rec_t',
+            '$rec_vt',
+            '$record',
+            '$record_t',
+            '$record_vt',
+            '$tup',
+            '$tup_t',
+            '$tup_vt',
+            '$tuple',
+            '$tuple_t',
+            '$tuple_vt',
+            '$break',
+            '$continue',
+            '$raise',
+            '$showtype',
+            '$vcopyenv_v',
+            '$vcopyenv_vt',
+            '$tempenver',
+            '$solver_assert',
+            '$solver_verify',
+          ],
+          keywords_srp: [
+            '#if',
+            '#ifdef',
+            '#ifndef',
+            '#then',
+            '#elif',
+            '#elifdef',
+            '#elifndef',
+            '#else',
+            '#endif',
+            '#error',
+            '#prerr',
+            '#print',
+            '#assert',
+            '#undef',
+            '#define',
+            '#include',
+            '#require',
+            '#pragma',
+            '#codegen2',
+            '#codegen3',
+          ],
+          irregular_keyword_list: [
+            'val+',
+            'val-',
+            'val',
+            'case+',
+            'case-',
+            'case',
+            'addr@',
+            'addr',
+            'fold@',
+            'free@',
+            'fix@',
+            'fix',
+            'lam@',
+            'lam',
+            'llam@',
+            'llam',
+            'viewt@ype+',
+            'viewt@ype-',
+            'viewt@ype',
+            'viewtype+',
+            'viewtype-',
+            'viewtype',
+            'view+',
+            'view-',
+            'view@',
+            'view',
+            'type+',
+            'type-',
+            'type',
+            'vtype+',
+            'vtype-',
+            'vtype',
+            'vt@ype+',
+            'vt@ype-',
+            'vt@ype',
+            'viewt@ype+',
+            'viewt@ype-',
+            'viewt@ype',
+            'viewtype+',
+            'viewtype-',
+            'viewtype',
+            'prop+',
+            'prop-',
+            'prop',
+            'type+',
+            'type-',
+            'type',
+            't@ype',
+            't@ype+',
+            't@ype-',
+            'abst@ype',
+            'abstype',
+            'absviewt@ype',
+            'absvt@ype',
+            'for*',
+            'for',
+            'while*',
+            'while',
+          ],
+          keywords_types: [
+            'bool',
+            'double',
+            'byte',
+            'int',
+            'short',
+            'char',
+            'void',
+            'unit',
+            'long',
+            'float',
+            'string',
+            'strptr',
+          ],
+          keywords_effects: [
+            '0',
+            'fun',
+            'clo',
+            'prf',
+            'funclo',
+            'cloptr',
+            'cloref',
+            'ref',
+            'ntm',
+            '1',
+          ],
+          operators: [
+            '@',
+            '!',
+            '|',
+            '`',
+            ':',
+            '$',
+            '.',
+            '=',
+            '#',
+            '~',
+            '..',
+            '...',
+            '=>',
+            '=<>',
+            '=/=>',
+            '=>>',
+            '=/=>>',
+            '<',
+            '>',
+            '><',
+            '.<',
+            '>.',
+            '.<>.',
+            '->',
+            '-<>',
+          ],
+          brackets: [
+            { open: ',(', close: ')', token: 'delimiter.parenthesis' },
+            { open: '`(', close: ')', token: 'delimiter.parenthesis' },
+            { open: '%(', close: ')', token: 'delimiter.parenthesis' },
+            { open: "'(", close: ')', token: 'delimiter.parenthesis' },
+            { open: "'{", close: '}', token: 'delimiter.parenthesis' },
+            { open: '@(', close: ')', token: 'delimiter.parenthesis' },
+            { open: '@{', close: '}', token: 'delimiter.brace' },
+            { open: '@[', close: ']', token: 'delimiter.square' },
+            { open: '#[', close: ']', token: 'delimiter.square' },
+            { open: '{', close: '}', token: 'delimiter.curly' },
+            { open: '[', close: ']', token: 'delimiter.square' },
+            { open: '(', close: ')', token: 'delimiter.parenthesis' },
+            { open: '<', close: '>', token: 'delimiter.angle' },
+          ],
+          symbols: /[=><!~?:&|+\-*\/\^%]+/,
+          IDENTFST: /[a-zA-Z_]/,
+          IDENTRST: /[a-zA-Z0-9_'$]/,
+          symbolic: /[%&+-./:=@~`^|*!$#?<>]/,
+          digit: /[0-9]/,
+          digitseq0: /@digit*/,
+          xdigit: /[0-9A-Za-z]/,
+          xdigitseq0: /@xdigit*/,
+          INTSP: /[lLuU]/,
+          FLOATSP: /[fFlL]/,
+          fexponent: /[eE][+-]?[0-9]+/,
+          fexponent_bin: /[pP][+-]?[0-9]+/,
+          deciexp: /\.[0-9]*@fexponent?/,
+          hexiexp: /\.[0-9a-zA-Z]*@fexponent_bin?/,
+          irregular_keywords: /val[+-]?|case[+-]?|addr\@?|fold\@|free\@|fix\@?|lam\@?|llam\@?|prop[+-]?|type[+-]?|view[+-@]?|viewt@?ype[+-]?|t@?ype[+-]?|v(iew)?t@?ype[+-]?|abst@?ype|absv(iew)?t@?ype|for\*?|while\*?/,
+          ESCHAR: /[ntvbrfa\\\?'"\(\[\{]/,
+          start: 'root',
+          tokenizer: {
+            root: [
+              { regex: /[ \t\r\n]+/, action: { token: '' } },
+              { regex: /\(\*\)/, action: { token: 'invalid' } },
+              {
+                regex: /\(\*/,
+                action: { token: 'comment', next: 'lexing_COMMENT_block_ml' },
+              },
+              { regex: /\(/, action: '@brackets' },
+              { regex: /\)/, action: '@brackets' },
+              { regex: /\[/, action: '@brackets' },
+              { regex: /\]/, action: '@brackets' },
+              { regex: /\{/, action: '@brackets' },
+              { regex: /\}/, action: '@brackets' },
+              { regex: /,\(/, action: '@brackets' },
+              { regex: /,/, action: { token: 'delimiter.comma' } },
+              { regex: /;/, action: { token: 'delimiter.semicolon' } },
+              { regex: /@\(/, action: '@brackets' },
+              { regex: /@\[/, action: '@brackets' },
+              { regex: /@\{/, action: '@brackets' },
+              {
+                regex: /:</,
+                action: { token: 'keyword', next: '@lexing_EFFECT_commaseq0' },
+              },
+              { regex: /\.@symbolic+/, action: { token: 'identifier.sym' } },
+              {
+                regex: /\.@digit*@fexponent@FLOATSP*/,
+                action: { token: 'number.float' },
+              },
+              { regex: /\.@digit+/, action: { token: 'number.float' } },
+              {
+                regex: /\$@IDENTFST@IDENTRST*/,
+                action: {
+                  cases: {
+                    '@keywords_dlr': { token: 'keyword.dlr' },
+                    '@default': { token: 'namespace' },
+                  },
+                },
+              },
+              {
+                regex: /\#@IDENTFST@IDENTRST*/,
+                action: {
+                  cases: {
+                    '@keywords_srp': { token: 'keyword.srp' },
+                    '@default': { token: 'identifier' },
+                  },
+                },
+              },
+              { regex: /%\(/, action: { token: 'delimiter.parenthesis' } },
+              {
+                regex: /^%{(#|\^|\$)?/,
+                action: {
+                  token: 'keyword',
+                  next: '@lexing_EXTCODE',
+                  nextEmbedded: 'text/javascript',
+                },
+              },
+              { regex: /^%}/, action: { token: 'keyword' } },
+              { regex: /'\(/, action: { token: 'delimiter.parenthesis' } },
+              { regex: /'\[/, action: { token: 'delimiter.bracket' } },
+              { regex: /'\{/, action: { token: 'delimiter.brace' } },
+              [
+                /(')(\\@ESCHAR|\\[xX]@xdigit+|\\@digit+)(')/,
+                ['string', 'string.escape', 'string'],
+              ],
+              [/'[^\\']'/, 'string'],
+              [/"/, 'string.quote', '@lexing_DQUOTE'],
+              { regex: /`\(/, action: '@brackets' },
+              { regex: /\\/, action: { token: 'punctuation' } },
+              {
+                regex: /@irregular_keywords(?!@IDENTRST)/,
+                action: { token: 'keyword' },
+              },
+              {
+                regex: /@IDENTFST@IDENTRST*[<!\[]?/,
+                action: {
+                  cases: {
+                    '@keywords': { token: 'keyword' },
+                    '@keywords_types': { token: 'type' },
+                    '@default': { token: 'identifier' },
+                  },
+                },
+              },
+              {
+                regex: /\/\/\/\//,
+                action: { token: 'comment', next: '@lexing_COMMENT_rest' },
+              },
+              { regex: /\/\/.*$/, action: { token: 'comment' } },
+              {
+                regex: /\/\*/,
+                action: { token: 'comment', next: '@lexing_COMMENT_block_c' },
+              },
+              {
+                regex: /-<|=</,
+                action: { token: 'keyword', next: '@lexing_EFFECT_commaseq0' },
+              },
+              {
+                regex: /@symbolic+/,
+                action: {
+                  cases: { '@operators': 'keyword', '@default': 'operator' },
+                },
+              },
+              {
+                regex: /0[xX]@xdigit+(@hexiexp|@fexponent_bin)@FLOATSP*/,
+                action: { token: 'number.float' },
+              },
+              {
+                regex: /0[xX]@xdigit+@INTSP*/,
+                action: { token: 'number.hex' },
+              },
+              {
+                regex: /0[0-7]+(?![0-9])@INTSP*/,
+                action: { token: 'number.octal' },
+              },
+              {
+                regex: /@digit+(@fexponent|@deciexp)@FLOATSP*/,
+                action: { token: 'number.float' },
+              },
+              {
+                regex: /@digit@digitseq0@INTSP*/,
+                action: { token: 'number.decimal' },
+              },
+              { regex: /@digit+@INTSP*/, action: { token: 'number' } },
+            ],
+            lexing_COMMENT_block_ml: [
+              [/[^\(\*]+/, 'comment'],
+              [/\(\*/, 'comment', '@push'],
+              [/\(\*/, 'comment.invalid'],
+              [/\*\)/, 'comment', '@pop'],
+              [/\*/, 'comment'],
+            ],
+            lexing_COMMENT_block_c: [
+              [/[^\/*]+/, 'comment'],
+              [/\*\//, 'comment', '@pop'],
+              [/[\/*]/, 'comment'],
+            ],
+            lexing_COMMENT_rest: [
+              [/$/, 'comment', '@pop'],
+              [/.*/, 'comment'],
+            ],
+            lexing_EFFECT_commaseq0: [
+              {
+                regex: /@IDENTFST@IDENTRST+|@digit+/,
+                action: {
+                  cases: {
+                    '@keywords_effects': { token: 'type.effect' },
+                    '@default': { token: 'identifier' },
+                  },
+                },
+              },
+              { regex: /,/, action: { token: 'punctuation' } },
+              { regex: />/, action: { token: '@rematch', next: '@pop' } },
+            ],
+            lexing_EXTCODE: [
+              {
+                regex: /^%}/,
+                action: {
+                  token: '@rematch',
+                  next: '@pop',
+                  nextEmbedded: '@pop',
+                },
+              },
+              { regex: /[^%]+/, action: '' },
+            ],
+            lexing_DQUOTE: [
+              { regex: /"/, action: { token: 'string.quote', next: '@pop' } },
+              {
+                regex: /(\{\$)(@IDENTFST@IDENTRST*)(\})/,
+                action: [
+                  { token: 'string.escape' },
+                  { token: 'identifier' },
+                  { token: 'string.escape' },
+                ],
+              },
+              { regex: /\\$/, action: { token: 'string.escape' } },
+              {
+                regex: /\\(@ESCHAR|[xX]@xdigit+|@digit+)/,
+                action: { token: 'string.escape' },
+              },
+              { regex: /[^\\"]+/, action: { token: 'string' } },
+            ],
+          },
+        };
+    },
+  },
+]);

docs/8424.8424.js

@@ -0,0 +1,367 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [8424],
+  {
+    98424: (t, e, i) => {
+      'use strict';
+      i.r(e), i.d(e, { conf: () => r, language: () => m });
+      var r = {
+          wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\$\^\&\*\(\)\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\s]+)/g,
+          comments: { blockComment: ['{#', '#}'] },
+          brackets: [
+            ['{#', '#}'],
+            ['{%', '%}'],
+            ['{{', '}}'],
+            ['(', ')'],
+            ['[', ']'],
+            ['\x3c!--', '--\x3e'],
+            ['<', '>'],
+          ],
+          autoClosingPairs: [
+            { open: '{# ', close: ' #}' },
+            { open: '{% ', close: ' %}' },
+            { open: '{{ ', close: ' }}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          surroundingPairs: [
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+            { open: '<', close: '>' },
+          ],
+        },
+        m = {
+          defaultToken: '',
+          tokenPostfix: '',
+          ignoreCase: !0,
+          keywords: [
+            'apply',
+            'autoescape',
+            'block',
+            'deprecated',
+            'do',
+            'embed',
+            'extends',
+            'flush',
+            'for',
+            'from',
+            'if',
+            'import',
+            'include',
+            'macro',
+            'sandbox',
+            'set',
+            'use',
+            'verbatim',
+            'with',
+            'endapply',
+            'endautoescape',
+            'endblock',
+            'endembed',
+            'endfor',
+            'endif',
+            'endmacro',
+            'endsandbox',
+            'endset',
+            'endwith',
+            'true',
+            'false',
+          ],
+          tokenizer: {
+            root: [
+              [/\s+/],
+              [/{#/, 'comment.twig', '@commentState'],
+              [/{%[-~]?/, 'delimiter.twig', '@blockState'],
+              [/{{[-~]?/, 'delimiter.twig', '@variableState'],
+              [/<!DOCTYPE/, 'metatag.html', '@doctype'],
+              [/<!--/, 'comment.html', '@comment'],
+              [
+                /(<)((?:[\w\-]+:)?[\w\-]+)(\s*)(\/>)/,
+                ['delimiter.html', 'tag.html', '', 'delimiter.html'],
+              ],
+              [
+                /(<)(script)/,
+                ['delimiter.html', { token: 'tag.html', next: '@script' }],
+              ],
+              [
+                /(<)(style)/,
+                ['delimiter.html', { token: 'tag.html', next: '@style' }],
+              ],
+              [
+                /(<)((?:[\w\-]+:)?[\w\-]+)/,
+                ['delimiter.html', { token: 'tag.html', next: '@otherTag' }],
+              ],
+              [
+                /(<\/)((?:[\w\-]+:)?[\w\-]+)/,
+                ['delimiter.html', { token: 'tag.html', next: '@otherTag' }],
+              ],
+              [/</, 'delimiter.html'],
+              [/[^<]+/],
+            ],
+            commentState: [
+              [/#}/, 'comment.twig', '@pop'],
+              [/./, 'comment.twig'],
+            ],
+            blockState: [
+              [/[-~]?%}/, 'delimiter.twig', '@pop'],
+              [/\s+/],
+              [
+                /(verbatim)(\s*)([-~]?%})/,
+                [
+                  'keyword.twig',
+                  '',
+                  { token: 'delimiter.twig', next: '@rawDataState' },
+                ],
+              ],
+              { include: 'expression' },
+            ],
+            rawDataState: [
+              [
+                /({%[-~]?)(\s*)(endverbatim)(\s*)([-~]?%})/,
+                [
+                  'delimiter.twig',
+                  '',
+                  'keyword.twig',
+                  '',
+                  { token: 'delimiter.twig', next: '@popall' },
+                ],
+              ],
+              [/./, 'string.twig'],
+            ],
+            variableState: [
+              [/[-~]?}}/, 'delimiter.twig', '@pop'],
+              { include: 'expression' },
+            ],
+            stringState: [
+              [/"/, 'string.twig', '@pop'],
+              [/#{\s*/, 'string.twig', '@interpolationState'],
+              [/[^#"\\]*(?:(?:\\.|#(?!\{))[^#"\\]*)*/, 'string.twig'],
+            ],
+            interpolationState: [
+              [/}/, 'string.twig', '@pop'],
+              { include: 'expression' },
+            ],
+            expression: [
+              [/\s+/],
+              [/\+|-|\/{1,2}|%|\*{1,2}/, 'operators.twig'],
+              [/(and|or|not|b-and|b-xor|b-or)(\s+)/, ['operators.twig', '']],
+              [/==|!=|<|>|>=|<=/, 'operators.twig'],
+              [/(starts with|ends with|matches)(\s+)/, ['operators.twig', '']],
+              [/(in)(\s+)/, ['operators.twig', '']],
+              [/(is)(\s+)/, ['operators.twig', '']],
+              [/\||~|:|\.{1,2}|\?{1,2}/, 'operators.twig'],
+              [
+                /[^\W\d][\w]*/,
+                {
+                  cases: {
+                    '@keywords': 'keyword.twig',
+                    '@default': 'variable.twig',
+                  },
+                },
+              ],
+              [/\d+(\.\d+)?/, 'number.twig'],
+              [/\(|\)|\[|\]|{|}|,/, 'delimiter.twig'],
+              [
+                /"([^#"\\]*(?:\\.[^#"\\]*)*)"|\'([^\'\\]*(?:\\.[^\'\\]*)*)\'/,
+                'string.twig',
+              ],
+              [/"/, 'string.twig', '@stringState'],
+              [/=>/, 'operators.twig'],
+              [/=/, 'operators.twig'],
+            ],
+            doctype: [
+              [/[^>]+/, 'metatag.content.html'],
+              [/>/, 'metatag.html', '@pop'],
+            ],
+            comment: [
+              [/-->/, 'comment.html', '@pop'],
+              [/[^-]+/, 'comment.content.html'],
+              [/./, 'comment.content.html'],
+            ],
+            otherTag: [
+              [/\/?>/, 'delimiter.html', '@pop'],
+              [/"([^"]*)"/, 'attribute.value.html'],
+              [/'([^']*)'/, 'attribute.value.html'],
+              [/[\w\-]+/, 'attribute.name.html'],
+              [/=/, 'delimiter.html'],
+              [/[ \t\r\n]+/],
+            ],
+            script: [
+              [/type/, 'attribute.name.html', '@scriptAfterType'],
+              [/"([^"]*)"/, 'attribute.value.html'],
+              [/'([^']*)'/, 'attribute.value.html'],
+              [/[\w\-]+/, 'attribute.name.html'],
+              [/=/, 'delimiter.html'],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@scriptEmbedded',
+                  nextEmbedded: 'text/javascript',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [
+                /(<\/)(script\s*)(>)/,
+                [
+                  'delimiter.html',
+                  'tag.html',
+                  { token: 'delimiter.html', next: '@pop' },
+                ],
+              ],
+            ],
+            scriptAfterType: [
+              [/=/, 'delimiter.html', '@scriptAfterTypeEquals'],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@scriptEmbedded',
+                  nextEmbedded: 'text/javascript',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            scriptAfterTypeEquals: [
+              [
+                /"([^"]*)"/,
+                {
+                  token: 'attribute.value.html',
+                  switchTo: '@scriptWithCustomType.$1',
+                },
+              ],
+              [
+                /'([^']*)'/,
+                {
+                  token: 'attribute.value.html',
+                  switchTo: '@scriptWithCustomType.$1',
+                },
+              ],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@scriptEmbedded',
+                  nextEmbedded: 'text/javascript',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            scriptWithCustomType: [
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@scriptEmbedded.$S2',
+                  nextEmbedded: '$S2',
+                },
+              ],
+              [/"([^"]*)"/, 'attribute.value.html'],
+              [/'([^']*)'/, 'attribute.value.html'],
+              [/[\w\-]+/, 'attribute.name.html'],
+              [/=/, 'delimiter.html'],
+              [/[ \t\r\n]+/],
+              [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            scriptEmbedded: [
+              [
+                /<\/script/,
+                { token: '@rematch', next: '@pop', nextEmbedded: '@pop' },
+              ],
+              [/[^<]+/, ''],
+            ],
+            style: [
+              [/type/, 'attribute.name.html', '@styleAfterType'],
+              [/"([^"]*)"/, 'attribute.value.html'],
+              [/'([^']*)'/, 'attribute.value.html'],
+              [/[\w\-]+/, 'attribute.name.html'],
+              [/=/, 'delimiter.html'],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@styleEmbedded',
+                  nextEmbedded: 'text/css',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [
+                /(<\/)(style\s*)(>)/,
+                [
+                  'delimiter.html',
+                  'tag.html',
+                  { token: 'delimiter.html', next: '@pop' },
+                ],
+              ],
+            ],
+            styleAfterType: [
+              [/=/, 'delimiter.html', '@styleAfterTypeEquals'],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@styleEmbedded',
+                  nextEmbedded: 'text/css',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            styleAfterTypeEquals: [
+              [
+                /"([^"]*)"/,
+                {
+                  token: 'attribute.value.html',
+                  switchTo: '@styleWithCustomType.$1',
+                },
+              ],
+              [
+                /'([^']*)'/,
+                {
+                  token: 'attribute.value.html',
+                  switchTo: '@styleWithCustomType.$1',
+                },
+              ],
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@styleEmbedded',
+                  nextEmbedded: 'text/css',
+                },
+              ],
+              [/[ \t\r\n]+/],
+              [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            styleWithCustomType: [
+              [
+                />/,
+                {
+                  token: 'delimiter.html',
+                  next: '@styleEmbedded.$S2',
+                  nextEmbedded: '$S2',
+                },
+              ],
+              [/"([^"]*)"/, 'attribute.value.html'],
+              [/'([^']*)'/, 'attribute.value.html'],
+              [/[\w\-]+/, 'attribute.name.html'],
+              [/=/, 'delimiter.html'],
+              [/[ \t\r\n]+/],
+              [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
+            ],
+            styleEmbedded: [
+              [
+                /<\/style/,
+                { token: '@rematch', next: '@pop', nextEmbedded: '@pop' },
+              ],
+              [/[^<]+/, ''],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/854.854.js

@@ -0,0 +1,195 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [854],
+  {
+    60854: (e, t, r) => {
+      'use strict';
+      r.r(t), r.d(t, { conf: () => s, language: () => n });
+      var s = {
+          wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#%\^\&\*\(\)\=\$\-\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+          comments: { blockComment: ['###', '###'], lineComment: '#' },
+          folding: {
+            markers: {
+              start: new RegExp('^\\s*#region\\b'),
+              end: new RegExp('^\\s*#endregion\\b'),
+            },
+          },
+        },
+        n = {
+          defaultToken: '',
+          ignoreCase: !1,
+          tokenPostfix: '.mips',
+          regEx: /\/(?!\/\/)(?:[^\/\\]|\\.)*\/[igm]*/,
+          keywords: [
+            '.data',
+            '.text',
+            'syscall',
+            'trap',
+            'add',
+            'addu',
+            'addi',
+            'addiu',
+            'and',
+            'andi',
+            'div',
+            'divu',
+            'mult',
+            'multu',
+            'nor',
+            'or',
+            'ori',
+            'sll',
+            'slv',
+            'sra',
+            'srav',
+            'srl',
+            'srlv',
+            'sub',
+            'subu',
+            'xor',
+            'xori',
+            'lhi',
+            'lho',
+            'lhi',
+            'llo',
+            'slt',
+            'slti',
+            'sltu',
+            'sltiu',
+            'beq',
+            'bgtz',
+            'blez',
+            'bne',
+            'j',
+            'jal',
+            'jalr',
+            'jr',
+            'lb',
+            'lbu',
+            'lh',
+            'lhu',
+            'lw',
+            'li',
+            'la',
+            'sb',
+            'sh',
+            'sw',
+            'mfhi',
+            'mflo',
+            'mthi',
+            'mtlo',
+            'move',
+          ],
+          symbols: /[\.,\:]+/,
+          escapes: /\\(?:[abfnrtv\\"'$]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+          tokenizer: {
+            root: [
+              [/\$[a-zA-Z_]\w*/, 'variable.predefined'],
+              [
+                /[.a-zA-Z_]\w*/,
+                {
+                  cases: {
+                    this: 'variable.predefined',
+                    '@keywords': { token: 'keyword.$0' },
+                    '@default': '',
+                  },
+                },
+              ],
+              [/[ \t\r\n]+/, ''],
+              [/#.*$/, 'comment'],
+              ['///', { token: 'regexp', next: '@hereregexp' }],
+              [/^(\s*)(@regEx)/, ['', 'regexp']],
+              [/(\,)(\s*)(@regEx)/, ['delimiter', '', 'regexp']],
+              [/(\:)(\s*)(@regEx)/, ['delimiter', '', 'regexp']],
+              [/@symbols/, 'delimiter'],
+              [/\d+[eE]([\-+]?\d+)?/, 'number.float'],
+              [/\d+\.\d+([eE][\-+]?\d+)?/, 'number.float'],
+              [/0[xX][0-9a-fA-F]+/, 'number.hex'],
+              [/0[0-7]+(?!\d)/, 'number.octal'],
+              [/\d+/, 'number'],
+              [/[,.]/, 'delimiter'],
+              [/"""/, 'string', '@herestring."""'],
+              [/'''/, 'string', "@herestring.'''"],
+              [
+                /"/,
+                {
+                  cases: {
+                    '@eos': 'string',
+                    '@default': { token: 'string', next: '@string."' },
+                  },
+                },
+              ],
+              [
+                /'/,
+                {
+                  cases: {
+                    '@eos': 'string',
+                    '@default': { token: 'string', next: "@string.'" },
+                  },
+                },
+              ],
+            ],
+            string: [
+              [/[^"'\#\\]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\./, 'string.escape.invalid'],
+              [/\./, 'string.escape.invalid'],
+              [
+                /#{/,
+                {
+                  cases: {
+                    '$S2=="': {
+                      token: 'string',
+                      next: 'root.interpolatedstring',
+                    },
+                    '@default': 'string',
+                  },
+                },
+              ],
+              [
+                /["']/,
+                {
+                  cases: {
+                    '$#==$S2': { token: 'string', next: '@pop' },
+                    '@default': 'string',
+                  },
+                },
+              ],
+              [/#/, 'string'],
+            ],
+            herestring: [
+              [
+                /("""|''')/,
+                {
+                  cases: {
+                    '$1==$S2': { token: 'string', next: '@pop' },
+                    '@default': 'string',
+                  },
+                },
+              ],
+              [/[^#\\'"]+/, 'string'],
+              [/['"]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\./, 'string.escape.invalid'],
+              [
+                /#{/,
+                { token: 'string.quote', next: 'root.interpolatedstring' },
+              ],
+              [/#/, 'string'],
+            ],
+            comment: [
+              [/[^#]+/, 'comment'],
+              [/#/, 'comment'],
+            ],
+            hereregexp: [
+              [/[^\\\/#]+/, 'regexp'],
+              [/\\./, 'regexp'],
+              [/#.*$/, 'comment'],
+              ['///[igm]*', { token: 'regexp', next: '@pop' }],
+              [/\//, 'regexp'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/8670.8670.js

@@ -0,0 +1,220 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [8670],
+  {
+    88670: (e, r, i) => {
+      'use strict';
+      i.r(r), i.d(r, { conf: () => o, language: () => t });
+      var o = {
+          comments: { lineComment: '#' },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+            { open: '`', close: '`' },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+            { open: '`', close: '`' },
+          ],
+        },
+        t = {
+          defaultToken: '',
+          ignoreCase: !0,
+          tokenPostfix: '.shell',
+          brackets: [
+            { token: 'delimiter.bracket', open: '{', close: '}' },
+            { token: 'delimiter.parenthesis', open: '(', close: ')' },
+            { token: 'delimiter.square', open: '[', close: ']' },
+          ],
+          keywords: [
+            'if',
+            'then',
+            'do',
+            'else',
+            'elif',
+            'while',
+            'until',
+            'for',
+            'in',
+            'esac',
+            'fi',
+            'fin',
+            'fil',
+            'done',
+            'exit',
+            'set',
+            'unset',
+            'export',
+            'function',
+          ],
+          builtins: [
+            'ab',
+            'awk',
+            'bash',
+            'beep',
+            'cat',
+            'cc',
+            'cd',
+            'chown',
+            'chmod',
+            'chroot',
+            'clear',
+            'cp',
+            'curl',
+            'cut',
+            'diff',
+            'echo',
+            'find',
+            'gawk',
+            'gcc',
+            'get',
+            'git',
+            'grep',
+            'hg',
+            'kill',
+            'killall',
+            'ln',
+            'ls',
+            'make',
+            'mkdir',
+            'openssl',
+            'mv',
+            'nc',
+            'node',
+            'npm',
+            'ping',
+            'ps',
+            'restart',
+            'rm',
+            'rmdir',
+            'sed',
+            'service',
+            'sh',
+            'shopt',
+            'shred',
+            'source',
+            'sort',
+            'sleep',
+            'ssh',
+            'start',
+            'stop',
+            'su',
+            'sudo',
+            'svn',
+            'tee',
+            'telnet',
+            'top',
+            'touch',
+            'vi',
+            'vim',
+            'wall',
+            'wc',
+            'wget',
+            'who',
+            'write',
+            'yes',
+            'zsh',
+          ],
+          symbols: /[=><!~?&|+\-*\/\^;\.,]+/,
+          tokenizer: {
+            root: [
+              { include: '@whitespace' },
+              [
+                /[a-zA-Z]\w*/,
+                {
+                  cases: {
+                    '@keywords': 'keyword',
+                    '@builtins': 'type.identifier',
+                    '@default': '',
+                  },
+                },
+              ],
+              { include: '@strings' },
+              { include: '@parameters' },
+              { include: '@heredoc' },
+              [/[{}\[\]()]/, '@brackets'],
+              [/-+\w+/, 'attribute.name'],
+              [/@symbols/, 'delimiter'],
+              { include: '@numbers' },
+              [/[,;]/, 'delimiter'],
+            ],
+            whitespace: [
+              [/\s+/, 'white'],
+              [/(^#!.*$)/, 'metatag'],
+              [/(^#.*$)/, 'comment'],
+            ],
+            numbers: [
+              [/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
+              [/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/, 'number.hex'],
+              [/\d+/, 'number'],
+            ],
+            strings: [
+              [/'/, 'string', '@stringBody'],
+              [/"/, 'string', '@dblStringBody'],
+            ],
+            stringBody: [
+              [/'/, 'string', '@popall'],
+              [/./, 'string'],
+            ],
+            dblStringBody: [
+              [/"/, 'string', '@popall'],
+              [/./, 'string'],
+            ],
+            heredoc: [
+              [
+                /(<<[-<]?)(\s*)(['"`]?)([\w\-]+)(['"`]?)/,
+                [
+                  'constants',
+                  'white',
+                  'string.heredoc.delimiter',
+                  'string.heredoc',
+                  'string.heredoc.delimiter',
+                ],
+              ],
+            ],
+            parameters: [
+              [/\$\d+/, 'variable.predefined'],
+              [/\$\w+/, 'variable'],
+              [/\$[*@#?\-$!0_]/, 'variable'],
+              [/\$'/, 'variable', '@parameterBodyQuote'],
+              [/\$"/, 'variable', '@parameterBodyDoubleQuote'],
+              [/\$\(/, 'variable', '@parameterBodyParen'],
+              [/\$\{/, 'variable', '@parameterBodyCurlyBrace'],
+            ],
+            parameterBodyQuote: [
+              [/[^#:%*@\-!_']+/, 'variable'],
+              [/[#:%*@\-!_]/, 'delimiter'],
+              [/[']/, 'variable', '@pop'],
+            ],
+            parameterBodyDoubleQuote: [
+              [/[^#:%*@\-!_"]+/, 'variable'],
+              [/[#:%*@\-!_]/, 'delimiter'],
+              [/["]/, 'variable', '@pop'],
+            ],
+            parameterBodyParen: [
+              [/[^#:%*@\-!_)]+/, 'variable'],
+              [/[#:%*@\-!_]/, 'delimiter'],
+              [/[)]/, 'variable', '@pop'],
+            ],
+            parameterBodyCurlyBrace: [
+              [/[^#:%*@\-!_}]+/, 'variable'],
+              [/[#:%*@\-!_]/, 'delimiter'],
+              [/[}]/, 'variable', '@pop'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/8715.8715.js

@@ -0,0 +1,331 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [8715],
+  {
+    8715: (e, t, o) => {
+      'use strict';
+      o.r(t), o.d(t, { conf: () => n, language: () => s });
+      var n = {
+          comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '[', close: ']' },
+            { open: '{', close: '}' },
+            { open: '(', close: ')' },
+            { open: "'", close: "'", notIn: ['string', 'comment'] },
+            { open: '"', close: '"', notIn: ['string'] },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          folding: {
+            markers: {
+              start: new RegExp('^\\s*#pragma\\s+region\\b'),
+              end: new RegExp('^\\s*#pragma\\s+endregion\\b'),
+            },
+          },
+        },
+        s = {
+          tokenPostfix: '.rust',
+          defaultToken: 'invalid',
+          keywords: [
+            'as',
+            'box',
+            'break',
+            'const',
+            'continue',
+            'crate',
+            'else',
+            'enum',
+            'extern',
+            'false',
+            'fn',
+            'for',
+            'if',
+            'impl',
+            'in',
+            'let',
+            'loop',
+            'match',
+            'mod',
+            'move',
+            'mut',
+            'pub',
+            'ref',
+            'return',
+            'self',
+            'static',
+            'struct',
+            'super',
+            'trait',
+            'true',
+            'type',
+            'unsafe',
+            'use',
+            'where',
+            'while',
+            'catch',
+            'default',
+            'union',
+            'static',
+            'abstract',
+            'alignof',
+            'become',
+            'do',
+            'final',
+            'macro',
+            'offsetof',
+            'override',
+            'priv',
+            'proc',
+            'pure',
+            'sizeof',
+            'typeof',
+            'unsized',
+            'virtual',
+            'yield',
+          ],
+          typeKeywords: [
+            'Self',
+            'm32',
+            'm64',
+            'm128',
+            'f80',
+            'f16',
+            'f128',
+            'int',
+            'uint',
+            'float',
+            'char',
+            'bool',
+            'u8',
+            'u16',
+            'u32',
+            'u64',
+            'f32',
+            'f64',
+            'i8',
+            'i16',
+            'i32',
+            'i64',
+            'str',
+            'Option',
+            'Either',
+            'c_float',
+            'c_double',
+            'c_void',
+            'FILE',
+            'fpos_t',
+            'DIR',
+            'dirent',
+            'c_char',
+            'c_schar',
+            'c_uchar',
+            'c_short',
+            'c_ushort',
+            'c_int',
+            'c_uint',
+            'c_long',
+            'c_ulong',
+            'size_t',
+            'ptrdiff_t',
+            'clock_t',
+            'time_t',
+            'c_longlong',
+            'c_ulonglong',
+            'intptr_t',
+            'uintptr_t',
+            'off_t',
+            'dev_t',
+            'ino_t',
+            'pid_t',
+            'mode_t',
+            'ssize_t',
+          ],
+          constants: [
+            'true',
+            'false',
+            'Some',
+            'None',
+            'Left',
+            'Right',
+            'Ok',
+            'Err',
+          ],
+          supportConstants: [
+            'EXIT_FAILURE',
+            'EXIT_SUCCESS',
+            'RAND_MAX',
+            'EOF',
+            'SEEK_SET',
+            'SEEK_CUR',
+            'SEEK_END',
+            '_IOFBF',
+            '_IONBF',
+            '_IOLBF',
+            'BUFSIZ',
+            'FOPEN_MAX',
+            'FILENAME_MAX',
+            'L_tmpnam',
+            'TMP_MAX',
+            'O_RDONLY',
+            'O_WRONLY',
+            'O_RDWR',
+            'O_APPEND',
+            'O_CREAT',
+            'O_EXCL',
+            'O_TRUNC',
+            'S_IFIFO',
+            'S_IFCHR',
+            'S_IFBLK',
+            'S_IFDIR',
+            'S_IFREG',
+            'S_IFMT',
+            'S_IEXEC',
+            'S_IWRITE',
+            'S_IREAD',
+            'S_IRWXU',
+            'S_IXUSR',
+            'S_IWUSR',
+            'S_IRUSR',
+            'F_OK',
+            'R_OK',
+            'W_OK',
+            'X_OK',
+            'STDIN_FILENO',
+            'STDOUT_FILENO',
+            'STDERR_FILENO',
+          ],
+          supportMacros: [
+            'format!',
+            'print!',
+            'println!',
+            'panic!',
+            'format_args!',
+            'unreachable!',
+            'write!',
+            'writeln!',
+          ],
+          operators: [
+            '!',
+            '!=',
+            '%',
+            '%=',
+            '&',
+            '&=',
+            '&&',
+            '*',
+            '*=',
+            '+',
+            '+=',
+            '-',
+            '-=',
+            '->',
+            '.',
+            '..',
+            '...',
+            '/',
+            '/=',
+            ':',
+            ';',
+            '<<',
+            '<<=',
+            '<',
+            '<=',
+            '=',
+            '==',
+            '=>',
+            '>',
+            '>=',
+            '>>',
+            '>>=',
+            '@',
+            '^',
+            '^=',
+            '|',
+            '|=',
+            '||',
+            '_',
+            '?',
+            '#',
+          ],
+          escapes: /\\([nrt0\"''\\]|x\h{2}|u\{\h{1,6}\})/,
+          delimiters: /[,]/,
+          symbols: /[\#\!\%\&\*\+\-\.\/\:\;\<\=\>\@\^\|_\?]+/,
+          intSuffixes: /[iu](8|16|32|64|128|size)/,
+          floatSuffixes: /f(32|64)/,
+          tokenizer: {
+            root: [
+              [
+                /[a-zA-Z][a-zA-Z0-9_]*!?|_[a-zA-Z0-9_]+/,
+                {
+                  cases: {
+                    '@typeKeywords': 'keyword.type',
+                    '@keywords': 'keyword',
+                    '@supportConstants': 'keyword',
+                    '@supportMacros': 'keyword',
+                    '@constants': 'keyword',
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+              [/\$/, 'identifier'],
+              [/'[a-zA-Z_][a-zA-Z0-9_]*(?=[^\'])/, 'identifier'],
+              [/'\S'/, 'string.byteliteral'],
+              [
+                /"/,
+                { token: 'string.quote', bracket: '@open', next: '@string' },
+              ],
+              { include: '@numbers' },
+              { include: '@whitespace' },
+              [
+                /@delimiters/,
+                { cases: { '@keywords': 'keyword', '@default': 'delimiter' } },
+              ],
+              [/[{}()\[\]<>]/, '@brackets'],
+              [
+                /@symbols/,
+                { cases: { '@operators': 'operator', '@default': '' } },
+              ],
+            ],
+            whitespace: [
+              [/[ \t\r\n]+/, 'white'],
+              [/\/\*/, 'comment', '@comment'],
+              [/\/\/.*$/, 'comment'],
+            ],
+            comment: [
+              [/[^\/*]+/, 'comment'],
+              [/\/\*/, 'comment', '@push'],
+              ['\\*/', 'comment', '@pop'],
+              [/[\/*]/, 'comment'],
+            ],
+            string: [
+              [/[^\\"]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/"/, { token: 'string.quote', bracket: '@close', next: '@pop' }],
+            ],
+            numbers: [
+              [/(0o[0-7_]+)(@intSuffixes)?/, { token: 'number' }],
+              [/(0b[0-1_]+)(@intSuffixes)?/, { token: 'number' }],
+              [
+                /[\d][\d_]*(\.[\d][\d_]*)?[eE][+-][\d_]+(@floatSuffixes)?/,
+                { token: 'number' },
+              ],
+              [/\b(\d\.?[\d_]*)(@floatSuffixes)?\b/, { token: 'number' }],
+              [/(0x[\da-fA-F]+)_?(@intSuffixes)?/, { token: 'number' }],
+              [/[\d][\d_]*(@intSuffixes?)?/, { token: 'number' }],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/8719.8719.js

@@ -0,0 +1,320 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [8719],
+  {
+    18719: (e, t, n) => {
+      'use strict';
+      n.r(t), n.d(t, { conf: () => s, language: () => o });
+      var s = {
+          wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\$\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+          comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: "'", close: "'", notIn: ['string', 'comment'] },
+            { open: '"', close: '"', notIn: ['string', 'comment'] },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '<', close: '>' },
+            { open: "'", close: "'" },
+            { open: '"', close: '"' },
+          ],
+          folding: {
+            markers: {
+              start: new RegExp('^\\s*#region\\b'),
+              end: new RegExp('^\\s*#endregion\\b'),
+            },
+          },
+        },
+        o = {
+          defaultToken: '',
+          tokenPostfix: '.cs',
+          brackets: [
+            { open: '{', close: '}', token: 'delimiter.curly' },
+            { open: '[', close: ']', token: 'delimiter.square' },
+            { open: '(', close: ')', token: 'delimiter.parenthesis' },
+            { open: '<', close: '>', token: 'delimiter.angle' },
+          ],
+          keywords: [
+            'extern',
+            'alias',
+            'using',
+            'bool',
+            'decimal',
+            'sbyte',
+            'byte',
+            'short',
+            'ushort',
+            'int',
+            'uint',
+            'long',
+            'ulong',
+            'char',
+            'float',
+            'double',
+            'object',
+            'dynamic',
+            'string',
+            'assembly',
+            'is',
+            'as',
+            'ref',
+            'out',
+            'this',
+            'base',
+            'new',
+            'typeof',
+            'void',
+            'checked',
+            'unchecked',
+            'default',
+            'delegate',
+            'var',
+            'const',
+            'if',
+            'else',
+            'switch',
+            'case',
+            'while',
+            'do',
+            'for',
+            'foreach',
+            'in',
+            'break',
+            'continue',
+            'goto',
+            'return',
+            'throw',
+            'try',
+            'catch',
+            'finally',
+            'lock',
+            'yield',
+            'from',
+            'let',
+            'where',
+            'join',
+            'on',
+            'equals',
+            'into',
+            'orderby',
+            'ascending',
+            'descending',
+            'select',
+            'group',
+            'by',
+            'namespace',
+            'partial',
+            'class',
+            'field',
+            'event',
+            'method',
+            'param',
+            'property',
+            'public',
+            'protected',
+            'internal',
+            'private',
+            'abstract',
+            'sealed',
+            'static',
+            'struct',
+            'readonly',
+            'volatile',
+            'virtual',
+            'override',
+            'params',
+            'get',
+            'set',
+            'add',
+            'remove',
+            'operator',
+            'true',
+            'false',
+            'implicit',
+            'explicit',
+            'interface',
+            'enum',
+            'null',
+            'async',
+            'await',
+            'fixed',
+            'sizeof',
+            'stackalloc',
+            'unsafe',
+            'nameof',
+            'when',
+          ],
+          namespaceFollows: ['namespace', 'using'],
+          parenFollows: [
+            'if',
+            'for',
+            'while',
+            'switch',
+            'foreach',
+            'using',
+            'catch',
+            'when',
+          ],
+          operators: [
+            '=',
+            '??',
+            '||',
+            '&&',
+            '|',
+            '^',
+            '&',
+            '==',
+            '!=',
+            '<=',
+            '>=',
+            '<<',
+            '+',
+            '-',
+            '*',
+            '/',
+            '%',
+            '!',
+            '~',
+            '++',
+            '--',
+            '+=',
+            '-=',
+            '*=',
+            '/=',
+            '%=',
+            '&=',
+            '|=',
+            '^=',
+            '<<=',
+            '>>=',
+            '>>',
+            '=>',
+          ],
+          symbols: /[=><!~?:&|+\-*\/\^%]+/,
+          escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+          tokenizer: {
+            root: [
+              [
+                /\@?[a-zA-Z_]\w*/,
+                {
+                  cases: {
+                    '@namespaceFollows': {
+                      token: 'keyword.$0',
+                      next: '@namespace',
+                    },
+                    '@keywords': { token: 'keyword.$0', next: '@qualified' },
+                    '@default': { token: 'identifier', next: '@qualified' },
+                  },
+                },
+              ],
+              { include: '@whitespace' },
+              [
+                /}/,
+                {
+                  cases: {
+                    '$S2==interpolatedstring': {
+                      token: 'string.quote',
+                      next: '@pop',
+                    },
+                    '$S2==litinterpstring': {
+                      token: 'string.quote',
+                      next: '@pop',
+                    },
+                    '@default': '@brackets',
+                  },
+                },
+              ],
+              [/[{}()\[\]]/, '@brackets'],
+              [/[<>](?!@symbols)/, '@brackets'],
+              [
+                /@symbols/,
+                { cases: { '@operators': 'delimiter', '@default': '' } },
+              ],
+              [/[0-9_]*\.[0-9_]+([eE][\-+]?\d+)?[fFdD]?/, 'number.float'],
+              [/0[xX][0-9a-fA-F_]+/, 'number.hex'],
+              [/0[bB][01_]+/, 'number.hex'],
+              [/[0-9_]+/, 'number'],
+              [/[;,.]/, 'delimiter'],
+              [/"([^"\\]|\\.)*$/, 'string.invalid'],
+              [/"/, { token: 'string.quote', next: '@string' }],
+              [/\$\@"/, { token: 'string.quote', next: '@litinterpstring' }],
+              [/\@"/, { token: 'string.quote', next: '@litstring' }],
+              [/\$"/, { token: 'string.quote', next: '@interpolatedstring' }],
+              [/'[^\\']'/, 'string'],
+              [/(')(@escapes)(')/, ['string', 'string.escape', 'string']],
+              [/'/, 'string.invalid'],
+            ],
+            qualified: [
+              [
+                /[a-zA-Z_][\w]*/,
+                {
+                  cases: {
+                    '@keywords': { token: 'keyword.$0' },
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+              [/\./, 'delimiter'],
+              ['', '', '@pop'],
+            ],
+            namespace: [
+              { include: '@whitespace' },
+              [/[A-Z]\w*/, 'namespace'],
+              [/[\.=]/, 'delimiter'],
+              ['', '', '@pop'],
+            ],
+            comment: [
+              [/[^\/*]+/, 'comment'],
+              ['\\*/', 'comment', '@pop'],
+              [/[\/*]/, 'comment'],
+            ],
+            string: [
+              [/[^\\"]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/"/, { token: 'string.quote', next: '@pop' }],
+            ],
+            litstring: [
+              [/[^"]+/, 'string'],
+              [/""/, 'string.escape'],
+              [/"/, { token: 'string.quote', next: '@pop' }],
+            ],
+            litinterpstring: [
+              [/[^"{]+/, 'string'],
+              [/""/, 'string.escape'],
+              [/{{/, 'string.escape'],
+              [/}}/, 'string.escape'],
+              [/{/, { token: 'string.quote', next: 'root.litinterpstring' }],
+              [/"/, { token: 'string.quote', next: '@pop' }],
+            ],
+            interpolatedstring: [
+              [/[^\\"{]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/{{/, 'string.escape'],
+              [/}}/, 'string.escape'],
+              [/{/, { token: 'string.quote', next: 'root.interpolatedstring' }],
+              [/"/, { token: 'string.quote', next: '@pop' }],
+            ],
+            whitespace: [
+              [/^[ \t\v\f]*#((r)|(load))(?=\s)/, 'directive.csx'],
+              [/^[ \t\v\f]*#\w.*$/, 'namespace.cpp'],
+              [/[ \t\v\f\r\n]+/, ''],
+              [/\/\*/, 'comment', '@comment'],
+              [/\/\/.*$/, 'comment'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/8946.8946.js

@@ -0,0 +1,54 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [8946],
+  {
+    68946: (t, e, r) => {
+      'use strict';
+      r.r(e), r.d(e, { conf: () => s, language: () => i });
+      var s = { brackets: [], autoClosingPairs: [], surroundingPairs: [] },
+        i = {
+          keywords: [],
+          typeKeywords: [],
+          tokenPostfix: '.csp',
+          operators: [],
+          symbols: /[=><!~?:&|+\-*\/\^%]+/,
+          escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+          tokenizer: {
+            root: [
+              [/child-src/, 'string.quote'],
+              [/connect-src/, 'string.quote'],
+              [/default-src/, 'string.quote'],
+              [/font-src/, 'string.quote'],
+              [/frame-src/, 'string.quote'],
+              [/img-src/, 'string.quote'],
+              [/manifest-src/, 'string.quote'],
+              [/media-src/, 'string.quote'],
+              [/object-src/, 'string.quote'],
+              [/script-src/, 'string.quote'],
+              [/style-src/, 'string.quote'],
+              [/worker-src/, 'string.quote'],
+              [/base-uri/, 'string.quote'],
+              [/plugin-types/, 'string.quote'],
+              [/sandbox/, 'string.quote'],
+              [/disown-opener/, 'string.quote'],
+              [/form-action/, 'string.quote'],
+              [/frame-ancestors/, 'string.quote'],
+              [/report-uri/, 'string.quote'],
+              [/report-to/, 'string.quote'],
+              [/upgrade-insecure-requests/, 'string.quote'],
+              [/block-all-mixed-content/, 'string.quote'],
+              [/require-sri-for/, 'string.quote'],
+              [/reflected-xss/, 'string.quote'],
+              [/referrer/, 'string.quote'],
+              [/policy-uri/, 'string.quote'],
+              [/'self'/, 'string.quote'],
+              [/'unsafe-inline'/, 'string.quote'],
+              [/'unsafe-eval'/, 'string.quote'],
+              [/'strict-dynamic'/, 'string.quote'],
+              [/'unsafe-hashed-attributes'/, 'string.quote'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/911.911.js

@@ -0,0 +1,156 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [911],
+  {
+    20911: (e, n, o) => {
+      'use strict';
+      o.r(n), o.d(n, { conf: () => t, language: () => s });
+      var t = {
+          comments: { lineComment: '--', blockComment: ['--[[', ']]'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+        },
+        s = {
+          defaultToken: '',
+          tokenPostfix: '.lua',
+          keywords: [
+            'and',
+            'break',
+            'do',
+            'else',
+            'elseif',
+            'end',
+            'false',
+            'for',
+            'function',
+            'goto',
+            'if',
+            'in',
+            'local',
+            'nil',
+            'not',
+            'or',
+            'repeat',
+            'return',
+            'then',
+            'true',
+            'until',
+            'while',
+          ],
+          brackets: [
+            { token: 'delimiter.bracket', open: '{', close: '}' },
+            { token: 'delimiter.array', open: '[', close: ']' },
+            { token: 'delimiter.parenthesis', open: '(', close: ')' },
+          ],
+          operators: [
+            '+',
+            '-',
+            '*',
+            '/',
+            '%',
+            '^',
+            '#',
+            '==',
+            '~=',
+            '<=',
+            '>=',
+            '<',
+            '>',
+            '=',
+            ';',
+            ':',
+            ',',
+            '.',
+            '..',
+            '...',
+          ],
+          symbols: /[=><!~?:&|+\-*\/\^%]+/,
+          escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+          tokenizer: {
+            root: [
+              [
+                /[a-zA-Z_]\w*/,
+                {
+                  cases: {
+                    '@keywords': { token: 'keyword.$0' },
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+              { include: '@whitespace' },
+              [
+                /(,)(\s*)([a-zA-Z_]\w*)(\s*)(:)(?!:)/,
+                ['delimiter', '', 'key', '', 'delimiter'],
+              ],
+              [
+                /({)(\s*)([a-zA-Z_]\w*)(\s*)(:)(?!:)/,
+                ['@brackets', '', 'key', '', 'delimiter'],
+              ],
+              [/[{}()\[\]]/, '@brackets'],
+              [
+                /@symbols/,
+                { cases: { '@operators': 'delimiter', '@default': '' } },
+              ],
+              [/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
+              [/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/, 'number.hex'],
+              [/\d+?/, 'number'],
+              [/[;,.]/, 'delimiter'],
+              [/"([^"\\]|\\.)*$/, 'string.invalid'],
+              [/'([^'\\]|\\.)*$/, 'string.invalid'],
+              [/"/, 'string', '@string."'],
+              [/'/, 'string', "@string.'"],
+            ],
+            whitespace: [
+              [/[ \t\r\n]+/, ''],
+              [/--\[([=]*)\[/, 'comment', '@comment.$1'],
+              [/--.*$/, 'comment'],
+            ],
+            comment: [
+              [/[^\]]+/, 'comment'],
+              [
+                /\]([=]*)\]/,
+                {
+                  cases: {
+                    '$1==$S2': { token: 'comment', next: '@pop' },
+                    '@default': 'comment',
+                  },
+                },
+              ],
+              [/./, 'comment'],
+            ],
+            string: [
+              [/[^\\"']+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [
+                /["']/,
+                {
+                  cases: {
+                    '$#==$S2': { token: 'string', next: '@pop' },
+                    '@default': 'string',
+                  },
+                },
+              ],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/9343.9343.js

@@ -0,0 +1,282 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [9343],
+  {
+    39343: (e, n, t) => {
+      'use strict';
+      t.r(n), t.d(n, { conf: () => o, language: () => r });
+      var o = {
+          comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: "'", close: "'", notIn: ['string', 'comment'] },
+            { open: '"', close: '"', notIn: ['string'] },
+            { open: '`', close: '`', notIn: ['string', 'comment'] },
+            { open: '/**', close: ' */', notIn: ['string'] },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '<', close: '>' },
+            { open: "'", close: "'" },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: '`', close: '`' },
+          ],
+          folding: {
+            markers: {
+              start: /^\s*\s*#?region\b/,
+              end: /^\s*\s*#?endregion\b/,
+            },
+          },
+        },
+        r = {
+          defaultToken: 'invalid',
+          tokenPostfix: '.dart',
+          keywords: [
+            'abstract',
+            'dynamic',
+            'implements',
+            'show',
+            'as',
+            'else',
+            'import',
+            'static',
+            'assert',
+            'enum',
+            'in',
+            'super',
+            'async',
+            'export',
+            'interface',
+            'switch',
+            'await',
+            'extends',
+            'is',
+            'sync',
+            'break',
+            'external',
+            'library',
+            'this',
+            'case',
+            'factory',
+            'mixin',
+            'throw',
+            'catch',
+            'false',
+            'new',
+            'true',
+            'class',
+            'final',
+            'null',
+            'try',
+            'const',
+            'finally',
+            'on',
+            'typedef',
+            'continue',
+            'for',
+            'operator',
+            'var',
+            'covariant',
+            'Function',
+            'part',
+            'void',
+            'default',
+            'get',
+            'rethrow',
+            'while',
+            'deferred',
+            'hide',
+            'return',
+            'with',
+            'do',
+            'if',
+            'set',
+            'yield',
+          ],
+          typeKeywords: ['int', 'double', 'String', 'bool'],
+          operators: [
+            '+',
+            '-',
+            '*',
+            '/',
+            '~/',
+            '%',
+            '++',
+            '--',
+            '==',
+            '!=',
+            '>',
+            '<',
+            '>=',
+            '<=',
+            '=',
+            '-=',
+            '/=',
+            '%=',
+            '>>=',
+            '^=',
+            '+=',
+            '*=',
+            '~/=',
+            '<<=',
+            '&=',
+            '!=',
+            '||',
+            '&&',
+            '&',
+            '|',
+            '^',
+            '~',
+            '<<',
+            '>>',
+            '!',
+            '>>>',
+            '??',
+            '?',
+            ':',
+            '|=',
+          ],
+          symbols: /[=><!~?:&|+\-*\/\^%]+/,
+          escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+          digits: /\d+(_+\d+)*/,
+          octaldigits: /[0-7]+(_+[0-7]+)*/,
+          binarydigits: /[0-1]+(_+[0-1]+)*/,
+          hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+          regexpctl: /[(){}\[\]\$\^|\-*+?\.]/,
+          regexpesc: /\\(?:[bBdDfnrstvwWn0\\\/]|@regexpctl|c[A-Z]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4})/,
+          tokenizer: {
+            root: [[/[{}]/, 'delimiter.bracket'], { include: 'common' }],
+            common: [
+              [
+                /[a-z_$][\w$]*/,
+                {
+                  cases: {
+                    '@typeKeywords': 'type.identifier',
+                    '@keywords': 'keyword',
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+              [
+                /(?<![a-zA-Z0-9_$])([_$]*[A-Z][a-zA-Z0-9_$]*)/,
+                'type.identifier',
+              ],
+              { include: '@whitespace' },
+              [
+                /\/(?=([^\\\/]|\\.)+\/([gimsuy]*)(\s*)(\.|;|,|\)|\]|\}|$))/,
+                { token: 'regexp', bracket: '@open', next: '@regexp' },
+              ],
+              [/@[a-zA-Z]+/, 'annotation'],
+              [/[()\[\]]/, '@brackets'],
+              [/[<>](?!@symbols)/, '@brackets'],
+              [/!(?=([^=]|$))/, 'delimiter'],
+              [
+                /@symbols/,
+                { cases: { '@operators': 'delimiter', '@default': '' } },
+              ],
+              [/(@digits)[eE]([\-+]?(@digits))?/, 'number.float'],
+              [/(@digits)\.(@digits)([eE][\-+]?(@digits))?/, 'number.float'],
+              [/0[xX](@hexdigits)n?/, 'number.hex'],
+              [/0[oO]?(@octaldigits)n?/, 'number.octal'],
+              [/0[bB](@binarydigits)n?/, 'number.binary'],
+              [/(@digits)n?/, 'number'],
+              [/[;,.]/, 'delimiter'],
+              [/"([^"\\]|\\.)*$/, 'string.invalid'],
+              [/'([^'\\]|\\.)*$/, 'string.invalid'],
+              [/"/, 'string', '@string_double'],
+              [/'/, 'string', '@string_single'],
+            ],
+            whitespace: [
+              [/[ \t\r\n]+/, ''],
+              [/\/\*\*(?!\/)/, 'comment.doc', '@jsdoc'],
+              [/\/\*/, 'comment', '@comment'],
+              [/\/\/\/.*$/, 'comment.doc'],
+              [/\/\/.*$/, 'comment'],
+            ],
+            comment: [
+              [/[^\/*]+/, 'comment'],
+              [/\*\//, 'comment', '@pop'],
+              [/[\/*]/, 'comment'],
+            ],
+            jsdoc: [
+              [/[^\/*]+/, 'comment.doc'],
+              [/\*\//, 'comment.doc', '@pop'],
+              [/[\/*]/, 'comment.doc'],
+            ],
+            regexp: [
+              [
+                /(\{)(\d+(?:,\d*)?)(\})/,
+                [
+                  'regexp.escape.control',
+                  'regexp.escape.control',
+                  'regexp.escape.control',
+                ],
+              ],
+              [
+                /(\[)(\^?)(?=(?:[^\]\\\/]|\\.)+)/,
+                [
+                  'regexp.escape.control',
+                  { token: 'regexp.escape.control', next: '@regexrange' },
+                ],
+              ],
+              [
+                /(\()(\?:|\?=|\?!)/,
+                ['regexp.escape.control', 'regexp.escape.control'],
+              ],
+              [/[()]/, 'regexp.escape.control'],
+              [/@regexpctl/, 'regexp.escape.control'],
+              [/[^\\\/]/, 'regexp'],
+              [/@regexpesc/, 'regexp.escape'],
+              [/\\\./, 'regexp.invalid'],
+              [
+                /(\/)([gimsuy]*)/,
+                [
+                  { token: 'regexp', bracket: '@close', next: '@pop' },
+                  'keyword.other',
+                ],
+              ],
+            ],
+            regexrange: [
+              [/-/, 'regexp.escape.control'],
+              [/\^/, 'regexp.invalid'],
+              [/@regexpesc/, 'regexp.escape'],
+              [/[^\]]/, 'regexp'],
+              [
+                /\]/,
+                {
+                  token: 'regexp.escape.control',
+                  next: '@pop',
+                  bracket: '@close',
+                },
+              ],
+            ],
+            string_double: [
+              [/[^\\"\$]+/, 'string'],
+              [/[^\\"]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/"/, 'string', '@pop'],
+              [/\$\w+/, 'identifier'],
+            ],
+            string_single: [
+              [/[^\\'\$]+/, 'string'],
+              [/@escapes/, 'string.escape'],
+              [/\\./, 'string.escape.invalid'],
+              [/'/, 'string', '@pop'],
+              [/\$\w+/, 'identifier'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/9398.9398.js

@@ -0,0 +1,378 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [9398],
+  {
+    79398: (E, T, A) => {
+      'use strict';
+      A.r(T), A.d(T, { conf: () => N, language: () => e });
+      var N = {
+          comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+          brackets: [
+            ['[', ']'],
+            ['(', ')'],
+            ['{', '}'],
+          ],
+          autoClosingPairs: [
+            { open: '"', close: '"', notIn: ['string', 'comment'] },
+            { open: "'", close: "'", notIn: ['string', 'comment'] },
+            { open: '[', close: ']', notIn: ['string', 'comment'] },
+            { open: '(', close: ')', notIn: ['string', 'comment'] },
+            { open: '{', close: '}', notIn: ['string', 'comment'] },
+          ],
+        },
+        e = {
+          defaultToken: '',
+          tokenPostfix: '.msdax',
+          ignoreCase: !0,
+          brackets: [
+            { open: '[', close: ']', token: 'delimiter.square' },
+            { open: '{', close: '}', token: 'delimiter.brackets' },
+            { open: '(', close: ')', token: 'delimiter.parenthesis' },
+          ],
+          keywords: [
+            'VAR',
+            'RETURN',
+            'NOT',
+            'EVALUATE',
+            'DATATABLE',
+            'ORDER',
+            'BY',
+            'START',
+            'AT',
+            'DEFINE',
+            'MEASURE',
+            'ASC',
+            'DESC',
+            'IN',
+            'BOOLEAN',
+            'DOUBLE',
+            'INTEGER',
+            'DATETIME',
+            'CURRENCY',
+            'STRING',
+          ],
+          functions: [
+            'CLOSINGBALANCEMONTH',
+            'CLOSINGBALANCEQUARTER',
+            'CLOSINGBALANCEYEAR',
+            'DATEADD',
+            'DATESBETWEEN',
+            'DATESINPERIOD',
+            'DATESMTD',
+            'DATESQTD',
+            'DATESYTD',
+            'ENDOFMONTH',
+            'ENDOFQUARTER',
+            'ENDOFYEAR',
+            'FIRSTDATE',
+            'FIRSTNONBLANK',
+            'LASTDATE',
+            'LASTNONBLANK',
+            'NEXTDAY',
+            'NEXTMONTH',
+            'NEXTQUARTER',
+            'NEXTYEAR',
+            'OPENINGBALANCEMONTH',
+            'OPENINGBALANCEQUARTER',
+            'OPENINGBALANCEYEAR',
+            'PARALLELPERIOD',
+            'PREVIOUSDAY',
+            'PREVIOUSMONTH',
+            'PREVIOUSQUARTER',
+            'PREVIOUSYEAR',
+            'SAMEPERIODLASTYEAR',
+            'STARTOFMONTH',
+            'STARTOFQUARTER',
+            'STARTOFYEAR',
+            'TOTALMTD',
+            'TOTALQTD',
+            'TOTALYTD',
+            'ADDCOLUMNS',
+            'ADDMISSINGITEMS',
+            'ALL',
+            'ALLEXCEPT',
+            'ALLNOBLANKROW',
+            'ALLSELECTED',
+            'CALCULATE',
+            'CALCULATETABLE',
+            'CALENDAR',
+            'CALENDARAUTO',
+            'CROSSFILTER',
+            'CROSSJOIN',
+            'CURRENTGROUP',
+            'DATATABLE',
+            'DETAILROWS',
+            'DISTINCT',
+            'EARLIER',
+            'EARLIEST',
+            'EXCEPT',
+            'FILTER',
+            'FILTERS',
+            'GENERATE',
+            'GENERATEALL',
+            'GROUPBY',
+            'IGNORE',
+            'INTERSECT',
+            'ISONORAFTER',
+            'KEEPFILTERS',
+            'LOOKUPVALUE',
+            'NATURALINNERJOIN',
+            'NATURALLEFTOUTERJOIN',
+            'RELATED',
+            'RELATEDTABLE',
+            'ROLLUP',
+            'ROLLUPADDISSUBTOTAL',
+            'ROLLUPGROUP',
+            'ROLLUPISSUBTOTAL',
+            'ROW',
+            'SAMPLE',
+            'SELECTCOLUMNS',
+            'SUBSTITUTEWITHINDEX',
+            'SUMMARIZE',
+            'SUMMARIZECOLUMNS',
+            'TOPN',
+            'TREATAS',
+            'UNION',
+            'USERELATIONSHIP',
+            'VALUES',
+            'SUM',
+            'SUMX',
+            'PATH',
+            'PATHCONTAINS',
+            'PATHITEM',
+            'PATHITEMREVERSE',
+            'PATHLENGTH',
+            'AVERAGE',
+            'AVERAGEA',
+            'AVERAGEX',
+            'COUNT',
+            'COUNTA',
+            'COUNTAX',
+            'COUNTBLANK',
+            'COUNTROWS',
+            'COUNTX',
+            'DISTINCTCOUNT',
+            'DIVIDE',
+            'GEOMEAN',
+            'GEOMEANX',
+            'MAX',
+            'MAXA',
+            'MAXX',
+            'MEDIAN',
+            'MEDIANX',
+            'MIN',
+            'MINA',
+            'MINX',
+            'PERCENTILE.EXC',
+            'PERCENTILE.INC',
+            'PERCENTILEX.EXC',
+            'PERCENTILEX.INC',
+            'PRODUCT',
+            'PRODUCTX',
+            'RANK.EQ',
+            'RANKX',
+            'STDEV.P',
+            'STDEV.S',
+            'STDEVX.P',
+            'STDEVX.S',
+            'VAR.P',
+            'VAR.S',
+            'VARX.P',
+            'VARX.S',
+            'XIRR',
+            'XNPV',
+            'DATE',
+            'DATEDIFF',
+            'DATEVALUE',
+            'DAY',
+            'EDATE',
+            'EOMONTH',
+            'HOUR',
+            'MINUTE',
+            'MONTH',
+            'NOW',
+            'SECOND',
+            'TIME',
+            'TIMEVALUE',
+            'TODAY',
+            'WEEKDAY',
+            'WEEKNUM',
+            'YEAR',
+            'YEARFRAC',
+            'CONTAINS',
+            'CONTAINSROW',
+            'CUSTOMDATA',
+            'ERROR',
+            'HASONEFILTER',
+            'HASONEVALUE',
+            'ISBLANK',
+            'ISCROSSFILTERED',
+            'ISEMPTY',
+            'ISERROR',
+            'ISEVEN',
+            'ISFILTERED',
+            'ISLOGICAL',
+            'ISNONTEXT',
+            'ISNUMBER',
+            'ISODD',
+            'ISSUBTOTAL',
+            'ISTEXT',
+            'USERNAME',
+            'USERPRINCIPALNAME',
+            'AND',
+            'FALSE',
+            'IF',
+            'IFERROR',
+            'NOT',
+            'OR',
+            'SWITCH',
+            'TRUE',
+            'ABS',
+            'ACOS',
+            'ACOSH',
+            'ACOT',
+            'ACOTH',
+            'ASIN',
+            'ASINH',
+            'ATAN',
+            'ATANH',
+            'BETA.DIST',
+            'BETA.INV',
+            'CEILING',
+            'CHISQ.DIST',
+            'CHISQ.DIST.RT',
+            'CHISQ.INV',
+            'CHISQ.INV.RT',
+            'COMBIN',
+            'COMBINA',
+            'CONFIDENCE.NORM',
+            'CONFIDENCE.T',
+            'COS',
+            'COSH',
+            'COT',
+            'COTH',
+            'CURRENCY',
+            'DEGREES',
+            'EVEN',
+            'EXP',
+            'EXPON.DIST',
+            'FACT',
+            'FLOOR',
+            'GCD',
+            'INT',
+            'ISO.CEILING',
+            'LCM',
+            'LN',
+            'LOG',
+            'LOG10',
+            'MOD',
+            'MROUND',
+            'ODD',
+            'PERMUT',
+            'PI',
+            'POISSON.DIST',
+            'POWER',
+            'QUOTIENT',
+            'RADIANS',
+            'RAND',
+            'RANDBETWEEN',
+            'ROUND',
+            'ROUNDDOWN',
+            'ROUNDUP',
+            'SIGN',
+            'SIN',
+            'SINH',
+            'SQRT',
+            'SQRTPI',
+            'TAN',
+            'TANH',
+            'TRUNC',
+            'BLANK',
+            'CONCATENATE',
+            'CONCATENATEX',
+            'EXACT',
+            'FIND',
+            'FIXED',
+            'FORMAT',
+            'LEFT',
+            'LEN',
+            'LOWER',
+            'MID',
+            'REPLACE',
+            'REPT',
+            'RIGHT',
+            'SEARCH',
+            'SUBSTITUTE',
+            'TRIM',
+            'UNICHAR',
+            'UNICODE',
+            'UPPER',
+            'VALUE',
+          ],
+          tokenizer: {
+            root: [
+              { include: '@comments' },
+              { include: '@whitespace' },
+              { include: '@numbers' },
+              { include: '@strings' },
+              { include: '@complexIdentifiers' },
+              [/[;,.]/, 'delimiter'],
+              [/[({})]/, '@brackets'],
+              [
+                /[a-z_][a-zA-Z0-9_]*/,
+                {
+                  cases: {
+                    '@keywords': 'keyword',
+                    '@functions': 'keyword',
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+              [/[<>=!%&+\-*/|~^]/, 'operator'],
+            ],
+            whitespace: [[/\s+/, 'white']],
+            comments: [
+              [/\/\/+.*/, 'comment'],
+              [/\/\*/, { token: 'comment.quote', next: '@comment' }],
+            ],
+            comment: [
+              [/[^*/]+/, 'comment'],
+              [/\*\//, { token: 'comment.quote', next: '@pop' }],
+              [/./, 'comment'],
+            ],
+            numbers: [
+              [/0[xX][0-9a-fA-F]*/, 'number'],
+              [/[$][+-]*\d*(\.\d*)?/, 'number'],
+              [/((\d+(\.\d*)?)|(\.\d+))([eE][\-+]?\d+)?/, 'number'],
+            ],
+            strings: [
+              [/N"/, { token: 'string', next: '@string' }],
+              [/"/, { token: 'string', next: '@string' }],
+            ],
+            string: [
+              [/[^"]+/, 'string'],
+              [/""/, 'string'],
+              [/"/, { token: 'string', next: '@pop' }],
+            ],
+            complexIdentifiers: [
+              [
+                /\[/,
+                { token: 'identifier.quote', next: '@bracketedIdentifier' },
+              ],
+              [/'/, { token: 'identifier.quote', next: '@quotedIdentifier' }],
+            ],
+            bracketedIdentifier: [
+              [/[^\]]+/, 'identifier'],
+              [/]]/, 'identifier'],
+              [/]/, { token: 'identifier.quote', next: '@pop' }],
+            ],
+            quotedIdentifier: [
+              [/[^']+/, 'identifier'],
+              [/''/, 'identifier'],
+              [/'/, { token: 'identifier.quote', next: '@pop' }],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/9537.9537.js

@@ -0,0 +1,176 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [9537],
+  {
+    79537: (e, n, o) => {
+      'use strict';
+      o.r(n), o.d(n, { conf: () => t, language: () => s });
+      var t = {
+          comments: { lineComment: '//', blockComment: ['/*', '*/'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+        },
+        s = {
+          defaultToken: '',
+          tokenPostfix: '.objective-c',
+          keywords: [
+            '#import',
+            '#include',
+            '#define',
+            '#else',
+            '#endif',
+            '#if',
+            '#ifdef',
+            '#ifndef',
+            '#ident',
+            '#undef',
+            '@class',
+            '@defs',
+            '@dynamic',
+            '@encode',
+            '@end',
+            '@implementation',
+            '@interface',
+            '@package',
+            '@private',
+            '@protected',
+            '@property',
+            '@protocol',
+            '@public',
+            '@selector',
+            '@synthesize',
+            '__declspec',
+            'assign',
+            'auto',
+            'BOOL',
+            'break',
+            'bycopy',
+            'byref',
+            'case',
+            'char',
+            'Class',
+            'const',
+            'copy',
+            'continue',
+            'default',
+            'do',
+            'double',
+            'else',
+            'enum',
+            'extern',
+            'FALSE',
+            'false',
+            'float',
+            'for',
+            'goto',
+            'if',
+            'in',
+            'int',
+            'id',
+            'inout',
+            'IMP',
+            'long',
+            'nil',
+            'nonatomic',
+            'NULL',
+            'oneway',
+            'out',
+            'private',
+            'public',
+            'protected',
+            'readwrite',
+            'readonly',
+            'register',
+            'return',
+            'SEL',
+            'self',
+            'short',
+            'signed',
+            'sizeof',
+            'static',
+            'struct',
+            'super',
+            'switch',
+            'typedef',
+            'TRUE',
+            'true',
+            'union',
+            'unsigned',
+            'volatile',
+            'void',
+            'while',
+          ],
+          decpart: /\d(_?\d)*/,
+          decimal: /0|@decpart/,
+          tokenizer: {
+            root: [
+              { include: '@comments' },
+              { include: '@whitespace' },
+              { include: '@numbers' },
+              { include: '@strings' },
+              [/[,:;]/, 'delimiter'],
+              [/[{}\[\]()<>]/, '@brackets'],
+              [
+                /[a-zA-Z@#]\w*/,
+                { cases: { '@keywords': 'keyword', '@default': 'identifier' } },
+              ],
+              [/[<>=\\+\\-\\*\\/\\^\\|\\~,]|and\\b|or\\b|not\\b]/, 'operator'],
+            ],
+            whitespace: [[/\s+/, 'white']],
+            comments: [
+              ['\\/\\*', 'comment', '@comment'],
+              ['\\/\\/+.*', 'comment'],
+            ],
+            comment: [
+              ['\\*\\/', 'comment', '@pop'],
+              ['.', 'comment'],
+            ],
+            numbers: [
+              [/0[xX][0-9a-fA-F]*(_?[0-9a-fA-F])*/, 'number.hex'],
+              [
+                /@decimal((\.@decpart)?([eE][\-+]?@decpart)?)[fF]*/,
+                { cases: { '(\\d)*': 'number', $0: 'number.float' } },
+              ],
+            ],
+            strings: [
+              [/'$/, 'string.escape', '@popall'],
+              [/'/, 'string.escape', '@stringBody'],
+              [/"$/, 'string.escape', '@popall'],
+              [/"/, 'string.escape', '@dblStringBody'],
+            ],
+            stringBody: [
+              [/[^\\']+$/, 'string', '@popall'],
+              [/[^\\']+/, 'string'],
+              [/\\./, 'string'],
+              [/'/, 'string.escape', '@popall'],
+              [/\\$/, 'string'],
+            ],
+            dblStringBody: [
+              [/[^\\"]+$/, 'string', '@popall'],
+              [/[^\\"]+/, 'string'],
+              [/\\./, 'string'],
+              [/"/, 'string.escape', '@popall'],
+              [/\\$/, 'string'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/9684.9684.js

@@ -0,0 +1,505 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [9684],
+  {
+    69684: (e, t, n) => {
+      'use strict';
+      n.r(t), n.d(t, { conf: () => r, language: () => s });
+      var r = {
+          comments: { lineComment: '#', blockComment: ['=begin', '=end'] },
+          brackets: [
+            ['(', ')'],
+            ['{', '}'],
+            ['[', ']'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+          ],
+          indentationRules: {
+            increaseIndentPattern: new RegExp(
+              '^\\s*((begin|class|(private|protected)\\s+def|def|else|elsif|ensure|for|if|module|rescue|unless|until|when|while|case)|([^#]*\\sdo\\b)|([^#]*=\\s*(case|if|unless)))\\b([^#\\{;]|("|\'|/).*\\4)*(#.*)?$'
+            ),
+            decreaseIndentPattern: new RegExp(
+              '^\\s*([}\\]]([,)]?\\s*(#|$)|\\.[a-zA-Z_]\\w*\\b)|(end|rescue|ensure|else|elsif|when)\\b)'
+            ),
+          },
+        },
+        s = {
+          tokenPostfix: '.ruby',
+          keywords: [
+            '__LINE__',
+            '__ENCODING__',
+            '__FILE__',
+            'BEGIN',
+            'END',
+            'alias',
+            'and',
+            'begin',
+            'break',
+            'case',
+            'class',
+            'def',
+            'defined?',
+            'do',
+            'else',
+            'elsif',
+            'end',
+            'ensure',
+            'for',
+            'false',
+            'if',
+            'in',
+            'module',
+            'next',
+            'nil',
+            'not',
+            'or',
+            'redo',
+            'rescue',
+            'retry',
+            'return',
+            'self',
+            'super',
+            'then',
+            'true',
+            'undef',
+            'unless',
+            'until',
+            'when',
+            'while',
+            'yield',
+          ],
+          keywordops: ['::', '..', '...', '?', ':', '=>'],
+          builtins: [
+            'require',
+            'public',
+            'private',
+            'include',
+            'extend',
+            'attr_reader',
+            'protected',
+            'private_class_method',
+            'protected_class_method',
+            'new',
+          ],
+          declarations: [
+            'module',
+            'class',
+            'def',
+            'case',
+            'do',
+            'begin',
+            'for',
+            'if',
+            'while',
+            'until',
+            'unless',
+          ],
+          linedecls: [
+            'def',
+            'case',
+            'do',
+            'begin',
+            'for',
+            'if',
+            'while',
+            'until',
+            'unless',
+          ],
+          operators: [
+            '^',
+            '&',
+            '|',
+            '<=>',
+            '==',
+            '===',
+            '!~',
+            '=~',
+            '>',
+            '>=',
+            '<',
+            '<=',
+            '<<',
+            '>>',
+            '+',
+            '-',
+            '*',
+            '/',
+            '%',
+            '**',
+            '~',
+            '+@',
+            '-@',
+            '[]',
+            '[]=',
+            '`',
+            '+=',
+            '-=',
+            '*=',
+            '**=',
+            '/=',
+            '^=',
+            '%=',
+            '<<=',
+            '>>=',
+            '&=',
+            '&&=',
+            '||=',
+            '|=',
+          ],
+          brackets: [
+            { open: '(', close: ')', token: 'delimiter.parenthesis' },
+            { open: '{', close: '}', token: 'delimiter.curly' },
+            { open: '[', close: ']', token: 'delimiter.square' },
+          ],
+          symbols: /[=><!~?:&|+\-*\/\^%\.]+/,
+          escape: /(?:[abefnrstv\\"'\n\r]|[0-7]{1,3}|x[0-9A-Fa-f]{1,2}|u[0-9A-Fa-f]{4})/,
+          escapes: /\\(?:C\-(@escape|.)|c(@escape|.)|@escape)/,
+          decpart: /\d(_?\d)*/,
+          decimal: /0|@decpart/,
+          delim: /[^a-zA-Z0-9\s\n\r]/,
+          heredelim: /(?:\w+|'[^']*'|"[^"]*"|`[^`]*`)/,
+          regexpctl: /[(){}\[\]\$\^|\-*+?\.]/,
+          regexpesc: /\\(?:[AzZbBdDfnrstvwWn0\\\/]|@regexpctl|c[A-Z]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4})?/,
+          tokenizer: {
+            root: [
+              [
+                /^(\s*)([a-z_]\w*[!?=]?)/,
+                [
+                  'white',
+                  {
+                    cases: {
+                      'for|until|while': {
+                        token: 'keyword.$2',
+                        next: '@dodecl.$2',
+                      },
+                      '@declarations': {
+                        token: 'keyword.$2',
+                        next: '@root.$2',
+                      },
+                      end: { token: 'keyword.$S2', next: '@pop' },
+                      '@keywords': 'keyword',
+                      '@builtins': 'predefined',
+                      '@default': 'identifier',
+                    },
+                  },
+                ],
+              ],
+              [
+                /[a-z_]\w*[!?=]?/,
+                {
+                  cases: {
+                    'if|unless|while|until': {
+                      token: 'keyword.$0x',
+                      next: '@modifier.$0x',
+                    },
+                    for: { token: 'keyword.$2', next: '@dodecl.$2' },
+                    '@linedecls': { token: 'keyword.$0', next: '@root.$0' },
+                    end: { token: 'keyword.$S2', next: '@pop' },
+                    '@keywords': 'keyword',
+                    '@builtins': 'predefined',
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+              [/[A-Z][\w]*[!?=]?/, 'constructor.identifier'],
+              [/\$[\w]*/, 'global.constant'],
+              [/@[\w]*/, 'namespace.instance.identifier'],
+              [/@@[\w]*/, 'namespace.class.identifier'],
+              [
+                /<<[-~](@heredelim).*/,
+                { token: 'string.heredoc.delimiter', next: '@heredoc.$1' },
+              ],
+              [
+                /[ \t\r\n]+<<(@heredelim).*/,
+                { token: 'string.heredoc.delimiter', next: '@heredoc.$1' },
+              ],
+              [
+                /^<<(@heredelim).*/,
+                { token: 'string.heredoc.delimiter', next: '@heredoc.$1' },
+              ],
+              { include: '@whitespace' },
+              [/"/, { token: 'string.d.delim', next: '@dstring.d."' }],
+              [/'/, { token: 'string.sq.delim', next: '@sstring.sq' }],
+              [/%([rsqxwW]|Q?)/, { token: '@rematch', next: 'pstring' }],
+              [/`/, { token: 'string.x.delim', next: '@dstring.x.`' }],
+              [/:(\w|[$@])\w*[!?=]?/, 'string.s'],
+              [/:"/, { token: 'string.s.delim', next: '@dstring.s."' }],
+              [/:'/, { token: 'string.s.delim', next: '@sstring.s' }],
+              [
+                /\/(?=(\\\/|[^\/\n])+\/)/,
+                { token: 'regexp.delim', next: '@regexp' },
+              ],
+              [/[{}()\[\]]/, '@brackets'],
+              [
+                /@symbols/,
+                {
+                  cases: {
+                    '@keywordops': 'keyword',
+                    '@operators': 'operator',
+                    '@default': '',
+                  },
+                },
+              ],
+              [/[;,]/, 'delimiter'],
+              [/0[xX][0-9a-fA-F](_?[0-9a-fA-F])*/, 'number.hex'],
+              [/0[_oO][0-7](_?[0-7])*/, 'number.octal'],
+              [/0[bB][01](_?[01])*/, 'number.binary'],
+              [/0[dD]@decpart/, 'number'],
+              [
+                /@decimal((\.@decpart)?([eE][\-+]?@decpart)?)/,
+                { cases: { $1: 'number.float', '@default': 'number' } },
+              ],
+            ],
+            dodecl: [
+              [/^/, { token: '', switchTo: '@root.$S2' }],
+              [
+                /[a-z_]\w*[!?=]?/,
+                {
+                  cases: {
+                    end: { token: 'keyword.$S2', next: '@pop' },
+                    do: { token: 'keyword', switchTo: '@root.$S2' },
+                    '@linedecls': { token: '@rematch', switchTo: '@root.$S2' },
+                    '@keywords': 'keyword',
+                    '@builtins': 'predefined',
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+              { include: '@root' },
+            ],
+            modifier: [
+              [/^/, '', '@pop'],
+              [
+                /[a-z_]\w*[!?=]?/,
+                {
+                  cases: {
+                    end: { token: 'keyword.$S2', next: '@pop' },
+                    'then|else|elsif|do': {
+                      token: 'keyword',
+                      switchTo: '@root.$S2',
+                    },
+                    '@linedecls': { token: '@rematch', switchTo: '@root.$S2' },
+                    '@keywords': 'keyword',
+                    '@builtins': 'predefined',
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+              { include: '@root' },
+            ],
+            sstring: [
+              [/[^\\']+/, 'string.$S2'],
+              [/\\\\|\\'|\\$/, 'string.$S2.escape'],
+              [/\\./, 'string.$S2.invalid'],
+              [/'/, { token: 'string.$S2.delim', next: '@pop' }],
+            ],
+            dstring: [
+              [/[^\\`"#]+/, 'string.$S2'],
+              [/#/, 'string.$S2.escape', '@interpolated'],
+              [/\\$/, 'string.$S2.escape'],
+              [/@escapes/, 'string.$S2.escape'],
+              [/\\./, 'string.$S2.escape.invalid'],
+              [
+                /[`"]/,
+                {
+                  cases: {
+                    '$#==$S3': { token: 'string.$S2.delim', next: '@pop' },
+                    '@default': 'string.$S2',
+                  },
+                },
+              ],
+            ],
+            heredoc: [
+              [
+                /^(\s*)(@heredelim)$/,
+                {
+                  cases: {
+                    '$2==$S2': [
+                      'string.heredoc',
+                      { token: 'string.heredoc.delimiter', next: '@pop' },
+                    ],
+                    '@default': ['string.heredoc', 'string.heredoc'],
+                  },
+                },
+              ],
+              [/.*/, 'string.heredoc'],
+            ],
+            interpolated: [
+              [/\$\w*/, 'global.constant', '@pop'],
+              [/@\w*/, 'namespace.class.identifier', '@pop'],
+              [/@@\w*/, 'namespace.instance.identifier', '@pop'],
+              [
+                /[{]/,
+                {
+                  token: 'string.escape.curly',
+                  switchTo: '@interpolated_compound',
+                },
+              ],
+              ['', '', '@pop'],
+            ],
+            interpolated_compound: [
+              [/[}]/, { token: 'string.escape.curly', next: '@pop' }],
+              { include: '@root' },
+            ],
+            pregexp: [
+              { include: '@whitespace' },
+              [
+                /[^\(\{\[\\]/,
+                {
+                  cases: {
+                    '$#==$S3': { token: 'regexp.delim', next: '@pop' },
+                    '$#==$S2': { token: 'regexp.delim', next: '@push' },
+                    '~[)}\\]]': '@brackets.regexp.escape.control',
+                    '~@regexpctl': 'regexp.escape.control',
+                    '@default': 'regexp',
+                  },
+                },
+              ],
+              { include: '@regexcontrol' },
+            ],
+            regexp: [
+              { include: '@regexcontrol' },
+              [/[^\\\/]/, 'regexp'],
+              ['/[ixmp]*', { token: 'regexp.delim' }, '@pop'],
+            ],
+            regexcontrol: [
+              [
+                /(\{)(\d+(?:,\d*)?)(\})/,
+                [
+                  '@brackets.regexp.escape.control',
+                  'regexp.escape.control',
+                  '@brackets.regexp.escape.control',
+                ],
+              ],
+              [
+                /(\[)(\^?)/,
+                [
+                  '@brackets.regexp.escape.control',
+                  { token: 'regexp.escape.control', next: '@regexrange' },
+                ],
+              ],
+              [
+                /(\()(\?[:=!])/,
+                ['@brackets.regexp.escape.control', 'regexp.escape.control'],
+              ],
+              [
+                /\(\?#/,
+                { token: 'regexp.escape.control', next: '@regexpcomment' },
+              ],
+              [/[()]/, '@brackets.regexp.escape.control'],
+              [/@regexpctl/, 'regexp.escape.control'],
+              [/\\$/, 'regexp.escape'],
+              [/@regexpesc/, 'regexp.escape'],
+              [/\\\./, 'regexp.invalid'],
+              [/#/, 'regexp.escape', '@interpolated'],
+            ],
+            regexrange: [
+              [/-/, 'regexp.escape.control'],
+              [/\^/, 'regexp.invalid'],
+              [/\\$/, 'regexp.escape'],
+              [/@regexpesc/, 'regexp.escape'],
+              [/[^\]]/, 'regexp'],
+              [/\]/, '@brackets.regexp.escape.control', '@pop'],
+            ],
+            regexpcomment: [
+              [/[^)]+/, 'comment'],
+              [/\)/, { token: 'regexp.escape.control', next: '@pop' }],
+            ],
+            pstring: [
+              [
+                /%([qws])\(/,
+                { token: 'string.$1.delim', switchTo: '@qstring.$1.(.)' },
+              ],
+              [
+                /%([qws])\[/,
+                { token: 'string.$1.delim', switchTo: '@qstring.$1.[.]' },
+              ],
+              [
+                /%([qws])\{/,
+                { token: 'string.$1.delim', switchTo: '@qstring.$1.{.}' },
+              ],
+              [
+                /%([qws])</,
+                { token: 'string.$1.delim', switchTo: '@qstring.$1.<.>' },
+              ],
+              [
+                /%([qws])(@delim)/,
+                { token: 'string.$1.delim', switchTo: '@qstring.$1.$2.$2' },
+              ],
+              [/%r\(/, { token: 'regexp.delim', switchTo: '@pregexp.(.)' }],
+              [/%r\[/, { token: 'regexp.delim', switchTo: '@pregexp.[.]' }],
+              [/%r\{/, { token: 'regexp.delim', switchTo: '@pregexp.{.}' }],
+              [/%r</, { token: 'regexp.delim', switchTo: '@pregexp.<.>' }],
+              [
+                /%r(@delim)/,
+                { token: 'regexp.delim', switchTo: '@pregexp.$1.$1' },
+              ],
+              [
+                /%(x|W|Q?)\(/,
+                { token: 'string.$1.delim', switchTo: '@qqstring.$1.(.)' },
+              ],
+              [
+                /%(x|W|Q?)\[/,
+                { token: 'string.$1.delim', switchTo: '@qqstring.$1.[.]' },
+              ],
+              [
+                /%(x|W|Q?)\{/,
+                { token: 'string.$1.delim', switchTo: '@qqstring.$1.{.}' },
+              ],
+              [
+                /%(x|W|Q?)</,
+                { token: 'string.$1.delim', switchTo: '@qqstring.$1.<.>' },
+              ],
+              [
+                /%(x|W|Q?)(@delim)/,
+                { token: 'string.$1.delim', switchTo: '@qqstring.$1.$2.$2' },
+              ],
+              [/%([rqwsxW]|Q?)./, { token: 'invalid', next: '@pop' }],
+              [/./, { token: 'invalid', next: '@pop' }],
+            ],
+            qstring: [
+              [/\\$/, 'string.$S2.escape'],
+              [/\\./, 'string.$S2.escape'],
+              [
+                /./,
+                {
+                  cases: {
+                    '$#==$S4': { token: 'string.$S2.delim', next: '@pop' },
+                    '$#==$S3': { token: 'string.$S2.delim', next: '@push' },
+                    '@default': 'string.$S2',
+                  },
+                },
+              ],
+            ],
+            qqstring: [
+              [/#/, 'string.$S2.escape', '@interpolated'],
+              { include: '@qstring' },
+            ],
+            whitespace: [
+              [/[ \t\r\n]+/, ''],
+              [/^\s*=begin\b/, 'comment', '@comment'],
+              [/#.*$/, 'comment'],
+            ],
+            comment: [
+              [/[^=]+/, 'comment'],
+              [/^\s*=begin\b/, 'comment.invalid'],
+              [/^\s*=end\b.*/, 'comment', '@pop'],
+              [/[=]/, 'comment'],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/9907.9907.js

@@ -0,0 +1,370 @@
+(self.webpackChunkmermaid_live_editor =
+  self.webpackChunkmermaid_live_editor || []).push([
+  [9907],
+  {
+    39907: (e, n, t) => {
+      'use strict';
+      t.r(n), t.d(n, { conf: () => o, language: () => r });
+      var o = {
+          comments: { lineComment: "'", blockComment: ['/*', '*/'] },
+          brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+            ['<', '>'],
+            ['addhandler', 'end addhandler'],
+            ['class', 'end class'],
+            ['enum', 'end enum'],
+            ['event', 'end event'],
+            ['function', 'end function'],
+            ['get', 'end get'],
+            ['if', 'end if'],
+            ['interface', 'end interface'],
+            ['module', 'end module'],
+            ['namespace', 'end namespace'],
+            ['operator', 'end operator'],
+            ['property', 'end property'],
+            ['raiseevent', 'end raiseevent'],
+            ['removehandler', 'end removehandler'],
+            ['select', 'end select'],
+            ['set', 'end set'],
+            ['structure', 'end structure'],
+            ['sub', 'end sub'],
+            ['synclock', 'end synclock'],
+            ['try', 'end try'],
+            ['while', 'end while'],
+            ['with', 'end with'],
+            ['using', 'end using'],
+            ['do', 'loop'],
+            ['for', 'next'],
+          ],
+          autoClosingPairs: [
+            { open: '{', close: '}', notIn: ['string', 'comment'] },
+            { open: '[', close: ']', notIn: ['string', 'comment'] },
+            { open: '(', close: ')', notIn: ['string', 'comment'] },
+            { open: '"', close: '"', notIn: ['string', 'comment'] },
+            { open: '<', close: '>', notIn: ['string', 'comment'] },
+          ],
+          folding: {
+            markers: {
+              start: new RegExp('^\\s*#Region\\b'),
+              end: new RegExp('^\\s*#End Region\\b'),
+            },
+          },
+        },
+        r = {
+          defaultToken: '',
+          tokenPostfix: '.vb',
+          ignoreCase: !0,
+          brackets: [
+            { token: 'delimiter.bracket', open: '{', close: '}' },
+            { token: 'delimiter.array', open: '[', close: ']' },
+            { token: 'delimiter.parenthesis', open: '(', close: ')' },
+            { token: 'delimiter.angle', open: '<', close: '>' },
+            {
+              token: 'keyword.tag-addhandler',
+              open: 'addhandler',
+              close: 'end addhandler',
+            },
+            { token: 'keyword.tag-class', open: 'class', close: 'end class' },
+            { token: 'keyword.tag-enum', open: 'enum', close: 'end enum' },
+            { token: 'keyword.tag-event', open: 'event', close: 'end event' },
+            {
+              token: 'keyword.tag-function',
+              open: 'function',
+              close: 'end function',
+            },
+            { token: 'keyword.tag-get', open: 'get', close: 'end get' },
+            { token: 'keyword.tag-if', open: 'if', close: 'end if' },
+            {
+              token: 'keyword.tag-interface',
+              open: 'interface',
+              close: 'end interface',
+            },
+            {
+              token: 'keyword.tag-module',
+              open: 'module',
+              close: 'end module',
+            },
+            {
+              token: 'keyword.tag-namespace',
+              open: 'namespace',
+              close: 'end namespace',
+            },
+            {
+              token: 'keyword.tag-operator',
+              open: 'operator',
+              close: 'end operator',
+            },
+            {
+              token: 'keyword.tag-property',
+              open: 'property',
+              close: 'end property',
+            },
+            {
+              token: 'keyword.tag-raiseevent',
+              open: 'raiseevent',
+              close: 'end raiseevent',
+            },
+            {
+              token: 'keyword.tag-removehandler',
+              open: 'removehandler',
+              close: 'end removehandler',
+            },
+            {
+              token: 'keyword.tag-select',
+              open: 'select',
+              close: 'end select',
+            },
+            { token: 'keyword.tag-set', open: 'set', close: 'end set' },
+            {
+              token: 'keyword.tag-structure',
+              open: 'structure',
+              close: 'end structure',
+            },
+            { token: 'keyword.tag-sub', open: 'sub', close: 'end sub' },
+            {
+              token: 'keyword.tag-synclock',
+              open: 'synclock',
+              close: 'end synclock',
+            },
+            { token: 'keyword.tag-try', open: 'try', close: 'end try' },
+            { token: 'keyword.tag-while', open: 'while', close: 'end while' },
+            { token: 'keyword.tag-with', open: 'with', close: 'end with' },
+            { token: 'keyword.tag-using', open: 'using', close: 'end using' },
+            { token: 'keyword.tag-do', open: 'do', close: 'loop' },
+            { token: 'keyword.tag-for', open: 'for', close: 'next' },
+          ],
+          keywords: [
+            'AddHandler',
+            'AddressOf',
+            'Alias',
+            'And',
+            'AndAlso',
+            'As',
+            'Async',
+            'Boolean',
+            'ByRef',
+            'Byte',
+            'ByVal',
+            'Call',
+            'Case',
+            'Catch',
+            'CBool',
+            'CByte',
+            'CChar',
+            'CDate',
+            'CDbl',
+            'CDec',
+            'Char',
+            'CInt',
+            'Class',
+            'CLng',
+            'CObj',
+            'Const',
+            'Continue',
+            'CSByte',
+            'CShort',
+            'CSng',
+            'CStr',
+            'CType',
+            'CUInt',
+            'CULng',
+            'CUShort',
+            'Date',
+            'Decimal',
+            'Declare',
+            'Default',
+            'Delegate',
+            'Dim',
+            'DirectCast',
+            'Do',
+            'Double',
+            'Each',
+            'Else',
+            'ElseIf',
+            'End',
+            'EndIf',
+            'Enum',
+            'Erase',
+            'Error',
+            'Event',
+            'Exit',
+            'False',
+            'Finally',
+            'For',
+            'Friend',
+            'Function',
+            'Get',
+            'GetType',
+            'GetXMLNamespace',
+            'Global',
+            'GoSub',
+            'GoTo',
+            'Handles',
+            'If',
+            'Implements',
+            'Imports',
+            'In',
+            'Inherits',
+            'Integer',
+            'Interface',
+            'Is',
+            'IsNot',
+            'Let',
+            'Lib',
+            'Like',
+            'Long',
+            'Loop',
+            'Me',
+            'Mod',
+            'Module',
+            'MustInherit',
+            'MustOverride',
+            'MyBase',
+            'MyClass',
+            'NameOf',
+            'Namespace',
+            'Narrowing',
+            'New',
+            'Next',
+            'Not',
+            'Nothing',
+            'NotInheritable',
+            'NotOverridable',
+            'Object',
+            'Of',
+            'On',
+            'Operator',
+            'Option',
+            'Optional',
+            'Or',
+            'OrElse',
+            'Out',
+            'Overloads',
+            'Overridable',
+            'Overrides',
+            'ParamArray',
+            'Partial',
+            'Private',
+            'Property',
+            'Protected',
+            'Public',
+            'RaiseEvent',
+            'ReadOnly',
+            'ReDim',
+            'RemoveHandler',
+            'Resume',
+            'Return',
+            'SByte',
+            'Select',
+            'Set',
+            'Shadows',
+            'Shared',
+            'Short',
+            'Single',
+            'Static',
+            'Step',
+            'Stop',
+            'String',
+            'Structure',
+            'Sub',
+            'SyncLock',
+            'Then',
+            'Throw',
+            'To',
+            'True',
+            'Try',
+            'TryCast',
+            'TypeOf',
+            'UInteger',
+            'ULong',
+            'UShort',
+            'Using',
+            'Variant',
+            'Wend',
+            'When',
+            'While',
+            'Widening',
+            'With',
+            'WithEvents',
+            'WriteOnly',
+            'Xor',
+          ],
+          tagwords: [
+            'If',
+            'Sub',
+            'Select',
+            'Try',
+            'Class',
+            'Enum',
+            'Function',
+            'Get',
+            'Interface',
+            'Module',
+            'Namespace',
+            'Operator',
+            'Set',
+            'Structure',
+            'Using',
+            'While',
+            'With',
+            'Do',
+            'Loop',
+            'For',
+            'Next',
+            'Property',
+            'Continue',
+            'AddHandler',
+            'RemoveHandler',
+            'Event',
+            'RaiseEvent',
+            'SyncLock',
+          ],
+          symbols: /[=><!~?;\.,:&|+\-*\/\^%]+/,
+          integersuffix: /U?[DI%L&S@]?/,
+          floatsuffix: /[R#F!]?/,
+          tokenizer: {
+            root: [
+              { include: '@whitespace' },
+              [/next(?!\w)/, { token: 'keyword.tag-for' }],
+              [/loop(?!\w)/, { token: 'keyword.tag-do' }],
+              [
+                /end\s+(?!for|do)(addhandler|class|enum|event|function|get|if|interface|module|namespace|operator|property|raiseevent|removehandler|select|set|structure|sub|synclock|try|while|with|using)/,
+                { token: 'keyword.tag-$1' },
+              ],
+              [
+                /[a-zA-Z_]\w*/,
+                {
+                  cases: {
+                    '@tagwords': { token: 'keyword.tag-$0' },
+                    '@keywords': { token: 'keyword.$0' },
+                    '@default': 'identifier',
+                  },
+                },
+              ],
+              [/^\s*#\w+/, 'keyword'],
+              [/\d*\d+e([\-+]?\d+)?(@floatsuffix)/, 'number.float'],
+              [/\d*\.\d+(e[\-+]?\d+)?(@floatsuffix)/, 'number.float'],
+              [/&H[0-9a-f]+(@integersuffix)/, 'number.hex'],
+              [/&0[0-7]+(@integersuffix)/, 'number.octal'],
+              [/\d+(@integersuffix)/, 'number'],
+              [/#.*#/, 'number'],
+              [/[{}()\[\]]/, '@brackets'],
+              [/@symbols/, 'delimiter'],
+              [/["\u201c\u201d]/, { token: 'string.quote', next: '@string' }],
+            ],
+            whitespace: [
+              [/[ \t\r\n]+/, ''],
+              [/(\'|REM(?!\w)).*$/, 'comment'],
+            ],
+            string: [
+              [/[^"\u201c\u201d]+/, 'string'],
+              [/["\u201c\u201d]{2}/, 'string.escape'],
+              [/["\u201c\u201d]C?/, { token: 'string.quote', next: '@pop' }],
+            ],
+          },
+        };
+    },
+  },
+]);

docs/bundle.js.LICENSE.txt

@@ -0,0 +1,803 @@
+/*
+ *          __        ___
+ *    _____/ /___  __/ (_)____
+ *   / ___/ __/ / / / / / ___/
+ *  (__  ) /_/ /_/ / / (__  )
+ * /____/\__/\__, /_/_/____/
+ *          /____/
+ *
+ * light - weight css preprocessor @licence MIT
+ */
+
+/*!
+   * Wait for document loaded before starting the execution
+   */
+
+/*! ../../config */
+
+/*! ../../dagre-wrapper/index.js */
+
+/*! ../../logger */
+
+/*! ../../mermaidAPI */
+
+/*! ../../utils */
+
+/*! ../common/common */
+
+/*! ../config */
+
+/*! ../createLabel */
+
+/*! ../diagrams/class/svgDraw */
+
+/*! ../intersect/index.js */
+
+/*! ../logger */
+
+/*! ../package.json */
+
+/*! ../utils */
+
+/*! ./../../../../node_modules/process/browser.js */
+
+/*! ./../../../../node_modules/webpack/buildin/module.js */
+
+/*! ./../process/browser.js */
+
+/*! ./classDb */
+
+/*! ./clusters */
+
+/*! ./config */
+
+/*! ./createLabel */
+
+/*! ./defaultConfig */
+
+/*! ./diagrams/class/classDb */
+
+/*! ./diagrams/class/classRenderer */
+
+/*! ./diagrams/class/classRenderer-v2 */
+
+/*! ./diagrams/class/parser/classDiagram */
+
+/*! ./diagrams/class/styles */
+
+/*! ./diagrams/common/common */
+
+/*! ./diagrams/er/erDb */
+
+/*! ./diagrams/er/erRenderer */
+
+/*! ./diagrams/er/parser/erDiagram */
+
+/*! ./diagrams/er/styles */
+
+/*! ./diagrams/flowchart/flowDb */
+
+/*! ./diagrams/flowchart/flowRenderer */
+
+/*! ./diagrams/flowchart/flowRenderer-v2 */
+
+/*! ./diagrams/flowchart/parser/flow */
+
+/*! ./diagrams/flowchart/styles */
+
+/*! ./diagrams/gantt/ganttDb */
+
+/*! ./diagrams/gantt/ganttRenderer */
+
+/*! ./diagrams/gantt/parser/gantt */
+
+/*! ./diagrams/gantt/styles */
+
+/*! ./diagrams/git/gitGraphAst */
+
+/*! ./diagrams/git/gitGraphRenderer */
+
+/*! ./diagrams/git/parser/gitGraph */
+
+/*! ./diagrams/git/styles */
+
+/*! ./diagrams/info/infoDb */
+
+/*! ./diagrams/info/infoRenderer */
+
+/*! ./diagrams/info/parser/info */
+
+/*! ./diagrams/info/styles */
+
+/*! ./diagrams/pie/parser/pie */
+
+/*! ./diagrams/pie/pieDb */
+
+/*! ./diagrams/pie/pieRenderer */
+
+/*! ./diagrams/pie/styles */
+
+/*! ./diagrams/requirement/parser/requirementDiagram */
+
+/*! ./diagrams/requirement/requirementDb */
+
+/*! ./diagrams/requirement/requirementRenderer */
+
+/*! ./diagrams/requirement/styles */
+
+/*! ./diagrams/sequence/parser/sequenceDiagram */
+
+/*! ./diagrams/sequence/sequenceDb */
+
+/*! ./diagrams/sequence/sequenceRenderer */
+
+/*! ./diagrams/sequence/styles */
+
+/*! ./diagrams/state/parser/stateDiagram */
+
+/*! ./diagrams/state/stateDb */
+
+/*! ./diagrams/state/stateRenderer */
+
+/*! ./diagrams/state/stateRenderer-v2 */
+
+/*! ./diagrams/state/styles */
+
+/*! ./diagrams/user-journey/journeyDb */
+
+/*! ./diagrams/user-journey/journeyRenderer */
+
+/*! ./diagrams/user-journey/parser/journey */
+
+/*! ./diagrams/user-journey/styles */
+
+/*! ./edges */
+
+/*! ./erDb */
+
+/*! ./erMarkers */
+
+/*! ./errorRenderer */
+
+/*! ./flowChartShapes */
+
+/*! ./flowDb */
+
+/*! ./ganttDb */
+
+/*! ./gitGraphAst */
+
+/*! ./id-cache.js */
+
+/*! ./infoDb */
+
+/*! ./intersect-circle.js */
+
+/*! ./intersect-ellipse */
+
+/*! ./intersect-ellipse.js */
+
+/*! ./intersect-line */
+
+/*! ./intersect-node.js */
+
+/*! ./intersect-polygon.js */
+
+/*! ./intersect-rect.js */
+
+/*! ./intersect/index.js */
+
+/*! ./intersect/intersect-rect */
+
+/*! ./journeyDb */
+
+/*! ./logger */
+
+/*! ./markers */
+
+/*! ./mermaid-graphlib */
+
+/*! ./mermaidAPI */
+
+/*! ./nodes */
+
+/*! ./parser/classDiagram */
+
+/*! ./parser/erDiagram */
+
+/*! ./parser/flow */
+
+/*! ./parser/gantt */
+
+/*! ./parser/gitGraph */
+
+/*! ./parser/info */
+
+/*! ./parser/journey */
+
+/*! ./parser/pie */
+
+/*! ./parser/requirementDiagram */
+
+/*! ./parser/sequenceDiagram */
+
+/*! ./parser/stateDiagram */
+
+/*! ./pieDb */
+
+/*! ./requirementDb */
+
+/*! ./requirementMarkers */
+
+/*! ./sequenceDb */
+
+/*! ./shapes */
+
+/*! ./shapes/note */
+
+/*! ./shapes/util */
+
+/*! ./stateDb */
+
+/*! ./styles */
+
+/*! ./svgDraw */
+
+/*! ./theme-base */
+
+/*! ./theme-dark */
+
+/*! ./theme-default */
+
+/*! ./theme-forest */
+
+/*! ./theme-helpers */
+
+/*! ./theme-neutral */
+
+/*! ./themes */
+
+/*! ./util */
+
+/*! ./utils */
+
+/*! @braintree/sanitize-url */
+
+/*! Check if previously processed */
+
+/*! d3 */
+
+/*! dagre */
+
+/*! dagre-d3 */
+
+/*! dagre-d3/lib/label/add-html-label.js */
+
+/*! entity-decode/browser */
+
+/*! exports provided: LEVELS, log, setLogLevel */
+
+/*! exports provided: addClasses, addRelations, setConf, drawOld, draw, default */
+
+/*! exports provided: addToRender, addToRenderV2, default */
+
+/*! exports provided: bounds, drawActors, setConf, draw, default */
+
+/*! exports provided: calcThemeVariables, default */
+
+/*! exports provided: clear, insertEdgeLabel, positionEdgeLabel, intersection, insertEdge */
+
+/*! exports provided: clusterDb, clear, extractDecendants, validate, findNonClusterChild, adjustClustersAndEdges, extractor, sortNodesByHierarchy */
+
+/*! exports provided: default */
+
+/*! exports provided: defaultConfig, updateCurrentConfig, setSiteConfig, saveConfigFromInitilize, updateSiteConfig, getSiteConfig, setConfig, getConfig, sanitize, addDirective, reset */
+
+/*! exports provided: detectInit, detectDirective, detectType, isSubstringInArray, interpolateToCurve, formatUrl, runFunc, getStylesFromArray, generateId, random, assignWithDepth, getTextObj, drawSimpleText, wrapLabel, calculateTextHeight, calculateTextWidth, calculateTextDimensions, calculateSvgSizeAttrs, configureSvgSize, initIdGeneratior, default */
+
+/*! exports provided: drawEdge, drawClass, parseMember, default */
+
+/*! exports provided: drawRect, drawFace, drawCircle, drawText, drawLabel, drawSection, drawTask, drawBackgroundRect, getTextObj, getNoteRect, default */
+
+/*! exports provided: drawRect, drawText, drawLabel, drawActor, anchorElement, drawActivation, drawLoop, drawBackgroundRect, insertArrowHead, insertArrowFilledHead, insertSequenceNumber, insertArrowCrossHead, getTextObj, getNoteRect, default */
+
+/*! exports provided: drawStartState, drawDivider, drawSimpleState, drawDescrState, addTitleAndBox, drawText, drawNote, drawState, drawEdge */
+
+/*! exports provided: encodeEntities, decodeEntities, default */
+
+/*! exports provided: getRows, removeScript, sanitizeText, lineBreakRegex, hasBreaks, splitBreaks, default */
+
+/*! exports provided: getThemeVariables */
+
+/*! exports provided: insertCluster, getClusterTitleWidth, clear, positionCluster */
+
+/*! exports provided: insertNode, setNodeElem, clear, positionNode */
+
+/*! exports provided: labelHelper, updateNodeBounds, insertPolygonShape */
+
+/*! exports provided: mkBorder */
+
+/*! exports provided: name, version, description, main, keywords, scripts, repository, author, license, standard, dependencies, devDependencies, files, yarn-upgrade-all, sideEffects, husky, default */
+
+/*! exports provided: parseDirective, addActor, addMessage, addSignal, getMessages, getActors, getActor, getActorKeys, getTitle, getTitleWrapped, enableSequenceNumbers, showSequenceNumbers, setWrap, autoWrap, clear, parseMessage, LINETYPE, ARROWTYPE, PLACEMENT, addNote, setTitle, apply, default */
+
+/*! exports provided: parseDirective, addClass, lookUpDomId, clear, getClass, getClasses, getRelations, addRelation, addAnnotation, addMember, addMembers, cleanupLabel, setCssClass, setLink, setClickEvent, bindFunctions, lineType, relationType, default */
+
+/*! exports provided: parseDirective, addState, clear, getState, getStates, logDocuments, getRelations, addRelation, cleanupLabel, lineType, relationType, default */
+
+/*! exports provided: parseDirective, clear, setAxisFormat, getAxisFormat, setTodayMarker, getTodayMarker, setDateFormat, enableInclusiveEndDates, endDatesAreInclusive, enableTopAxis, topAxisEnabled, getDateFormat, setExcludes, getExcludes, setTitle, getTitle, addSection, getSections, getTasks, addTask, findTaskById, addTaskOrg, setLink, setClass, setClickEvent, bindFunctions, default */
+
+/*! exports provided: parseDirective, clear, setTitle, getTitle, addSection, getSections, getTasks, addTask, addTaskOrg, default */
+
+/*! exports provided: parseDirective, default */
+
+/*! exports provided: parseDirective, lookUpDomId, addVertex, addSingleLink, addLink, updateLinkInterpolate, updateLink, addClass, setDirection, setClass, setLink, getTooltip, setClickEvent, bindFunctions, getDirection, getVertices, getEdges, getClasses, clear, setGen, defaultStyle, addSubGraph, getDepthFirstPos, indexNodes, getSubGraphs, firstGraph, default */
+
+/*! exports provided: render */
+
+/*! exports provided: set, get, keys, size, default */
+
+/*! exports provided: setConf, addVertices, addEdges, getClasses, draw, default */
+
+/*! exports provided: setConf, draw, bounds, drawTasks, default */
+
+/*! exports provided: setConf, draw, default */
+
+/*! exports provided: setConf, drawReqs, drawElements, draw, default */
+
+/*! exports provided: setConf, getClasses, draw, default */
+
+/*! exports provided: setDirection, setOptions, getOptions, commit, branch, merge, checkout, reset, prettyPrint, clear, getBranchesAsObjArray, getBranches, getCommits, getCommitsArray, getCurrentBranch, getDirection, getHead, default */
+
+/*! exports provided: setMessage, getMessage, setInfo, getInfo, default */
+
+/*! fs */
+
+/*! graphlib */
+
+/*! khroma */
+
+/*! moment-mini */
+
+/*! no static exports found */
+
+/*! path */
+
+/*! sequence config was passed as #1 */
+
+/*! stylis */
+
+/*!*********************!*\
+  !*** external "d3" ***!
+  \*********************/
+
+/*!**********************!*\
+  !*** ./package.json ***!
+  \**********************/
+
+/*!**********************!*\
+  !*** ./src/utils.js ***!
+  \**********************/
+
+/*!***********************!*\
+  !*** ./src/config.js ***!
+  \***********************/
+
+/*!***********************!*\
+  !*** ./src/logger.js ***!
+  \***********************/
+
+/*!***********************!*\
+  !*** ./src/styles.js ***!
+  \***********************/
+
+/*!************************!*\
+  !*** ./src/mermaid.js ***!
+  \************************/
+
+/*!************************!*\
+  !*** external "dagre" ***!
+  \************************/
+
+/*!*************************!*\
+  !*** external "khroma" ***!
+  \*************************/
+
+/*!*************************!*\
+  !*** external "stylis" ***!
+  \*************************/
+
+/*!***************************!*\
+  !*** ./src/mermaidAPI.js ***!
+  \***************************/
+
+/*!***************************!*\
+  !*** external "dagre-d3" ***!
+  \***************************/
+
+/*!***************************!*\
+  !*** external "graphlib" ***!
+  \***************************/
+
+/*!*****************************!*\
+  !*** ./src/themes/index.js ***!
+  \*****************************/
+
+/*!******************************!*\
+  !*** ./src/defaultConfig.js ***!
+  \******************************/
+
+/*!******************************!*\
+  !*** ./src/errorRenderer.js ***!
+  \******************************/
+
+/*!******************************!*\
+  !*** external "moment-mini" ***!
+  \******************************/
+
+/*!*********************************!*\
+  !*** ./src/diagrams/er/erDb.js ***!
+  \*********************************/
+
+/*!**********************************!*\
+  !*** ./src/themes/theme-base.js ***!
+  \**********************************/
+
+/*!**********************************!*\
+  !*** ./src/themes/theme-dark.js ***!
+  \**********************************/
+
+/*!***********************************!*\
+  !*** (webpack)/buildin/module.js ***!
+  \***********************************/
+
+/*!***********************************!*\
+  !*** ./src/diagrams/er/styles.js ***!
+  \***********************************/
+
+/*!***********************************!*\
+  !*** ./src/diagrams/pie/pieDb.js ***!
+  \***********************************/
+
+/*!************************************!*\
+  !*** ./src/dagre-wrapper/edges.js ***!
+  \************************************/
+
+/*!************************************!*\
+  !*** ./src/dagre-wrapper/index.js ***!
+  \************************************/
+
+/*!************************************!*\
+  !*** ./src/dagre-wrapper/nodes.js ***!
+  \************************************/
+
+/*!************************************!*\
+  !*** ./src/diagrams/git/styles.js ***!
+  \************************************/
+
+/*!************************************!*\
+  !*** ./src/diagrams/pie/styles.js ***!
+  \************************************/
+
+/*!************************************!*\
+  !*** ./src/themes/theme-forest.js ***!
+  \************************************/
+
+/*!*************************************!*\
+  !*** ./src/diagrams/info/infoDb.js ***!
+  \*************************************/
+
+/*!*************************************!*\
+  !*** ./src/diagrams/info/styles.js ***!
+  \*************************************/
+
+/*!*************************************!*\
+  !*** ./src/themes/theme-default.js ***!
+  \*************************************/
+
+/*!*************************************!*\
+  !*** ./src/themes/theme-helpers.js ***!
+  \*************************************/
+
+/*!*************************************!*\
+  !*** ./src/themes/theme-neutral.js ***!
+  \*************************************/
+
+/*!**************************************!*\
+  !*** ./src/dagre-wrapper/markers.js ***!
+  \**************************************/
+
+/*!**************************************!*\
+  !*** ./src/diagrams/class/styles.js ***!
+  \**************************************/
+
+/*!**************************************!*\
+  !*** ./src/diagrams/er/erMarkers.js ***!
+  \**************************************/
+
+/*!**************************************!*\
+  !*** ./src/diagrams/gantt/styles.js ***!
+  \**************************************/
+
+/*!**************************************!*\
+  !*** ./src/diagrams/state/shapes.js ***!
+  \**************************************/
+
+/*!**************************************!*\
+  !*** ./src/diagrams/state/styles.js ***!
+  \**************************************/
+
+/*!***************************************!*\
+  !*** ./src/dagre-wrapper/clusters.js ***!
+  \***************************************/
+
+/*!***************************************!*\
+  !*** ./src/diagrams/class/classDb.js ***!
+  \***************************************/
+
+/*!***************************************!*\
+  !*** ./src/diagrams/class/svgDraw.js ***!
+  \***************************************/
+
+/*!***************************************!*\
+  !*** ./src/diagrams/common/common.js ***!
+  \***************************************/
+
+/*!***************************************!*\
+  !*** ./src/diagrams/er/erRenderer.js ***!
+  \***************************************/
+
+/*!***************************************!*\
+  !*** ./src/diagrams/gantt/ganttDb.js ***!
+  \***************************************/
+
+/*!***************************************!*\
+  !*** ./src/diagrams/state/stateDb.js ***!
+  \***************************************/
+
+/*!****************************************!*\
+  !*** ./src/diagrams/state/id-cache.js ***!
+  \****************************************/
+
+/*!****************************************!*\
+  !*** external "entity-decode/browser" ***!
+  \****************************************/
+
+/*!*****************************************!*\
+  !*** ./node_modules/process/browser.js ***!
+  \*****************************************/
+
+/*!*****************************************!*\
+  !*** ./src/diagrams/git/gitGraphAst.js ***!
+  \*****************************************/
+
+/*!*****************************************!*\
+  !*** ./src/diagrams/pie/pieRenderer.js ***!
+  \*****************************************/
+
+/*!*****************************************!*\
+  !*** ./src/diagrams/sequence/styles.js ***!
+  \*****************************************/
+
+/*!******************************************!*\
+  !*** ./src/dagre-wrapper/createLabel.js ***!
+  \******************************************/
+
+/*!******************************************!*\
+  !*** ./src/dagre-wrapper/shapes/note.js ***!
+  \******************************************/
+
+/*!******************************************!*\
+  !*** ./src/dagre-wrapper/shapes/util.js ***!
+  \******************************************/
+
+/*!******************************************!*\
+  !*** ./src/diagrams/flowchart/flowDb.js ***!
+  \******************************************/
+
+/*!******************************************!*\
+  !*** ./src/diagrams/flowchart/styles.js ***!
+  \******************************************/
+
+/*!******************************************!*\
+  !*** ./src/diagrams/sequence/svgDraw.js ***!
+  \******************************************/
+
+/*!******************************************!*\
+  !*** external "@braintree/sanitize-url" ***!
+  \******************************************/
+
+/*!*******************************************!*\
+  !*** ./src/diagrams/info/infoRenderer.js ***!
+  \*******************************************/
+
+/*!*******************************************!*\
+  !*** ./src/diagrams/pie/parser/pie.jison ***!
+  \*******************************************/
+
+/*!********************************************!*\
+  !*** ./src/diagrams/requirement/styles.js ***!
+  \********************************************/
+
+/*!*********************************************!*\
+  !*** ./src/diagrams/class/classRenderer.js ***!
+  \*********************************************/
+
+/*!*********************************************!*\
+  !*** ./src/diagrams/gantt/ganttRenderer.js ***!
+  \*********************************************/
+
+/*!*********************************************!*\
+  !*** ./src/diagrams/info/parser/info.jison ***!
+  \*********************************************/
+
+/*!*********************************************!*\
+  !*** ./src/diagrams/sequence/sequenceDb.js ***!
+  \*********************************************/
+
+/*!*********************************************!*\
+  !*** ./src/diagrams/state/stateRenderer.js ***!
+  \*********************************************/
+
+/*!*********************************************!*\
+  !*** ./src/diagrams/user-journey/styles.js ***!
+  \*********************************************/
+
+/*!**********************************************!*\
+  !*** ./src/dagre-wrapper/intersect/index.js ***!
+  \**********************************************/
+
+/*!**********************************************!*\
+  !*** ./src/diagrams/git/gitGraphRenderer.js ***!
+  \**********************************************/
+
+/*!**********************************************!*\
+  !*** ./src/diagrams/user-journey/svgDraw.js ***!
+  \**********************************************/
+
+/*!***********************************************!*\
+  !*** ./node_modules/path-browserify/index.js ***!
+  \***********************************************/
+
+/*!***********************************************!*\
+  !*** ./src/dagre-wrapper/mermaid-graphlib.js ***!
+  \***********************************************/
+
+/*!***********************************************!*\
+  !*** ./src/diagrams/gantt/parser/gantt.jison ***!
+  \***********************************************/
+
+/*!************************************************!*\
+  !*** ./src/diagrams/class/classRenderer-v2.js ***!
+  \************************************************/
+
+/*!************************************************!*\
+  !*** ./src/diagrams/er/parser/erDiagram.jison ***!
+  \************************************************/
+
+/*!************************************************!*\
+  !*** ./src/diagrams/flowchart/flowRenderer.js ***!
+  \************************************************/
+
+/*!************************************************!*\
+  !*** ./src/diagrams/git/parser/gitGraph.jison ***!
+  \************************************************/
+
+/*!************************************************!*\
+  !*** ./src/diagrams/state/stateRenderer-v2.js ***!
+  \************************************************/
+
+/*!************************************************!*\
+  !*** ./src/diagrams/user-journey/journeyDb.js ***!
+  \************************************************/
+
+/*!**************************************************!*\
+  !*** ./src/diagrams/flowchart/parser/flow.jison ***!
+  \**************************************************/
+
+/*!***************************************************!*\
+  !*** ./src/diagrams/flowchart/flowChartShapes.js ***!
+  \***************************************************/
+
+/*!***************************************************!*\
+  !*** ./src/diagrams/flowchart/flowRenderer-v2.js ***!
+  \***************************************************/
+
+/*!***************************************************!*\
+  !*** ./src/diagrams/requirement/requirementDb.js ***!
+  \***************************************************/
+
+/*!***************************************************!*\
+  !*** ./src/diagrams/sequence/sequenceRenderer.js ***!
+  \***************************************************/
+
+/*!******************************************************!*\
+  !*** ./node_modules/node-libs-browser/mock/empty.js ***!
+  \******************************************************/
+
+/*!******************************************************!*\
+  !*** ./src/diagrams/class/parser/classDiagram.jison ***!
+  \******************************************************/
+
+/*!******************************************************!*\
+  !*** ./src/diagrams/state/parser/stateDiagram.jison ***!
+  \******************************************************/
+
+/*!******************************************************!*\
+  !*** ./src/diagrams/user-journey/journeyRenderer.js ***!
+  \******************************************************/
+
+/*!*******************************************************!*\
+  !*** ./src/dagre-wrapper/intersect/intersect-line.js ***!
+  \*******************************************************/
+
+/*!*******************************************************!*\
+  !*** ./src/dagre-wrapper/intersect/intersect-node.js ***!
+  \*******************************************************/
+
+/*!*******************************************************!*\
+  !*** ./src/dagre-wrapper/intersect/intersect-rect.js ***!
+  \*******************************************************/
+
+/*!*******************************************************!*\
+  !*** external "dagre-d3/lib/label/add-html-label.js" ***!
+  \*******************************************************/
+
+/*!********************************************************!*\
+  !*** ./src/diagrams/requirement/requirementMarkers.js ***!
+  \********************************************************/
+
+/*!********************************************************!*\
+  !*** ./src/diagrams/user-journey/parser/journey.jison ***!
+  \********************************************************/
+
+/*!*********************************************************!*\
+  !*** ./src/dagre-wrapper/intersect/intersect-circle.js ***!
+  \*********************************************************/
+
+/*!*********************************************************!*\
+  !*** ./src/diagrams/requirement/requirementRenderer.js ***!
+  \*********************************************************/
+
+/*!**********************************************************!*\
+  !*** ./src/dagre-wrapper/intersect/intersect-ellipse.js ***!
+  \**********************************************************/
+
+/*!**********************************************************!*\
+  !*** ./src/dagre-wrapper/intersect/intersect-polygon.js ***!
+  \**********************************************************/
+
+/*!************************************************************!*\
+  !*** ./src/diagrams/sequence/parser/sequenceDiagram.jison ***!
+  \************************************************************/
+
+/*!******************************************************************!*\
+  !*** ./src/diagrams/requirement/parser/requirementDiagram.jison ***!
+  \******************************************************************/
+
+/**
+ * @license
+ * Copyright (c) 2012-2013 Chris Pettitt
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+//! moment.js
+
+//! moment.js locale configuration

docs/global.css

@@ -1,134 +0,0 @@
-@media (prefers-color-scheme: light) {
-	html, body {
-		position: relative;
-		width: 100%;
-		height: 100%;
-	}
-
-	#dgraph-div {
-		display: none;
-	}
-
-	body {
-		color: #333;
-		margin: 0;
-		padding: 8px;
-		box-sizing: border-box;
-		font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen-Sans, Ubuntu, Cantarell, "Helvetica Neue", sans-serif;
-	}
-
-	a {
-		color: rgb(0,100,200);
-		text-decoration: none;
-	}
-
-	a:hover {
-		text-decoration: underline;
-	}
-
-	a:visited {
-		color: rgb(0,80,160);
-	}
-
-	label {
-		display: block;
-	}
-
-
-
-	input, button, select, textarea {
-		font-family: inherit;
-		font-size: inherit;
-		padding: 0.4em;
-		margin: 0 0 0.5em 0;
-		box-sizing: border-box;
-		border: 1px solid #ccc;
-		border-radius: 2px;
-	}
-
-	input:disabled {
-		color: #ccc;
-	}
-
-	input[type="range"] {
-		height: 0;
-	}
-
-	button {
-		background-color: #f4f4f4;
-		outline: none;
-	}
-
-	button:active {
-		background-color: #ddd;
-	}
-
-	button:focus {
-		border-color: #666;
-	}
-}
-
-	body {
-		background-color: #3f3f3f;
-		color: #c8c8c8;
-		margin: 0;
-		padding: 8px;
-		box-sizing: border-box;
-		font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen-Sans, Ubuntu, Cantarell, "Helvetica Neue", sans-serif;
-	}}
-@media (prefers-color-scheme: dark) {
-	html, body {
-		position: relative;
-		width: 100%;
-		height: 100%;
-
-
-	a {
-		color: rgb(0,100,200);
-		text-decoration: none;
-	}
-
-	a:hover {
-		text-decoration: underline;
-	}
-
-	a:visited {
-		color: rgb(0,80,160);
-	}
-
-	label {
-		display: block;
-	}
-
-	input, button, select, textarea {
-		font-family: inherit;
-		font-size: inherit;
-		padding: 0.4em;
-		margin: 0 0 0.5em 0;
-		box-sizing: border-box;
-		border: 1px solid #ccc;
-		border-radius: 2px;
-	}
-
-	input:disabled {
-		color: #ccc;
-	}
-
-	input[type="range"] {
-		height: 0;
-	}
-
-	button {
-		background-color: #f4f4f4;
-		outline: none;
-	}
-
-	button:active {
-		background-color: #ddd;
-	}
-
-	button:focus {
-		border-color: #666;
-	}
-}
-

docs/index.html

@@ -1,45 +1,60 @@
-<!doctype html>
+<!DOCTYPE html>
 <html>
-<head>
+  <head>
-	<meta charset='utf8'>
+    <meta charset="utf8" />
-	<meta name='viewport' content='width=device-width'>
+    <meta name="viewport" content="width=device-width" />
 
-	<title>Mermaid live editor</title>
+    <title>Mermaid live editor</title>
 
-	<link rel='icon' type='image/png' href='favicon.png'>
+    <link rel="icon" type="image/png" href="favicon.png" />
-	<link rel='stylesheet' href='styles.css'>
+    <link rel="stylesheet" href="styles.css" />
-	<link rel='stylesheet' href='bundle.css'>
+    <link rel="stylesheet" href="bundle.css" />
-	<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css">
+    <link
-<!-- Google Analytics -->
+      rel="stylesheet"
-<script>
+      href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.2/css/all.min.css"
-	(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
+    />
-	(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
+    <!-- Google Analytics -->
-	m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
+    <script>
-	})(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
+      (function (i, s, o, g, r, a, m) {
+        i['GoogleAnalyticsObject'] = r;
+        (i[r] =
+          i[r] ||
+          function () {
+            (i[r].q = i[r].q || []).push(arguments);
+          }),
+          (i[r].l = 1 * new Date());
+        (a = s.createElement(o)), (m = s.getElementsByTagName(o)[0]);
+        a.async = 1;
+        a.src = g;
+        m.parentNode.insertBefore(a, m);
+      })(
+        window,
+        document,
+        'script',
+        'https://www.google-analytics.com/analytics.js',
+        'ga'
+      );
 
-	ga('create', 'UA-153180559-1', 'auto');
+      ga('create', 'UA-153180559-1', 'auto');
-	</script>
+    </script>
-	<!-- End Google Analytics -->
+    <!-- End Google Analytics -->
 
-	<style>
+    <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
-		.myInlineDecoration {
+    <title>Online FlowChart &amp; Diagrams Editor - Mermaid Live Editor</title>
-			/* cursor: pointer; */
+    <meta
-			/* text-decoration: underline; */
+      name="og:image"
-			font-weight: bold;
+      content="https://github.com/mermaid-js/mermaid/raw/develop/img/header.png"
-			font-style: oblique;
+    />
-			background: #ffcccc;
+    <link
-		}
+      rel="canonical"
-		#dgraph-div {
+      href="https://mermaid-js.github.io/mermaid-live-editor/"
-			display: none;
+    />
-		}
+    <meta
-</style>
+      name="description"
-  <meta content="text/html; charset=utf-8" http-equiv="Content-Type">
+      content="Simplify documentation and avoid heavy tools. Open source Visio Alternative. Commonly used for explaining your code! Mermaid is a simple markdown-like script language for generating charts from text via javascript."
-  <title>Online FlowChart &amp; Diagrams Editor - Mermaid Live Editor</title>
+    />
-  <meta name="og:image" content="https://mermaid-js.github.io/images/header.png">
-  <link rel="canonical" href="https://mermaid-js.github.io/mermaid-live-editor/">
-  <meta name="description" content="Simplify documentation and avoid heavy tools. Open source Visio Alternative. Commonly used for explaining your code! Mermaid is a simple markdown-like script language for generating charts from text via javascript.">
   </head>
-<body>
+  <body>
-	<script src='bundle.js'></script>
+    <script src="bundle.js"></script>
-</body>
+  </body>
-</html>
+</html>

docs/styles.css

@@ -1,17 +1,17 @@
 html {
-	padding: 0;
+  padding: 0;
-	width: 100%;
+  width: 100%;
-	height: 100%;
+  height: 100%;
 }
 
 body {
   padding: 32px;
-	font-family: 'trebuchet ms', verdana, arial;
+  font-family: 'trebuchet ms', verdana, arial;
-	position: relative;
+  position: relative;
-	width: 100%;
+  width: 100%;
-	height: 100%;
+  height: 100%;
-	box-sizing: border-box;
+  box-sizing: border-box;
-	margin: 0;
+  margin: 0;
 }
 
 /* @media (prefers-color-scheme: dark) {
@@ -41,3 +41,20 @@ i {
 .mermaidTooltip {
   position: absolute;
 }
+
+@font-face {
+  font-family: 'codicon';
+  src: url('codicon.ttf') format('truetype');
+}
+
+.myInlineDecoration {
+  /* cursor: pointer; */
+  /* text-decoration: underline; */
+  font-weight: bold;
+  font-style: oblique;
+  background: #ffcccc;
+}
+
+#dgraph-div {
+  display: none;
+}

package.json

@@ -1,46 +1,51 @@
 {
   "name": "mermaid-live-editor",
-  "version": "1.2.0",
+  "version": "1.2.13",
   "license": "MIT",
   "devDependencies": {
-    "cross-env": "^5.2.0",
+    "copy-webpack-plugin": "^8.1.1",
-    "css-loader": "^2.1.1",
+    "cross-env": "^7.0.3",
-    "husky": "^4.3.0",
+    "css-loader": "^5.2.0",
-    "lint-staged": "^10.5.2",
+    "file-loader": "^6.2.0",
-    "mini-css-extract-plugin": "^0.6.0",
+    "husky": "^6.0.0",
+    "lint-staged": "^10.5.4",
+    "mini-css-extract-plugin": "^1.6.0",
+    "monaco-editor-webpack-plugin": "^2.1.0",
     "prettier": "^2.2.1",
-    "prettier-plugin-svelte": "^1.4.1",
+    "prettier-plugin-svelte": "^2.2.0",
-    "serve": "^11.0.0",
+    "serve": "^11.3.2",
-    "style-loader": "^0.23.1",
+    "style-loader": "^2.0.0",
-    "svelte": "^3.0.0",
+    "svelte": "^3.38.2",
-    "svelte-loader": "2.13.3",
+    "svelte-loader": "3.1.1",
     "svelte-watch-resize": "^1.0.3",
-    "webpack": "^4.30.0",
+    "webpack": "^5.36.2",
-    "webpack-cli": "^3.3.0",
+    "webpack-cli": "^4.7.0",
-    "webpack-dev-server": "^3.3.1"
+    "webpack-dev-server": "^3.11.2"
   },
   "scripts": {
-    "release": "cross-env NODE_ENV=production webpack -p",
+    "build": "webpack build",
-    "build": "cross-env NODE_ENV=production webpack",
+    "dev": "webpack serve --content-base public",
-    "dev": "webpack-dev-server --content-base docs",
+    "release": "cross-env NODE_ENV=production webpack build",
-    "pretty": "prettier --write ./src/*"
+    "pretty": "prettier --plugin-search-dir=. --write ./src/*",
+    "pre-commit": "lint-staged",
+    "postinstall": "husky install"
   },
   "dependencies": {
-    "mermaid": "8.8.4",
+    "js-base64": "^3.6.0",
-    "js-base64": "^2.5.1",
     "json-lint": "^0.1.0",
     "jsonlint": "^1.6.3",
-    "moment": "^2.24.0",
+    "mermaid": "8.9.3",
-    "monaco-editor": "0.18.1",
+    "moment": "^2.29.1",
-    "svelte-routing": "^1.4.0",
+    "monaco-editor": "0.21.3",
-    "svelte-spa-router": "^1.3.0"
+    "svelte-routing": "^1.6.0",
-  },
+    "svelte-spa-router": "^3.1.0"
-  "husky": {
-    "hooks": {
-      "pre-commit": "lint-staged"
-    }
   },
   "lint-staged": {
     "*.{ts,svelte,js,css,md}": "prettier --plugin-search-dir=. --write"
+  },
+  "volta": {
+    "node": "14.16.1",
+    "yarn": "1.22.10",
+    "npm": "7.11.2"
   }
 }

public/index.html

@@ -0,0 +1,60 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf8" />
+    <meta name="viewport" content="width=device-width" />
+
+    <title>Mermaid live editor</title>
+
+    <link rel="icon" type="image/png" href="favicon.png" />
+    <link rel="stylesheet" href="styles.css" />
+    <link rel="stylesheet" href="bundle.css" />
+    <link
+      rel="stylesheet"
+      href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.2/css/all.min.css"
+    />
+    <!-- Google Analytics -->
+    <script>
+      (function (i, s, o, g, r, a, m) {
+        i['GoogleAnalyticsObject'] = r;
+        (i[r] =
+          i[r] ||
+          function () {
+            (i[r].q = i[r].q || []).push(arguments);
+          }),
+          (i[r].l = 1 * new Date());
+        (a = s.createElement(o)), (m = s.getElementsByTagName(o)[0]);
+        a.async = 1;
+        a.src = g;
+        m.parentNode.insertBefore(a, m);
+      })(
+        window,
+        document,
+        'script',
+        'https://www.google-analytics.com/analytics.js',
+        'ga'
+      );
+
+      ga('create', 'UA-153180559-1', 'auto');
+    </script>
+    <!-- End Google Analytics -->
+
+    <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
+    <title>Online FlowChart &amp; Diagrams Editor - Mermaid Live Editor</title>
+    <meta
+      name="og:image"
+      content="https://github.com/mermaid-js/mermaid/raw/develop/img/header.png"
+    />
+    <link
+      rel="canonical"
+      href="https://mermaid-js.github.io/mermaid-live-editor/"
+    />
+    <meta
+      name="description"
+      content="Simplify documentation and avoid heavy tools. Open source Visio Alternative. Commonly used for explaining your code! Mermaid is a simple markdown-like script language for generating charts from text via javascript."
+    />
+  </head>
+  <body>
+    <script src="bundle.js"></script>
+  </body>
+</html>

public/styles.css

@@ -0,0 +1,60 @@
+html {
+  padding: 0;
+  width: 100%;
+  height: 100%;
+}
+
+body {
+  padding: 32px;
+  font-family: 'trebuchet ms', verdana, arial;
+  position: relative;
+  width: 100%;
+  height: 100%;
+  box-sizing: border-box;
+  margin: 0;
+}
+
+/* @media (prefers-color-scheme: dark) {
+	body {
+		background-color: #3f3f3f;
+		color: #c8c8c8;
+	}
+	a, label {
+		color: #d8d8d8;
+	}
+} */
+.mermaid {
+  /* font-family: 'trebuchet ms', verdana, arial; */
+}
+.marketing-links {
+  font-size: 16px;
+}
+
+.ant-card {
+  margin-bottom: 16px;
+}
+
+i {
+  font-size: 10px !important;
+}
+
+.mermaidTooltip {
+  position: absolute;
+}
+
+@font-face {
+  font-family: 'codicon';
+  src: url('codicon.ttf') format('truetype');
+}
+
+.myInlineDecoration {
+  /* cursor: pointer; */
+  /* text-decoration: underline; */
+  font-weight: bold;
+  font-style: oblique;
+  background: #ffcccc;
+}
+
+#dgraph-div {
+  display: none;
+}

src/code-error-store.js

@@ -1,3 +0,0 @@
-import { writable } from 'svelte/store';
-
-export const codeErrorStore = writable(undefined);

src/code-store.js

@@ -1,55 +1,49 @@
 import { writable, get } from 'svelte/store';
-// import mermaid from '@mermaid-js/mermaid';
-import mermaid from '@mermaid';
 import { Base64 } from 'js-base64';
-import { push, pop, replace } from 'svelte-spa-router';
+import { replace, location } from 'svelte-spa-router';
 
-export const codeStore = writable({});
+const isDarkMode =
+  window.matchMedia('(prefers-color-scheme: dark)').matches && false;
+const defaultState = {
+  code: `graph TD
+    A[Christmas] -->|Get money| B(Go shopping)
+    B --> C{Let me think}
+    C -->|One| D[Laptop]
+    C -->|Two| E[iPhone]
+    C -->|Three| F[fa:fa-car Car]
+  `,
+  mermaid: { theme: isDarkMode ? 'dark' : 'default' },
+};
+export const codeStore = writable(defaultState);
 export const fromUrl = (data) => {
-  let code;
   let state;
-  const isDarkMode =
-    window.matchMedia('(prefers-color-scheme: dark)').matches && false;
   try {
-    let stateStr = Base64.decode(data);
+    const stateStr = Base64.decode(data);
     console.log('state from url', stateStr);
     state = JSON.parse(stateStr);
-
-    if (state.code === undefined) {
-      // not valid json
-      //      state = { code: '', mermaid: { theme: themeFromUrl } }
-    }
-    code = state.code;
   } catch (e) {
-    // console.error('Init error', e);
+    console.error('Init error', e);
-    code = `graph TD
+    state = defaultState;
-  A[Christmas] -->|Get money| B(Go shopping)
-  B --> C{Let me think}
-  C -->|One| D[Laptop]
-  C -->|Two| E[iPhone]
-  C -->|Three| F[fa:fa-car Car]
-		`;
-    state = { code, mermaid: { theme: isDarkMode ? 'dark' : 'default' } };
   }
-
+  codeStore.set({ ...state, updateEditor: true });
-  codeStore.set(state);
 };
 export const updateCodeStore = (newState) => {
   codeStore.set(newState);
-  replace('/edit/' + Base64.encodeURI(JSON.stringify(newState)));
 };
 export const updateCode = (code, updateEditor) => {
   const state = get(codeStore);
-  state.code = code;
+  codeStore.set({ ...state, code, updateEditor });
-  state.updateEditor = updateEditor;
-  codeStore.set(state);
 };
-export const updateConfig = (config) => {
+export const updateConfig = (config, updateEditor) => {
   const state = get(codeStore);
-  state.mermaid = config;
+  codeStore.set({ ...state, mermaid: config, updateEditor });
-  codeStore.set(state);
 };
 
-const unsubscribe = codeStore.subscribe((state) => {
+export const initURLSubscription = () => {
-  replace('/edit/' + Base64.encodeURI(JSON.stringify(state)));
+  codeStore.subscribe((state) => {
-});
+    const currentLocation = get(location).split('/')[1];
+    replace(
+      `/${currentLocation || 'edit'}/` + Base64.encodeURI(JSON.stringify(state))
+    );
+  });
+};