rollback #288 due to #338

Update mermaid

.eslintrc.cjs

@@ -0,0 +1,47 @@
+module.exports = {
+	root: true,
+	parser: '@typescript-eslint/parser',
+	extends: [
+		'eslint:recommended',
+		'plugin:@typescript-eslint/recommended',
+		// 'plugin:@typescript-eslint/recommended-requiring-type-checking',
+		'prettier'
+	],
+	plugins: ['svelte3', 'tailwindcss', '@typescript-eslint'],
+	ignorePatterns: [
+		'docs/*',
+		'*.cjs',
+		'*.md',
+		'snapshots.js',
+		'svelte.config.js',
+		'renovate.json',
+		'package.json',
+		'tsconfig.json'
+	],
+	overrides: [{ files: ['*.svelte'], processor: 'svelte3/svelte3' }],
+	settings: {
+		'svelte3/typescript': () => require('typescript')
+	},
+	parserOptions: {
+		sourceType: 'module',
+		ecmaVersion: 2019,
+		tsconfigRootDir: __dirname,
+		project: ['./tsconfig.json'],
+		extraFileExtensions: ['.svelte']
+	},
+	env: {
+		browser: true,
+		es2017: true,
+		node: true
+	},
+	rules: {
+		'@typescript-eslint/ban-ts-comment': [
+			'error',
+			{
+				'ts-ignore': 'allow-with-description'
+			}
+		],
+		'@typescript-eslint/no-unsafe-member-access': 'off',
+		'@typescript-eslint/no-unsafe-assignment': 'off'
+	}
+};

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,41 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: ''
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Link to Live Editor:
+Steps to reproduce the behavior:
+
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Desktop (please complete the following information):**
+
+- OS: [e.g. iOS]
+- Browser [e.g. chrome, safari]
+- Version [e.g. 22]
+
+**Smartphone (please complete the following information):**
+
+- Device: [e.g. iPhone6]
+- OS: [e.g. iOS8.1]
+- Browser [e.g. stock browser, safari]
+- Version [e.g. 22]
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,19 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: enhancement
+assignees: ''
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/codeql/config.yml

@@ -0,0 +1,7 @@
+name: 'Mermaid CodeQL config'
+
+paths:
+  - src
+paths-ignore:
+  - node_modules
+  - '**/*.spec.js'

.github/pull_request_template.md

@@ -12,6 +12,6 @@ Describe the way your implementation works or what design decisions you made if
 
 Make sure you
 
