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

@@ -9,7 +9,7 @@ jobs:
     steps:
       - uses: actions/setup-node@v2
         with:
-          node-version: '12'
+          node-version: '14'
 
       - name: Checkout
         uses: actions/checkout@v2
@@ -18,9 +18,10 @@ jobs:
         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 ./docs/*
+          git add .
-          git commit -m "Release"
+          git commit -m "Release $(yarn version --version)"
           git push

.github/workflows/stale.yml

@@ -2,17 +2,16 @@ name: Mark stale issues and pull requests
 
 on:
   schedule:
-  - cron: "0 0 * * *"
+    - cron: '0 0 * * 4'
 
 jobs:
   stale:
-
     runs-on: ubuntu-latest
-
     steps:
-    - uses: actions/stale@v3
+      - uses: actions/stale@v3
-      with:
+        with:
-        repo-token: ${{ secrets.GITHUB_TOKEN }}
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
-        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'  
+          exempt-issue-labels: 'retained'
-        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'  
+          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,9 +4,15 @@
 
 # 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 add .

docs/10.10.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[10],{914:function(e,s,o){"use strict";o.r(s),o.d(s,"conf",(function(){return n})),o.d(s,"language",(function(){return t}));var n={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")}}},t={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/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/11.11.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[11],{915:function(e,n,t){"use strict";t.r(n),t.d(n,"conf",(function(){return o})),t.d(n,"language",(function(){return s}));var o={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/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/13.13.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[13],{917:function(e,n,r){"use strict";r.r(n),r.d(n,"conf",(function(){return t})),r.d(n,"language",(function(){return s}));var t={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/14.14.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[14],{919:function(e,t,n){"use strict";n.r(t),n.d(t,"conf",(function(){return o})),n.d(t,"language",(function(){return s}));var o={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")}}},s={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/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/15.15.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[15],{920:function(t,r,e){"use strict";e.r(r),e.d(r,"conf",(function(){return s})),e.d(r,"language",(function(){return n}));var s={brackets:[],autoClosingPairs:[],surroundingPairs:[]},n={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/16.16.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[16],{921:function(e,t,n){"use strict";n.r(t),n.d(t,"conf",(function(){return r})),n.d(t,"language",(function(){return i}));var r={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.*\\*\\/")}}},i={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/17.17.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[17],{922:function(e,n,t){"use strict";t.r(n),t.d(n,"conf",(function(){return o})),t.d(n,"language",(function(){return 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/18.18.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[18],{923:function(e,n,o){"use strict";o.r(n),o.d(n,"conf",(function(){return s})),o.d(n,"language",(function(){return t}));var s={brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}]},t={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/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/19.19.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[19],{924:function(e,n,t){"use strict";t.r(n),t.d(n,"conf",(function(){return s})),t.d(n,"language",(function(){return o}));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*\\*\\)")}}},o={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/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/20.20.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[20],{925:function(e,n,o){"use strict";o.r(n),o.d(n,"conf",(function(){return t})),o.d(n,"language",(function(){return s}));var t={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/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/21.21.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[21],{926:function(e,n,t){"use strict";t.r(n),t.d(n,"conf",(function(){return o})),t.d(n,"language",(function(){return 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/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/23.23.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[23],{928:function(e,t,s){"use strict";s.r(t),s.d(t,"conf",(function(){return o})),s.d(t,"language",(function(){return r}));var o={comments:{lineComment:"//",blockComment:["/*","*/"]},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"',notIn:["string"]}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'}]},r={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/24.24.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[24],{929:function(e,t,n){"use strict";n.r(t),n.d(t,"conf",(function(){return o})),n.d(t,"language",(function(){return d}));var i=n(212),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.languages.IndentAction.IndentOutdent}},{beforeText:new RegExp("<(?!(?:"+r.join("|")+"))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$","i"),action:{indentAction:i.languages.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/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/25.25.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[25],{930:function(e,n,s){"use strict";s.r(n),s.d(n,"conf",(function(){return o})),s.d(n,"language",(function(){return t}));var o={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:"'"}]},t={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/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/26.26.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[26],{931:function(e,t,o){"use strict";o.r(t),o.d(t,"conf",(function(){return n})),o.d(t,"language",(function(){return 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:".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/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/28.28.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[28],{934:function(e,n,t){"use strict";t.r(n),t.d(n,"conf",(function(){return i})),t.d(n,"language",(function(){return o}));var i={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>))")}}},o={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/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/29.29.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[29],{935:function(e,t,n){"use strict";n.r(t),n.d(t,"conf",(function(){return i})),n.d(t,"language",(function(){return 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/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/30.30.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[30],{936:function(e,t,i){"use strict";i.r(t),i.d(t,"conf",(function(){return o})),i.d(t,"language",(function(){return 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/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/31.31.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[31],{937:function(e,n,o){"use strict";o.r(n),o.d(n,"conf",(function(){return t})),o.d(n,"language",(function(){return 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/32.32.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[32],{938:function(e,t,n){"use strict";n.r(t),n.d(t,"conf",(function(){return s})),n.d(t,"language",(function(){return o}));var s={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/33.33.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[33],{939:function(e,t,n){"use strict";n.r(t),n.d(t,"conf",(function(){return r})),n.d(t,"language",(function(){return s}));var r={wordPattern:/(-?\d*\.\d\w*)|([^\`\~\!\@\#%\^\&\*\(\)\=\$\-\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,comments:{blockComment:["###","###"],lineComment:"#"},folding:{markers:{start:new RegExp("^\\s*#region\\b"),end:new RegExp("^\\s*#endregion\\b")}}},s={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/34.34.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[34],{940:function(E,T,A){"use strict";A.r(T),A.d(T,"conf",(function(){return N})),A.d(T,"language",(function(){return R}));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"]}]},R={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/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/36.36.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[36],{942:function(e,n,o){"use strict";o.r(n),o.d(n,"conf",(function(){return t})),o.d(n,"language",(function(){return 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/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/37.37.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[37],{943:function(e,t,o){"use strict";o.r(t),o.d(t,"conf",(function(){return n})),o.d(t,"language",(function(){return r}));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:"'"}],folding:{markers:{start:new RegExp("^\\s*\\{\\$REGION(\\s\\'.*\\')?\\}"),end:new RegExp("^\\s*\\{\\$ENDREGION\\}")}}},r={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/38.38.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[38],{944:function(e,o,n){"use strict";n.r(o),n.d(o,"conf",(function(){return t})),n.d(o,"language",(function(){return 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/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/44.44.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[44],{950:function(e,n,s){"use strict";s.r(n),s.d(n,"conf",(function(){return t})),s.d(n,"language",(function(){return 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/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/45.45.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[45],{951:function(e,t,n){"use strict";n.r(t),n.d(t,"conf",(function(){return o})),n.d(t,"language",(function(){return 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/46.46.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[46],{952:function(e,n,t){"use strict";t.r(n),t.d(n,"conf",(function(){return r})),t.d(n,"language",(function(){return i}));var s=t(212),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:s.languages.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/47.47.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[47],{953:function(e,o,r){"use strict";r.r(o),r.d(o,"conf",(function(){return t})),r.d(o,"language",(function(){return n}));var t={comments:{lineComment:"#"},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'}]},n={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/49.49.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[49],{955:function(E,S,e){"use strict";e.r(S),e.d(S,"conf",(function(){return T})),e.d(S,"language",(function(){return 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/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/51.51.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[51],{957:function(e,n,s){"use strict";s.r(n),s.d(n,"conf",(function(){return i})),s.d(n,"language",(function(){return 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/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/53.53.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[53],{959:function(e,t,o){"use strict";o.r(t),o.d(t,"conf",(function(){return n})),o.d(t,"language",(function(){return 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/54.54.js

@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[54],{960:function(e,n,o){"use strict";o.r(n),o.d(n,"conf",(function(){return t})),o.d(n,"language",(function(){return 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/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'],
+            ],
+          },
+        };
+    },
+  },
+]);