-- [ ] :book: have read the [contribution guidelines](https://github.com/mermaid-js/mermaid/blob/develop/CONTRIBUTING.md)
+- [ ] :book: have read the [contribution guidelines](https://github.com/mermaid-js/mermaid/blob/master/CONTRIBUTING.md)
 - [ ] :computer: have added unit/e2e tests (if appropriate)
-- [ ] :bookmark: targeted `master` branch
+- [ ] :bookmark: targeted `develop` branch

.github/workflows/codeql-analysis.yml

@@ -9,14 +9,14 @@
 # the `language` matrix defined below to confirm you have the correct set of
 # supported CodeQL languages.
 #
-name: "CodeQL"
+name: 'CodeQL'
 
 on:
   push:
-    branches: [ master ]
+    branches: [master]
   pull_request:
     # The branches below must be a subset of the branches above
-    branches: [ master ]
+    branches: [master]
   schedule:
     - cron: '36 1 * * 2'
 
@@ -28,40 +28,41 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        language: [ 'javascript' ]
+        language: ['javascript']
         # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
         # Learn more:
         # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
 
     steps:
-    - name: Checkout repository
-      uses: actions/checkout@v2
+      - name: Checkout repository
+        uses: actions/checkout@v2
 
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
-      with:
-        languages: ${{ matrix.language }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+      # Initializes the CodeQL tools for scanning.
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v1
+        with:
+          config-file: ./.github/codeql/config.yml
+          languages: ${{ matrix.language }}
+          # If you wish to specify custom queries, you can do so here or in a config file.
+          # By default, queries listed here will override any specified in a config file.
+          # Prefix the list here with "+" to use these queries and those in the config file.
+          # queries: ./path/to/local/query, your-org/your-repo/queries@main
 
-    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
-    # If this step fails, then you should remove it and run the build manually (see below)
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v1
+      # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+      # If this step fails, then you should remove it and run the build manually (see below)
+      # - name: Autobuild
+      #   uses: github/codeql-action/autobuild@v1
 
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 https://git.io/JvXDl
+      # ℹ️ Command-line programs to run using the OS shell.
+      # 📚 https://git.io/JvXDl
 
-    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
-    #    and modify them (or add more) to build your code if your project
-    #    uses a compiled language
+      # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+      #    and modify them (or add more) to build your code if your project
+      #    uses a compiled language
 
-    #- run: |
-    #   make bootstrap
-    #   make release
+      #- run: |
+      #   make bootstrap
+      #   make release
 
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v1

.github/workflows/cypress.yml

@@ -0,0 +1,45 @@
+name: Cypress Tests
+
+on:
+  pull_request:
+    branches:
+      - master
+      - develop
+
+jobs:
+  cypress-run:
+    runs-on: ubuntu-latest
+    container: cypress/browsers:node14.16.0-chrome90-ff88
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - uses: actions/cache@v2
+        id: yarn-and-build-cache
+        with:
+          path: |
+            ~/.cache/Cypress
+            build
+            node_modules
+          key: ${{ runner.os }}-node_modules-build-${{ hashFiles('**/yarn.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-node_modules-build-
+
+      - name: Lint
+        run: |
+          yarn install
+          yarn run lint
+
+      # Install NPM dependencies, cache them correctly
+      # and run all Cypress tests
+      - name: Cypress run
+        uses: cypress-io/github-action@v2
+        with:
+          build: yarn build
+          start: yarn preview
+          wait-on: 'http://localhost:3000'
+          record: true
+          headless: true
+        env:
+          CYPRESS_RECORD_KEY: ${{ secrets.CYPRESS_RECORD_KEY }}

.github/workflows/deploy.yml

@@ -3,6 +3,9 @@ on:
   push:
     branches:
       - master
+  pull_request:
+    branches:
+      - master
 jobs:
   build:
     runs-on: ubuntu-latest
@@ -14,14 +17,35 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v2
 
+      - name: Get yarn cache directory path
+        id: yarn-cache-dir-path
+        run: echo "::set-output name=dir::$(yarn cache dir)"
+
+      - uses: actions/cache@v2
+        id: yarn-cache
+        with:
+          path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
+          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-yarn-
+
       - name: Build & Deploy
         run: |
           npm i -g yarn
+          export DEPLOY=true
+          [ "$GITHUB_EVENT_NAME" == "pull_request" ] && export BETA=true && rm -rf docs/beta/
+          [ "$GITHUB_EVENT_NAME" != "pull_request" ] && rm -rf docs/_app/
           yarn install
-          yarn version --patch --no-git-tag-version
-          yarn release
-          git config user.name github-actions
-          git config user.email github-actions@github.com
-          git add .
-          git commit -m "Release $(yarn version --version)"
-          git push
+          yarn run lint
+          version=$(yarn version --patch --no-git-tag-version | grep "New version" | cut -d':' -f 2)
+          yarn build
+          cd bin
+          ./fix-path
+          cd ..
+
+      - name: Deploy
+        uses: peaceiris/actions-gh-pages@v3
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./docs
+          keep_files: true

.github/workflows/docker-publish.yml

@@ -0,0 +1,69 @@
+name: Docker
+
+on:
+  push:
+    # Publish `master` as Docker `latest` image.
+    branches:
+      - master
+
+    # Publish `v1.2.3` tags as releases.
+    tags:
+      - v*
+
+  # Run tests for all PRs to master and develop.
+  pull_request:
+    branches:
+      - master
+      - develop
+
+env:
+  IMAGE_NAME: mermaid-live-editor
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Run tests
+        run: |
+          docker build . --file Dockerfile
+
+  push:
+    # Ensure test job passes before pushing image.
+    needs: test
+
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push'
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Build image
+        run: docker build . --file Dockerfile --tag $IMAGE_NAME
+
+      - name: Log into registry
+        run: echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io -u ${{ github.actor }} --password-stdin
+
+      - name: Push image
+        run: |
+          IMAGE_ID=ghcr.io/${{ github.repository_owner }}/$IMAGE_NAME
+
+          # Change all uppercase to lowercase
+          IMAGE_ID=$(echo $IMAGE_ID | tr '[A-Z]' '[a-z]')
+
+          # Strip git ref prefix from version
+          VERSION=$(echo "${{ github.ref }}" | sed -e 's,.*/\(.*\),\1,')
+
+          # Strip "v" prefix from tag name
+          [[ "${{ github.ref }}" == "refs/tags/"* ]] && VERSION=$(echo $VERSION | sed -e 's/^v//')
+
+          # Use Docker `latest` tag convention
+          [ "$VERSION" == "master" ] && VERSION=latest
+
+          echo IMAGE_ID=$IMAGE_ID
+          echo VERSION=$VERSION
+
+          docker tag $IMAGE_NAME $IMAGE_ID:$VERSION
+          docker push $IMAGE_ID:$VERSION

.gitignore

@@ -4,4 +4,10 @@ coverage/
 build/
 yarn-error.log
 .npmrc
-*node_modules*
+.DS_Store
+/.svelte-kit
+/build
+/functions
+/snapshots.js
+/cypress/videos
+/cypress/screenshots

.husky/pre-commit

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

.npmrc

@@ -0,0 +1 @@
+engine-strict=true

.prettierignore

@@ -1 +1,6 @@
-dist/
+docs/**
+.svelte-kit/**
+static/**
+build/**
+node_modules/**
+snapshots.js

.prettierrc

@@ -1,5 +1,8 @@
 {
-    "singleQuote": true,
-    "svelteSortOrder": "scripts-styles-markup",
-    "svelteBracketNewLine": false
-}
+	"singleQuote": true,
+	"svelteSortOrder": "options-scripts-markup-styles",
+	"svelteBracketNewLine": false,
+	"useTabs": true,
+	"trailingComma": "none",
+	"printWidth": 100
+}

Dockerfile

@@ -6,9 +6,7 @@
 # Stop               : press ctrl + c 
 #                                     or 
 #                                        docker stop mermaid-live-editor
-
-
-FROM node:14.16.0-alpine3.13 as mermaid-live-editor-builder
+FROM node:14.17.0 as mermaid-live-editor-builder 
 COPY --chown=node:node . /home
 WORKDIR /home
 RUN yarn install

README.md

@@ -1,6 +1,6 @@
-[![Join our Slack!](https://img.shields.io/static/v1?message=join%20chat&color=9cf&logo=slack&label=slack)](https://join.slack.com/t/mermaid-talk/shared_invite/enQtNzc4NDIyNzk4OTAyLWVhYjQxOTI2OTg4YmE1ZmJkY2Y4MTU3ODliYmIwOTY3NDJlYjA0YjIyZTdkMDMyZTUwOGI0NjEzYmEwODcwOTE)
+[![Mermaid Live Editor](https://img.shields.io/endpoint?url=https://dashboard.cypress.io/badge/detailed/2ckppp/master&style=flat&logo=cypress)](https://dashboard.cypress.io/projects/2ckppp/runs) [![Join our Slack!](https://img.shields.io/static/v1?message=join%20chat&color=9cf&logo=slack&label=slack)](https://join.slack.com/t/mermaid-talk/shared_invite/enQtNzc4NDIyNzk4OTAyLWVhYjQxOTI2OTg4YmE1ZmJkY2Y4MTU3ODliYmIwOTY3NDJlYjA0YjIyZTdkMDMyZTUwOGI0NjEzYmEwODcwOTE)
 
-# Contributors are welcome
+# Contributors are welcome!
 
 If you want to speed up the progress for mermaid-live-editor, join the slack channel and contact knsv.
 
@@ -19,41 +19,34 @@ Edit, preview and share mermaid charts/diagrams.
 
 You can try out a live version [here](https://mermaid-js.github.io/mermaid-live-editor/).
 
+## Docker
+
+```bash
+docker run --publish 8000:80 ghcr.io/mermaid-js/mermaid-live-editor
+```
+
+Then open http://localhost:8000
+
 ## Setup
 
 [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). :
+This project is set up using [Yarn](https://classic.yarnpkg.com/en/docs/getting-started):
 
 ```
 yarn install
 ```
 
-or in develop branch to use the beta version of mermaid use
-
-```
-yarn install --update-checksums
-```
-
-This together with a .npmrc file:
-
-```
-registry=https://registry.npmjs.com/
-@mermaid-js:registry=https://npm.pkg.github.com
-//npm.pkg.github.com/:_authToken="XXXXXXXXX"
-```
-
 ## Development
 
 ```
-yarn dev
-open http://localhost:8080
+yarn dev -- --open
 ```
 
-This app is created with Svelte + svelte-spa-router.
+This app is created with Svelte Kit.
 
 ## Release
 
-```
-yarn release
-```
+When a PR is created targeting master, it will be built and deployed as a beta in http://mermaid-js.github.io/mermaid-live-editor/beta
+
+Once the PR is merged, it will automatically be released.

bin/fix-path

@@ -0,0 +1,6 @@
+#!/bin/bash
+pushd ../docs
+# find ./ -type f -exec sed -i 's/service-worker.js/mermaid-live-editor\/service-worker.js/g' {} \;
+find ./ -type f -exec sed -i 's/manifest.json/\/mermaid-live-editor\/manifest.json/g' {} \;
+find ./ -type f -exec sed -i 's/favicon.png/\/mermaid-live-editor\/favicon.png/g' {} \;
+popd

cypress.json

@@ -0,0 +1,11 @@
+{
+	"projectId": "2ckppp",
+	"$schema": "https://on.cypress.io/cypress.schema.json",
+	"baseUrl": "http://localhost:3000",
+	"pluginsFile": "./cypress/plugins/index.cjs",
+	"viewportWidth": 1440,
+	"viewportHeight": 768,
+	"snapshotFileName": "./cypress/snapshots.js",
+	"defaultCommandTimeout": 16000,
+	"requestTimeout": 16000
+}

cypress/.eslintrc

@@ -0,0 +1,12 @@
+{
+	"plugins": ["cypress", "mocha"],
+	"extends": ["plugin:cypress/recommended", "plugin:mocha/recommended"],
+	"rules": {
+		"jest/expect-expect": "off",
+		"mocha/no-mocha-arrows": "off"
+	},
+	"env": {
+		"cypress/globals": true,
+		"mocha": true
+	}
+}

cypress/fixtures/example.json

@@ -0,0 +1,5 @@
+{
+	"name": "Using fixtures to represent data",
+	"email": "hello@cypress.io",
+	"body": "Fixtures are a great way to mock data for responses to routes"
+}

cypress/integration/actions.spec.ts

@@ -0,0 +1,24 @@
+describe('Check actions', () => {
+	beforeEach(() => {
+		cy.clearLocalStorage();
+		cy.visit('/edit');
+	});
+	it('should update markdown code', () => {
+		cy.get('#markdown')
+			.invoke('val')
+			.then((oldText) => {
+				cy.get('#editor').click('bottom').type('{enter}C --> HistoryTest');
+				cy.get('#markdown')
+					.invoke('val')
+					.then((newText) => {
+						expect(oldText).to.not.eq(newText);
+					});
+			});
+	});
+
+	it('should load gists from URL', () => {
+		cy.get('#gist').type('https://gist.github.com/sidharthv96/6268a23e673a533dcb198f241fd7012a');
+		cy.contains('Load Gist').click();
+		cy.contains('Go shopping!!');
+	});
+});

cypress/integration/diagramUpdate.spec.ts

@@ -0,0 +1,33 @@
+describe('Auto sync tests', () => {
+	beforeEach(() => {
+		cy.clearLocalStorage();
+		cy.visit('/');
+	});
+	it('should dim diagram when code is edited', () => {
+		cy.contains('Auto sync').click();
+		cy.get('#view').should('not.have.class', 'outOfSync');
+		cy.get('#editor').type('  C --> Test');
+		cy.get('#view').should('have.class', 'outOfSync');
+		cy.getLocalStorage('codeStore').snapshot();
+	});
+
+	it('should show/hide sync button with auto sync', () => {
+		cy.get('[data-cy=sync]').should('not.exist');
+		cy.contains('Auto sync').click();
+		cy.get('[data-cy=sync]').should('exist');
+		cy.get('#autoSync').check();
+		cy.get('[data-cy=sync]').should('not.exist');
+	});
+	it('should not dim diagram when code is in sync', () => {
+		cy.contains('Auto sync').click();
+		cy.get('#view').should('not.have.class', 'outOfSync');
+		cy.get('#editor').type('  C --> Test');
+		cy.get('#view').should('have.class', 'outOfSync');
+		cy.get('[data-cy=sync]').click();
+		cy.get('#view').should('not.have.class', 'outOfSync');
+		cy.get('#autoSync').check();
+		cy.get('#editor').type('ing');
+		cy.get('#view').should('not.have.class', 'outOfSync');
+		cy.getLocalStorage('codeStore').snapshot();
+	});
+});

cypress/integration/history.spec.ts

@@ -0,0 +1,63 @@
+describe('Save History', () => {
+	beforeEach(() => {
+		cy.clock();
+		cy.clearLocalStorage();
+		cy.visit('/edit');
+		cy.contains('Actions').click();
+		cy.contains('History').click();
+	});
+
+	it('should save when clicked', () => {
+		cy.get('#historyList').find('li').should('have.length', 0);
+		cy.get('#historyList').contains('No items in History');
+		cy.get('#saveHistory').click();
+		cy.get('#historyList').find('No items in History').should('not.exist');
+		cy.get('#historyList').find('li').should('have.length', 1);
+		cy.get('#saveHistory').click();
+		cy.on('window:alert', (str) => {
+			expect(str).to.equal('State already saved.');
+		});
+		cy.on('window:confirm', () => true);
+		cy.get('#editor').type('  C --> HistoryTest');
+		cy.get('#saveHistory').click();
+		cy.get('#historyList').find('li').should('have.length', 2);
+	});
+
+	it('should be able to restore and delete', () => {
+		cy.get('#saveHistory').click();
+		cy.get('#editor').type('  C --> HistoryTest');
+		cy.get('#historyList').find('No items in History').should('not.exist');
+		cy.get('#historyList').find('li').should('have.length', 1);
+		cy.contains('HistoryTest');
+		cy.contains('Restore').click();
+		cy.contains('HistoryTest').should('not.exist');
+		cy.contains('Delete').click();
+		cy.get('#historyList').find('li').should('have.length', 0);
+		cy.get('#historyList').contains('No items in History');
+		cy.get('#saveHistory').click();
+		cy.get('#editor').type('  C --> HistoryTest');
+		cy.get('#saveHistory').click();
+		cy.get('#editor').type('ing');
+		cy.get('#clearHistory').click();
+		cy.on('window:alert', (str) => {
+			expect(str).to.equal('Clear all saved items?');
+		});
+		cy.on('window:confirm', () => true);
+		cy.get('#historyList').contains('No items in History');
+	});
+
+	it('should auto save history', () => {
+		cy.get('#editor').type('  C --> HistoryTest');
+		cy.tick(70000);
+		cy.contains('Timeline').click();
+		cy.get('#historyList').find('li').should('have.length', 1);
+		cy.get('#editor').type('ing');
+		cy.tick(70000);
+		cy.get('#historyList').find('li').should('have.length', 2);
+		for (let i = 0; i < 31; i++) {
+			cy.get('#editor').type('.');
+			cy.tick(70000);
+		}
+		cy.get('#historyList').find('li').should('have.length', 30);
+	});
+});

cypress/integration/loadSite.spec.ts

@@ -0,0 +1,91 @@
+import { toBase64 } from 'js-base64';
+
+describe('Site Loads', () => {
+	beforeEach(() => {
+		cy.clearLocalStorage();
+	});
+	it('Check Home page load', () => {
+		cy.visit('/');
+		cy.url().should('include', '/edit');
+		cy.contains('History').click();
+		cy.getLocalStorage('codeStore').snapshot();
+	});
+
+	it('Check Redirect from old URL', () => {
+		cy.visit(
+			'/#/edit/eyJjb2RlIjoiZ3JhcGggVERcbiAgICBBW0NocmlzdG1hc10gLS0-fEdldCBtb25leXwgQihHbyBzaG9wcGluZylcbiAgICBCIC0tPiBDe0xldCBtZSB0aGlua31cbiAgICBDIC0tPnxPbmV8IERbTGFwdG9wXVxuICAgIEMgLS0-fFR3b3wgRVtpUGhvbmVdXG4gICAgQyAtLT58VGhyZWV8IEZbZmE6ZmEtY2FyIENhcl0iLCJtZXJtYWlkIjp7InRoZW1lIjoiZGVmYXVsdCJ9LCJ1cGRhdGVFZGl0b3IiOmZhbHNlfQ'
+		);
+		cy.url().should(
+			'include',
+			'/edit/eyJjb2RlIjoiZ3JhcGggVERcbiAgICBBW0NocmlzdG1hc10gLS0-fEdldCBtb25leXwgQihHbyBzaG9wcGluZylcbiAgICBCIC0tPiBDe0xldCBtZSB0aGlua31cbiAgICBDIC0tPnxPbmV8IERbTGFwdG9wXVxuICAgIEMgLS0-fFR3b3wgRVtpUGhvbmVdXG4gICAgQyAtLT58VGhyZWV8IEZbZmE6ZmEtY2FyIENhcl0iLCJtZXJtYWlkIjp7InRoZW1lIjoiZGVmYXVsdCJ9LCJ1cGRhdGVFZGl0b3IiOmZhbHNlfQ'
+		);
+
+		cy.contains('History').click();
+		cy.getLocalStorage('codeStore').snapshot();
+	});
+
+	it('should load sample diagrams when clicked', () => {
+		cy.contains('Sample Diagrams').click();
+		cy.contains('Pie Chart').click();
+		cy.contains('pie title Pets adopted by volunteers');
+		cy.contains('Class Diagram').click();
+		cy.contains('classDiagram');
+	});
+
+	it('should load diagram from gist', () => {
+		cy.visit(`/edit?gist=https://gist.github.com/sidharthv96/6268a23e673a533dcb198f241fd7012a`);
+		cy.contains('History').click();
+		cy.contains('Go shopping!!');
+		cy.contains('Revisions');
+		cy.contains('sidharthv96 v8f8f1e2');
+		cy.contains('sidharthv96 v7851e19');
+		cy.getLocalStorage('codeStore').snapshot();
+	});
+
+	it('should load diagram from gist revision', () => {
+		cy.visit(
+			'/edit?gist=https://gist.github.com/sidharthv96/6268a23e673a533dcb198f241fd7012a/ec9b4ab0e41e4ff6287326cd3cb47affd7851e19'
+		);
+		cy.contains('History').click();
+		cy.contains('Party');
+		cy.contains('Revisions');
+		cy.contains('sidharthv96 v7851e19');
+		cy.getLocalStorage('codeStore').snapshot();
+	});
+
+	it('should load diagram from raw files', () => {
+		cy.visit(
+			'/edit?code=https://gist.githubusercontent.com/sidharthv96/6268a23e673a533dcb198f241fd7012a/raw/4eb03887e6a41397e80bdcdbf94017c498f8f1e2/code.mmd&config=https://gist.githubusercontent.com/sidharthv96/6268a23e673a533dcb198f241fd7012a/raw/4eb03887e6a41397e80bdcdbf94017c498f8f1e2/config.json'
+		);
+		cy.contains('Party');
+		cy.getLocalStorage('codeStore').snapshot();
+	});
+
+	it('should prevent setting the "securityLevel" option via URL', () => {
+		const b64State = toBase64(
+			`{"code":"graph TD\\nA[\\"<img src='https://via.placeholder.com/64' width=64 />\\"]","mermaid":"{\\"securityLevel\\": \\"loose\\", \\"theme\\": \\"forest\\"}","updateEditor":true,"autoSync":true,"updateDiagram":true}`,
+			true
+		);
+		cy.on('window:confirm', () => true);
+		cy.visit(`/edit#${b64State}`);
+		cy.contains('Config').click();
+		cy.contains('forest');
+		cy.contains('securityLevel').should('not.exist');
+		cy.get('#view').find('img').should('not.exist');
+		cy.get('#view').contains('<img');
+		cy.get('#view').contains('src="https://via.placeholder.com/64"');
+	});
+
+	it('should allow persisting "securityLevel" using confirm dialogue', () => {
+		const b64State = toBase64(
+			`{"code":"graph TD\\nA[\\"<img src='https://via.placeholder.com/64' width=64/>\\"]","mermaid":"{\\"securityLevel\\": \\"loose\\", \\"theme\\": \\"forest\\"}","updateEditor":true,"autoSync":true,"updateDiagram":true}`,
+			true
+		);
+		cy.on('window:confirm', () => false);
+		cy.visit(`/edit#${b64State}`);
+		cy.contains('Config').click();
+		cy.contains('forest');
+		cy.contains('securityLevel');
+		cy.get('#view').find('img').should('be.visible');
+	});
+});

cypress/plugins/index.cjs

@@ -0,0 +1,31 @@
+/// <reference types="cypress" />
+// ***********************************************************
+// This example plugins/index.js can be used to load plugins
+//
+// You can change the location of this file or turn off loading
+// the plugins file with the 'pluginsFile' configuration option.
+//
+// You can read more here:
+// https://on.cypress.io/plugins-guide
+// ***********************************************************
+
+// This function is called when a project is opened or re-opened (e.g. due to
+// the project's config changing)
+
+/**
+ * @type {Cypress.PluginConfig}
+ */
+// eslint-disable-next-line no-unused-vars
+import * as fs from 'fs';
+
+module.exports = (on, config) => {
+	on('task', {
+		readFileMaybe(filename) {
+			if (fs.existsSync(filename)) {
+				return fs.readFileSync(filename, 'utf8');
+			}
+
+			return null;
+		}
+	});
+};

cypress/snapshots.js

@@ -0,0 +1,28 @@
+module.exports = {
+  "Site Loads": {
+    "Check Home page load": {
+      "1": "{\"code\":\"graph TD\\n    A[Christmas] -->|Get money| B(Go shopping)\\n    B --> C{Let me think}\\n    C -->|One| D[Laptop]\\n    C -->|Two| E[iPhone]\\n    C -->|Three| F[fa:fa-car Car]\\n  \",\"mermaid\":\"{\\n  \\\"theme\\\": \\\"default\\\"\\n}\",\"updateEditor\":true,\"autoSync\":true,\"updateDiagram\":true}"
+    },
+    "Check Redirect from old URL": {
+      "1": "{\"code\":\"graph TD\\n    A[Christmas] -->|Get money| B(Go shopping)\\n    B --> C{Let me think}\\n    C -->|One| D[Laptop]\\n    C -->|Two| E[iPhone]\\n    C -->|Three| F[fa:fa-car Car]\",\"mermaid\":\"{\\n  \\\"theme\\\": \\\"default\\\"\\n}\",\"updateEditor\":false,\"autoSync\":true,\"updateDiagram\":true}"
+    },
+    "should load diagram from gist": {
+      "1": "{\"code\":\"graph TD\\n    A[Party] -->|Get money| B(Go shopping!!)\\n    \",\"mermaid\":\"{\\n  \\\"theme\\\": \\\"forest\\\",\\n  \\\"test\\\": \\\"hello world\\\"\\n}\",\"updateEditor\":false,\"autoSync\":true,\"updateDiagram\":true,\"loader\":{\"type\":\"gist\",\"config\":{\"url\":\"https://gist.github.com/sidharthv96/6268a23e673a533dcb198f241fd7012a\"}}}"
+    },
+    "should load diagram from gist revision": {
+      "1": "{\"code\":\"graph TD\\n    A[Party] -->|Get money| B(Go shopping)\\n    \",\"mermaid\":\"{\\n  \\\"theme\\\": \\\"forest\\\",\\n  \\\"test\\\": \\\"hello\\\"\\n}\",\"updateEditor\":false,\"autoSync\":true,\"updateDiagram\":true,\"loader\":{\"type\":\"gist\",\"config\":{\"url\":\"https://gist.github.com/sidharthv96/6268a23e673a533dcb198f241fd7012a/ec9b4ab0e41e4ff6287326cd3cb47affd7851e19\"}}}"
+    },
+    "should load diagram from raw files": {
+      "1": "{\"code\":\"graph TD\\n    A[Party] -->|Get money| B(Go shopping!!)\\n    \",\"mermaid\":\"{\\n  \\\"theme\\\": \\\"forest\\\",\\n  \\\"test\\\": \\\"hello world\\\"\\n}\",\"updateEditor\":false,\"autoSync\":true,\"updateDiagram\":true,\"loader\":{\"type\":\"files\",\"config\":{\"codeURL\":\"https://gist.githubusercontent.com/sidharthv96/6268a23e673a533dcb198f241fd7012a/raw/4eb03887e6a41397e80bdcdbf94017c498f8f1e2/code.mmd\",\"configURL\":\"https://gist.githubusercontent.com/sidharthv96/6268a23e673a533dcb198f241fd7012a/raw/4eb03887e6a41397e80bdcdbf94017c498f8f1e2/config.json\"}}}"
+    }
+  },
+  "__version": "8.3.1",
+  "Auto sync tests": {
+    "should dim diagram when code is edited": {
+      "1": "{\"code\":\"graph TD\\n    A[Christmas] -->|Get money| B(Go shopping)\\n    B --> C{Let me think}\\n    C -->|One| D[Laptop]\\n    C -->|Two| E[iPhone]\\n    C -->|Three| F[fa:fa-car Car]\\n    C --> Test\",\"mermaid\":\"{\\n  \\\"theme\\\": \\\"default\\\"\\n}\",\"updateEditor\":false,\"autoSync\":false,\"updateDiagram\":false}"
+    },
+    "should not dim diagram when code is in sync": {
+      "1": "{\"code\":\"graph TD\\n    A[Christmas] -->|Get money| B(Go shopping)\\n    B --> C{Let me think}\\n    C -->|One| D[Laptop]\\n    C -->|Two| E[iPhone]\\n    C -->|Three| F[fa:fa-car Car]\\n    C --> Testing\",\"mermaid\":\"{\\n  \\\"theme\\\": \\\"default\\\"\\n}\",\"updateEditor\":false,\"autoSync\":true,\"updateDiagram\":false}"
+    }
+  }
+}

cypress/support/commands.ts

@@ -0,0 +1,38 @@
+// ***********************************************
+// This example commands.js shows you how to
+// create various custom commands and overwrite
+// existing commands.
+//
+// For more comprehensive examples of custom
+// commands please read more here:
+// https://on.cypress.io/custom-commands
+// ***********************************************
+//
+//
+// -- This is a parent command --
+// Cypress.Commands.add('login', (email, password) => { ... })
+//
+//
+// -- This is a child command --
+// Cypress.Commands.add('drag', { prevSubject: 'element'}, (subject, options) => { ... })
+//
+//
+// -- This is a dual command --
+// Cypress.Commands.add('dismiss', { prevSubject: 'optional'}, (subject, options) => { ... })
+//
+//
+// -- This will overwrite an existing command --
+// Cypress.Commands.overwrite('visit', (originalFn, url, options) => { ... })
+import { register } from '@cypress/snapshot';
+// eslint-disable-next-line @typescript-eslint/no-unsafe-call
+register();
+declare global {
+	// eslint-disable-next-line @typescript-eslint/no-namespace
+	namespace Cypress {
+		interface Chainable {
+			snapshot(): void;
+		}
+	}
+}
+
+import 'cypress-localstorage-commands';

cypress/support/index.js

@@ -0,0 +1,27 @@
+// ***********************************************************
+// This example support/index.js is processed and
+// loaded automatically before your test files.
+//
+// This is a great place to put global configuration and
+// behavior that modifies Cypress.
+//
+// You can change the location of this file or turn off
+// automatically serving support files with the
+// 'supportFile' configuration option.
+//
+// You can read more here:
+// https://on.cypress.io/configuration
+// ***********************************************************
+
+// Import commands.js using ES2015 syntax:
+import './commands';
+
+// Alternatively you can use CommonJS syntax:
+// require('./commands')
+
+Cypress.on('uncaught:exception', (err) => {
+	/* returning false here prevents Cypress from failing the test */
+	if (err.message.includes('ResizeObserver loop limit exceeded')) {
+		return false;
+	}
+});

cypress/tsconfig.json

@@ -0,0 +1,7 @@
+{
+	"compilerOptions": {
+		"allowJs": true,
+		"types": ["cypress", "cypress-localstorage-commands"]
+	},
+	"include": ["**/*.ts"]
+}

docs/1065.1065.js

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

docs/1134.1134.js

@@ -1,391 +0,0 @@
-(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

@@ -1,229 +0,0 @@
-(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

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

docs/1448.1448.js

@@ -1,150 +0,0 @@
-(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

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

docs/180.180.js

@@ -1,421 +0,0 @@
-(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

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

docs/1960.1960.js

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

docs/2060.2060.js

@@ -1,112 +0,0 @@
-(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

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

docs/2140.2140.js

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

docs/249.249.js

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

docs/2571.2571.js

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

docs/2798.2798.js

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

docs/2892.2892.js

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

docs/2911.2911.js

@@ -1,245 +0,0 @@
-/*! 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

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

docs/2954.2954.js

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

docs/3036.3036.js

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

docs/3585.3585.js

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

docs/3632.3632.js

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

docs/3919.3919.js

@@ -1,183 +0,0 @@
-(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

@@ -1,97 +0,0 @@
-(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

@@ -1,245 +0,0 @@
-(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

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

docs/4407.4407.js

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

docs/4902.4902.js

@@ -1,96 +0,0 @@
-(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

@@ -1,167 +0,0 @@
-(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

@@ -1,500 +0,0 @@
-(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

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

docs/525.525.js

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

docs/5593.5593.js

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

docs/5703.5703.js

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

docs/5849.5849.js

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

docs/6082.6082.js

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

docs/6241.6241.js

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

docs/6424.6424.js

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

docs/6449.6449.js

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

docs/6489.6489.js

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

docs/6587.6587.js

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

docs/6717.6717.js

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

docs/7043.7043.js

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

docs/7287.7287.js

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

docs/7562.7562.js

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

docs/7637.7637.js

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

docs/7835.7835.js

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

docs/8070.8070.js

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

docs/8084.8084.js

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

docs/8180.8180.js

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

docs/8424.8424.js

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

docs/854.854.js

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

docs/8670.8670.js

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

docs/8715.8715.js

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

docs/8719.8719.js

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

docs/8946.8946.js

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

docs/911.911.js

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

docs/9343.9343.js

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

docs/9398.9398.js

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

docs/9537.9537.js

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

docs/9684.9684.js

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

docs/9907.9907.js

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